diff -r c55016431358 -r 0a7b44b10206 symport/e32/euser/us_exec.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/symport/e32/euser/us_exec.cpp Thu Jun 25 15:59:54 2009 +0100 @@ -0,0 +1,6664 @@ +// 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 "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\euser\us_exec.cpp +// +// + +#include "us_std.h" +#include "us_data.h" +#include +#include +#include +#include "compareimp.h" + +#ifdef __VC32__ + #pragma setlocale("english") +#endif + +#ifdef __TOOLS2__ +#include + +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: +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); + } + + + +#ifndef __TOOLS2__ +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 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(); + } +#endif // __TOOLS2__ + + + +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 +*/ + { +#ifndef __TOOLS2__ + TInt i=(-1); + do + { + i++; + Exec::WaitForAnyRequest(); + } while (aStatus==KRequestPending); + if (i) + Exec::RequestSignal(i); +#else + // There's been no need to implement an active scheduler yet for TOOLS2 +#endif // __TOOLS2__ + } + + + +#ifndef __TOOLS2__ +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 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 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 aStatArray[] A reference to the request status object associated with the + first specific asynchronous request. +@param TInt aNum +*/ + { + TRequestStatus* aptr; + TBool m = ETrue; + TInt i = (-1); + do + { + i++; + Exec::WaitForAnyRequest(); + for(TInt j = 0; jInt()!= 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)); + } +#endif // __TOOLS2__ + +/** +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()); + } + + + +#ifndef __TOOLS2__ + +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(); + } +#endif // __TOOLS2__ + + + +/** +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(); + } + + + +#ifndef __TOOLS2__ + +/** +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. + +@return The fast counter value. +*/ +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); + } +#endif // __TOOLS2__ + + + +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. +*/ + { +#ifndef __TOOLS2__ + return(GetHeap()->AllocLen(aCell)); +#else + TUint8* p = ((TUint8*)aCell) - sizeof(TInt); + return *((TInt*)p); +#endif // __TOOLS2__ + } + + + + +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. +*/ + { +#ifndef __TOOLS2__ + return(GetHeap()->Alloc(aSize)); +#else +#ifdef _DEBUG + // Simulate heap failure + gAllocCount++; + switch (gAllocFailType) + { + case RAllocator::EFailNext: + if (gAllocCount == gAllocFailRate) + return NULL; + break; + case RAllocator::EDeterministic: + if (gAllocCount % gAllocFailRate == 0) + return NULL; + break; + default: + break; + } +#endif // _DEBUG + TUint8* p = (TUint8*)malloc(aSize + sizeof(TInt)); + if ( p == NULL ) { + return NULL; + } + *((TInt*)p) = aSize; + return p + sizeof(TInt); +#endif // __TOOLS2__ + } + + + + +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. +*/ + { +#ifndef __TOOLS2__ + return(GetHeap()->AllocL(aSize)); +#else + TAny* p = User::Alloc(aSize); + if (!p) + User::LeaveNoMemory(); + return p; +#endif // __TOOLS2__ + } + + + + +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. +*/ + { +#ifndef __TOOLS2__ + return(GetHeap()->AllocLC(aSize)); +#else + TAny* p = User::AllocL(aSize); + CleanupStack::PushL(p); + return p; +#endif // __TOOLS2__ + } + + + + +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. +*/ + { +#ifndef __TOOLS2__ + return GetHeap()->AllocZ(aSize); +#else + TAny* p = User::Alloc(aSize); + if (p) + memset(p, '\0', aSize); + return p; +#endif // __TOOLS2__ + } + + + + +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. +*/ + { +#ifndef __TOOLS2__ + return GetHeap()->AllocZL(aSize); +#else + TAny* p = User::AllocZ(aSize); + if (!p) + User::LeaveNoMemory(); + return p; +#endif // __TOOLS2__ + } + + + +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. +*/ + { +#ifndef __TOOLS2__ + return(GetHeap()->Available(aBiggestBlock)); +#else + aBiggestBlock = 0x100000; + return 0x40000000; +#endif // __TOOLS2__ + } + + + +#ifndef __TOOLS2__ +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(); + } +#endif // __TOOLS2__ + + + +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. +*/ + { +#ifndef __TOOLS2__ + if (aCell) + GetHeap()->Free(aCell); +#else + if (aCell) + { + TUint8* p = ((TUint8*)aCell) - sizeof(TInt); + free(p); + } +#endif // __TOOLS2__ + } + + + + +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. +*/ + { +#ifndef __TOOLS2__ + if (aCell) + GetHeap()->FreeZ(aCell); +#else + User::Free(aCell); + aCell = NULL; +#endif // __TOOLS2__ + } + + + + +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 +*/ + { +#ifndef __TOOLS2__ + return GetHeap()->ReAlloc(aCell, aSize, aMode); +#else + if (!aCell) + return User::Alloc(aSize); + else + { +#ifdef _DEBUG + // Simulate heap failure + gAllocCount++; + switch (gAllocFailType) + { + case RAllocator::EFailNext: + if (gAllocCount == gAllocFailRate) + return NULL; + break; + case RAllocator::EDeterministic: + if (gAllocCount % gAllocFailRate == 0) + return NULL; + break; + default: + break; + } +#endif // _DEBUG + TUint8* o = ((TUint8*)aCell) - sizeof(TInt); + TUint8* n = (TUint8*)realloc(o, aSize + sizeof(TInt)); + if (n) + { + *((TInt*)n) = aSize; + return n + sizeof(TInt); + } + } + return NULL; +#endif // __TOOLS2__ + } + + + + +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 +*/ + { +#ifndef __TOOLS2__ + return GetHeap()->ReAllocL(aCell, aSize, aMode); +#else + TAny* p = ReAlloc(aCell, aSize, aMode); + if (!p) + User::LeaveNoMemory(); + return p; +#endif // __TOOLS2__ + } + + + +#ifndef __TOOLS2__ +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); + } +#endif // __TOOLS2__ + +// 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) + }; + +#ifdef __TOOLS2__ +TPckgBuf gLocale; +// gLocale.iLocale set, does not guarantee gLocale's other members are loaded. +TBool gLocaleSet = EFalse; +// gLocale set, all members of gLoacle loaded except iLocale, which is not guaranteed loaded or not. +TBool gLocaleExSet = EFalse; +#endif + +LOCAL_C void LocaleLanguageGet(SLocaleLanguage& locale) + { +#ifndef __TOOLS2__ + TPckg localeLanguageBuf(locale); + TInt r = RProperty::Get(KUidSystemCategory, KLocaleLanguageKey, localeLanguageBuf); + __ASSERT_DEBUG(r == KErrNone || r == KErrNotFound, Panic(EBadLocaleParameter)); +#else + TInt r = KErrNone; + if (gLocaleExSet) + { + SLocaleLanguage* languageSettings = gLocale().GetLanguageSettings(); + memcpy(&locale, (void*)languageSettings, sizeof(SLocaleLanguage)); + } + else + r = KErrNotFound; +#endif // __TOOLS2__ + + 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) + { +#ifndef __TOOLS2__ + TPckg localeSettingsBuf(locale); + TInt r = RProperty::Get(KUidSystemCategory, KLocaleDataExtraKey, localeSettingsBuf); + __ASSERT_DEBUG(r == KErrNone || r == KErrNotFound, Panic(EBadLocaleParameter)); +#else + TInt r = KErrNone; + if (gLocaleExSet) + { + SLocaleLocaleSettings* extraSettings = gLocale().GetLocaleExtraSettings(); + memcpy(&locale, extraSettings, sizeof(SLocaleLocaleSettings)); + } + else + r = KErrNotFound; +#endif // __TOOLS2__ + + if(r == KErrNotFound) + { + Mem::Copy(&locale.iCurrencySymbol[0], _S16("\x00a3"), sizeof(TText16) << 2); + locale.iLocaleExtraSettingsDllPtr = NULL; + } + } + +LOCAL_C void LocaleTimeDateFormatGet(SLocaleTimeDateFormat& locale) + { +#ifndef __TOOLS2__ + TPckg localeTimeDateFormatBuf(locale); + TInt r = RProperty::Get(KUidSystemCategory, KLocaleTimeDateFormatKey, localeTimeDateFormatBuf); + __ASSERT_DEBUG(r == KErrNone || r == KErrNotFound, Panic(EBadLocaleParameter)); +#else + TInt r = KErrNone; + if (gLocaleExSet) + { + SLocaleTimeDateFormat* timeDateFormat = gLocale().GetLocaleTimeDateFormat(); + memcpy(&locale, timeDateFormat, sizeof(SLocaleTimeDateFormat)); + } + else + r = KErrNotFound; +#endif // __TOOLS2__ + 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(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(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(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(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(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(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 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 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(); + } +#else + + if (gLocaleSet) + { + TLocale* loc = gLocale().GetLocale(); + memcpy(this, (void*)loc, sizeof(TLocale)); + } + else + { + SetDefaults(); + } + +#endif // __TOOLS2__ + } + + +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 +the system copy. + +@capability WriteDeviceData + +@return KErrNone if successful, otherwise one of the other system wide error codes. + +@see TLocale::Refresh() +*/ + { +#ifndef __TOOLS2__ + TPckg localeDataBuf(*this); + TInt r = RProperty::Set(KUidSystemCategory, KLocaleDataKey, localeDataBuf); + if(r == KErrNone) + { + Exec::NotifyChanges(EChangesLocale); + } + return r; +#else + TLocale* loc = gLocale().GetLocale(); + memcpy((void*)loc, this, sizeof(TLocale)); + gLocaleSet = ETrue; + return KErrNone; +#endif + } + + +#ifdef __TOOLS2__ +RLoader gLocaleLoader; +#endif + +TInt TExtendedLocale::DoLoadLocale(const TDesC& aLocaleDllName, TLibraryFunction* aExportList) + { +#ifndef __TOOLS2__ + RLoader loader; + TInt r = loader.LoadLocale(aLocaleDllName, aExportList); + return r; +#else + gLocaleLoader.Free(); + TInt r = gLocaleLoader.LoadLocale(aLocaleDllName, aExportList); + return r; +#endif + } + +void TExtendedLocale::DoUpdateLanguageSettings(TLibraryFunction* aExportList) + { + iLanguageSettings.iLanguage = (TLanguage)aExportList[FnLanguage](); + iLanguageSettings.iDateSuffixTable = (const TText*)aExportList[FnDateSuffixTable](); + iLanguageSettings.iDayTable = (const TText*)aExportList[FnDayTable](); + iLanguageSettings.iDayAbbTable = (const TText*)aExportList[FnDayAbbTable](); + iLanguageSettings.iMonthTable = (const TText*)aExportList[FnMonthTable](); + iLanguageSettings.iMonthAbbTable = (const TText*)aExportList[FnMonthAbbTable](); + iLanguageSettings.iAmPmTable = (const TText*)aExportList[FnAmPmTable](); + iLanguageSettings.iMsgTable = (const TText16* const*)aExportList[FnMsgTable](); + } + +void TExtendedLocale::DoUpdateLocaleSettings(TLibraryFunction* aExportList) + { + Mem::Copy(&iLocaleExtraSettings.iCurrencySymbol[0], (const TAny*)aExportList[FnCurrencySymbol](), sizeof(TText) * (KMaxCurrencySymbol+1)); + iLocaleExtraSettings.iLocaleExtraSettingsDllPtr = (TAny*)aExportList[FnDateSuffixTable](); + } + +void TExtendedLocale::DoUpdateTimeDateFormat(TLibraryFunction* aExportList) + { + Mem::Copy(&iLocaleTimeDateFormat.iShortDateFormatSpec[0], (const TAny*)aExportList[FnShortDateFormatSpec](), sizeof(TText) * (KMaxShortDateFormatSpec+1)); + Mem::Copy(&iLocaleTimeDateFormat.iLongDateFormatSpec[0], (const TAny*)aExportList[FnLongDateFormatSpec](), sizeof(TText) * (KMaxLongDateFormatSpec+1)) ; + Mem::Copy(&iLocaleTimeDateFormat.iTimeFormatSpec[0], (const TAny*)aExportList[FnTimeFormatSpec](), sizeof(TText) * (KMaxTimeFormatSpec+1)); + iLocaleTimeDateFormat.iLocaleTimeDateFormatDllPtr = (TAny*)aExportList[FnDateSuffixTable](); + } + +/** +Default constructor. + +It constructs an empty object + +This is an empty copy of TExtendedLocale. To get the system locale you can +use TExtendedLocale::LoadSystemSettings. The current settings may be saved to the system +with TLocale::SaveSystemSettings(). + +@see TExtendedLocale::LoadSystemSettings +@see TExtendedLocale::SaveSystemSettings +*/ +EXPORT_C TExtendedLocale::TExtendedLocale() + : iLocale(0) + { + Mem::FillZ(&iLanguageSettings, sizeof(TExtendedLocale) - sizeof(TLocale)); + } + +/** +Load system wide locale settings + +It initialises this TExtendedLocale with the system wide locale settings. +The settings stored in the TExtendedLocale are overwritten with the system +wide locale. + +@see TExtendedLocale::SaveSystemSettings +*/ +EXPORT_C void TExtendedLocale::LoadSystemSettings() + { + LocaleLanguageGet(iLanguageSettings); + LocaleSettingsGet(iLocaleExtraSettings); + LocaleTimeDateFormatGet(iLocaleTimeDateFormat); + iDefaultCharSet = GetLocaleCharSet(); + iPreferredCharSet = GetLocalePreferredCharSet(); + iLocale.Refresh(); + } + +#ifndef __TOOLS2__ +/** +Make the current locale information system wide + +It overwrites the system wide locale information with the locale information +stored in this TExtendedLocale. +This will generate a notification for system locale changes. +In case of an error, the locale might be in an unconsistent state. + +@capability WriteDeviceData + +@return KErrNone if successful, otherwise one of the other system wide error codes. +*/ +EXPORT_C TInt TExtendedLocale::SaveSystemSettings() + { + + TPckg localeLanguageBuf(iLanguageSettings); + TInt r = RProperty::Set(KUidSystemCategory, KLocaleLanguageKey, localeLanguageBuf); + if(r != KErrNone) + return r; + + TPckg localeSettingsBuf(iLocaleExtraSettings); + r = RProperty::Set(KUidSystemCategory, KLocaleDataExtraKey, localeSettingsBuf); + if(r != KErrNone) + return r; + + TPckg localeTimeDateFormatBuf(iLocaleTimeDateFormat); + r = RProperty::Set(KUidSystemCategory, KLocaleTimeDateFormatKey, localeTimeDateFormatBuf); + if(r != KErrNone) + return r; + + r = Exec::SetGlobalUserData(ELocaleDefaultCharSet, (TInt)iDefaultCharSet); + if(r != KErrNone) + return r; + + r = Exec::SetGlobalUserData(ELocalePreferredCharSet, (TInt)iPreferredCharSet); + + if(r == KErrNone) + { + iLocale.Set(); + } + + return r; + } +#endif // __TOOLS2__ + + +/** +Loads a locale Dll and get the locale information + +It loads a locale DLL and it initialises the contents of this TExtendedLocale +with the locale information stored in the DLL. The locale information is only +stored in this TExtendedLocale. If you want to set the system wide settings with +the locale information in the DLL, you can call TExtendedLocale::SaveSystemSettings +after calling this function. + +@param aLocaleDllName The name of the locale DLL to be loaded +@return KErrNone if successful, system wide error if not + +@see TExtendedLocale::SaveSystemSettings +*/ +EXPORT_C TInt TExtendedLocale::LoadLocale(const TDesC& aLocaleDllName) + { + TLibraryFunction data[KNumLocaleExports]; + TInt r = DoLoadLocale(aLocaleDllName, &data[0]); + if(r == KErrNone) + { + iLocale.iExtraNegativeCurrencyFormatFlags=0x80000000; + iLocale.iLanguageDowngrade[0] = ELangNone; + iLocale.iLanguageDowngrade[1] = ELangNone; + iLocale.iLanguageDowngrade[2] = ELangNone; + iLocale.iDigitType = EDigitTypeWestern; + + typedef void (*TLibFn)(TLocale*); + ((TLibFn)data[FnLocaleData])(&iLocale); + + //Locale daylightsavings unchanged - we have travelled through space, not time + if (iLocale.iExtraNegativeCurrencyFormatFlags&0x80000000) + iLocale.iExtraNegativeCurrencyFormatFlags=0; + + DoUpdateLanguageSettings(&data[0]); + DoUpdateLocaleSettings(&data[0]); + DoUpdateTimeDateFormat(&data[0]); + + iPreferredCharSet = (const LCharSet*)data[FnCharSet](); + iDefaultCharSet = iPreferredCharSet; + gLocaleSet = ETrue; + gLocaleExSet = ETrue; + } + return r; + } + +/** +Loads a DLL and get some locale information + +It loads the specified locale DLL and depending on the aAspectGroup it overwrites +locale information in this TExtendedLocale with the locale information stored in the +DLL. aAspectGroup is a bitmap of TLocaleAspect values specifying what to be overwritten. +The locale information is only stored in this TExtendedLocale. If you want to set the +system wide settings with the locale information in the DLL, you can call +TExtendedLocale::SaveSystemSettings after calling this function. + +@param aAspectGroup A bitmap of TLocaleAspect values specifying what to be overwritten in + this TExtendedLocale. (eg.: ELocaleLanguageSettings | ELocaleTimeDateSettings) +@param aLocaleDllName The name of the locale DLL to be loaded + +@return KErrNone if the method is successful, a system wide error code if not + +@see TLocaleAspect +@see TExtendedLocale::SaveSystemSettings +*/ +EXPORT_C TInt TExtendedLocale::LoadLocaleAspect(TUint aAspectGroup, const TDesC& aLocaleDllName) + { + TLibraryFunction data[KNumLocaleExports]; + TInt r = DoLoadLocale(aLocaleDllName, &data[0]); + if(r == KErrNone) + { + if(aAspectGroup & ELocaleLanguageSettings) + { + DoUpdateLanguageSettings(&data[0]); + } + if(aAspectGroup & ELocaleCollateSetting) + { + iPreferredCharSet = (const LCharSet*)data[FnCharSet](); + iDefaultCharSet = iPreferredCharSet; + } + if(aAspectGroup & ELocaleLocaleSettings) + { + DoUpdateLocaleSettings(&data[0]); + } + if(aAspectGroup & ELocaleTimeDateSettings) + { + DoUpdateTimeDateFormat(&data[0]); + } + } + return r; + } + +/** +Sets the currency symbol + +It sets the currency symbol. The maximum lenght for the currency symbol is +KMaxCurrencySymbol. Trying to pass a descriptor longer than that, will result +in a panic. + +@param aSymbol The new currency symbol + +@panic USER 119, if the length of aSymbol is greater than KMaxCurrencySymbol. + +@capability WriteDeviceData + +@return KErrNone if successful, otherwise one of the other system wide error codes. +*/ +EXPORT_C TInt TExtendedLocale::SetCurrencySymbol(const TDesC &aSymbol) + { + __ASSERT_ALWAYS(aSymbol.Length()<=KMaxCurrencySymbol,::Panic(ECurrencySymbolOverflow)); + + LocaleSettingsGet(iLocaleExtraSettings); + Mem::Copy(&iLocaleExtraSettings.iCurrencySymbol[0], aSymbol.Ptr(), aSymbol.Length() << 1); + iLocaleExtraSettings.iCurrencySymbol[aSymbol.Length()] = 0; +#ifndef __TOOLS2__ + TInt r = RProperty::Set(KUidSystemCategory, KLocaleDataExtraKey, TPckg(iLocaleExtraSettings)); + return r; +#else + return KErrNone; +#endif + } + + +#ifndef __TOOLS2__ +/** +Returns the name of the DLL containing the given bits of locale information + +Given the bits of locale information specified in aLocaleDataSet, it returns the name +of the locale DLL storing the information. TExtendedLocale can contain information from +different DLLs. + +@param aLocaleDataSet The TLocaleAspect specifying a group of locale properties +@param aDllName The descriptor that will contain the name of DLL containing the specifying + bits of locale information (valid if the method is successful) + +@return KErrNone if successful, system wide error otherwise +*/ +EXPORT_C TInt TExtendedLocale::GetLocaleDllName(TLocaleAspect aLocaleDataSet, TDes& aDllName) + { + TBuf8 buf; + TAny* ptr = 0; + switch(aLocaleDataSet) + { + case ELocaleLanguageSettings: + ptr = (TAny*)iLanguageSettings.iDateSuffixTable; + break; + case ELocaleCollateSetting: + ptr = (TAny*)iPreferredCharSet; + break; + case ELocaleLocaleSettings: + ptr = (TAny*)iLocaleExtraSettings.iLocaleExtraSettingsDllPtr; + break; + case ELocaleTimeDateSettings: + ptr = (TAny*)iLocaleTimeDateFormat.iLocaleTimeDateFormatDllPtr; + break; + } + TInt r = Exec::GetModuleNameFromAddress(ptr, buf); + if (r == KErrNone) + { + aDllName.Copy(buf); + } + return r; + } +#endif // __TOOLS2__ + +/** +Get the Currency Symbol from SLocaleLocaleSettings object + +@return TPtrC Pointer holding the Currency Symbol +*/ +EXPORT_C TPtrC TExtendedLocale::GetCurrencySymbol() + { + TPtrC outCurrencySymbolPtr(iLocaleExtraSettings.iCurrencySymbol); + return outCurrencySymbolPtr; + } + +/** +Get the Long Date Format from SLocaleTimeDateFormat object + +@return TPtrC Pointer holding the Long Date Format +*/ +EXPORT_C TPtrC TExtendedLocale::GetLongDateFormatSpec() + { + TPtrC outLongDateFormatPtr(iLocaleTimeDateFormat.iLongDateFormatSpec); + return outLongDateFormatPtr; + } + +/** +Get the Short Date Format from SLocaleTimeDateFormat object + +@return TPtrC Pointer holding the Short Date Format +*/ +EXPORT_C TPtrC TExtendedLocale::GetShortDateFormatSpec() + { + TPtrC outShortDateFormatPtr(iLocaleTimeDateFormat.iShortDateFormatSpec); + return outShortDateFormatPtr; + } + +/** +Get the Time Format from SLocaleTimeDateFormat object + +@return TPtrC Pointer holding the Time Format +*/ +EXPORT_C TPtrC TExtendedLocale::GetTimeFormatSpec() + { + TPtrC outTimeFormatPtr(iLocaleTimeDateFormat.iTimeFormatSpec); + return outTimeFormatPtr; + } + +#ifndef __TOOLS2__ +EXPORT_C TInt UserSvr::LocalePropertiesSetDefaults() + { + _LIT_SECURITY_POLICY_C1(KLocaleWritePolicy,ECapabilityWriteDeviceData); + _LIT_SECURITY_POLICY_PASS(KLocaleReadPolicy); + + TInt r = RProperty::Define(KUidSystemCategory, KLocaleLanguageKey, RProperty::EByteArray, KLocaleReadPolicy, KLocaleWritePolicy, sizeof(TPckg)); + if(r != KErrNone && r != KErrAlreadyExists) + return r; + + SLocaleLanguage localeLanguage; + localeLanguage.iLanguage = ELangEnglish; + localeLanguage.iDateSuffixTable = (const TText16*)__DefaultDateSuffixTable; + localeLanguage.iDayTable = (const TText16*)__DefaultDayTable; + localeLanguage.iDayAbbTable = (const TText16*)__DefaultDayAbbTable; + localeLanguage.iMonthTable = (const TText16*)__DefaultMonthTable; + localeLanguage.iMonthAbbTable = (const TText16*)__DefaultMonthAbbTable; + localeLanguage.iAmPmTable = (const TText16*)__DefaultAmPmTable; + localeLanguage.iMsgTable = (const TText16* const*)__DefaultLMsgTable; + r = RProperty::Set(KUidSystemCategory, KLocaleLanguageKey, TPckg(localeLanguage)); + if(r != KErrNone) + return r; + + r = RProperty::Define(KUidSystemCategory, KLocaleDataKey, RProperty::EByteArray, KLocaleReadPolicy, KLocaleWritePolicy, sizeof(TPckg)); + if(r != KErrNone && r != KErrAlreadyExists) + return r; + + TLocale locale(0); + locale.SetDefaults(); + + r = RProperty::Set(KUidSystemCategory, KLocaleDataKey, TPckg(locale)); + if(r != KErrNone) + return r; + + r = RProperty::Define(KUidSystemCategory, KLocaleDataExtraKey, RProperty::EByteArray, KLocaleReadPolicy, KLocaleWritePolicy, sizeof(TPckg)); + if(r != KErrNone && r != KErrAlreadyExists) + return r; + + SLocaleLocaleSettings localeSettings; + Mem::Copy(&localeSettings.iCurrencySymbol[0], _S16("\x00a3"), sizeof(TText16) * 2); + + r = RProperty::Set(KUidSystemCategory, KLocaleDataExtraKey, TPckg(localeSettings)); + if(r != KErrNone) + return r; + + r = RProperty::Define(KUidSystemCategory, KLocaleTimeDateFormatKey, RProperty::EByteArray, KLocaleReadPolicy, KLocaleWritePolicy, sizeof(TPckg)); + if(r != KErrNone && r != KErrAlreadyExists) + return r; + + SLocaleTimeDateFormat localeTimeDateFormat; + Mem::Copy(&localeTimeDateFormat.iShortDateFormatSpec[0], _S16("%F%*D/%*M/%Y"), sizeof(TText16) * 13); + Mem::Copy(&localeTimeDateFormat.iLongDateFormatSpec[0], _S16("%F%*D%X %N %Y"), sizeof(TText16) * 14); + Mem::Copy(&localeTimeDateFormat.iTimeFormatSpec[0], _S16("%F%*I:%T:%S %*A"), sizeof(TText16) * 16); + + r = RProperty::Set(KUidSystemCategory, KLocaleTimeDateFormatKey, TPckg(localeTimeDateFormat)); + if(r != KErrNone) + return r; + + TInt charSet = (TInt)GetLocaleDefaultCharSet(); + r = Exec::SetGlobalUserData(ELocaleDefaultCharSet, charSet); + if(r != KErrNone) + return r; + + r = Exec::SetGlobalUserData(ELocalePreferredCharSet, charSet); + + return r; + } +#endif // __TOOLS2__ + +// TOverflowHandler class created to handle the descriptor overflow in TLoacle::FormatCurrency +NONSHARABLE_CLASS(TOverflowHandler) : public TDesOverflow + { + void Overflow(TDes& aDes); + }; + +void TOverflowHandler::Overflow(TDes&) + { + Panic(ETDes16Overflow); + } + + + + +EXPORT_C void TLocale::FormatCurrency(TDes& aText, TInt aAmount) +/** +Renders a currency value as text, based on the locale's currency and numeric +format settings. + +These settings include the currency symbol, the symbol's position and the +way negative values are formatted. + +@param aText On return, contains the currency value as text, formatted + according to the locale's currency format settings. +@param aAmount The currency value to be formatted. + +@panic USER 11, if aText is not long enough to hold the formatted value. +*/ + { + TOverflowHandler overflowHandler; + FormatCurrency(aText,overflowHandler,aAmount); + } + + + + +EXPORT_C void TLocale::FormatCurrency(TDes& aText, TInt64 aAmount) +/** +Renders a currency value as text, based on the locale's currency and numeric +format settings. + +These settings include the currency symbol, the symbol's position and the +way negative values are formatted. + +@param aText On return, contains the currency value as text, formatted + according to the locale's currency format settings. +@param aAmount The currency value to be formatted. + +@panic USER 11, if aText is not long enough to hold the formatted value. +*/ + { + TOverflowHandler overflowHandler; + FormatCurrency(aText,overflowHandler, aAmount); + } + + + + +EXPORT_C void TLocale::FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt aAmount) +/** +Renders a currency value as text, based on the locale's currency and numeric +format settings. + +These settings include the currency symbol, the symbol's position and the +way negative values are formatted. If aText is not long enough to hold the +formatted currency value, the overflow handler's Overflow() function is called. + +@param aText On return, contains the currency value as text, + formatted according to the locale's currency format + settings. +@param aOverflowHandler An object derived from TDesOverflow which handles + descriptor overflows. +@param aAmount The currency value to be formatted. +*/ + { + TInt64 aLongerInt(aAmount); + FormatCurrency(aText, aOverflowHandler, aLongerInt); + } + + + + +EXPORT_C void TLocale::FormatCurrency(TDes& aText, TDesOverflow& aOverflowHandler, TInt64 aAmount) +/** +Renders a currency value as text, based on the locale's currency and numeric +format settings. + +These settings include the currency symbol, the symbol's position and the +way negative values are formatted. If aText is not long enough to hold the +formatted currency value, the overflow handler's Overflow() function is called. + +@param aText On return, contains the currency value as text, + formatted according to the locale's currency format + settings. +@param aOverflowHandler An object derived from TDesOverflow which handles + descriptor overflows. +@param aAmount The currency value to be formatted. +*/ + { + // aAmount is in cents (or equivalent) rather than dollars (or equivalent) + const TBool amountIsNegative=(aAmount<0); + if (amountIsNegative) + { + aAmount=-aAmount; + } + aText.Num(aAmount, EDecimal); + const TInt currencyDecimalPlaces=CurrencyDecimalPlaces(); + TInt positionOfDecimalSeparator=aText.Length(); + if (currencyDecimalPlaces>0) + { + while (positionOfDecimalSeparator <= currencyDecimalPlaces) + { + if (aText.Length() == aText.MaxLength()) + { + aOverflowHandler.Overflow(aText); + return; + } + aText.Insert(0,KLitZeroPad); + ++positionOfDecimalSeparator; + } + positionOfDecimalSeparator=aText.Length(); + positionOfDecimalSeparator-=currencyDecimalPlaces; + TBuf<1> decimalSeparator; + decimalSeparator.Append(DecimalSeparator()); + if (aText.Length() == aText.MaxLength()) + { + aOverflowHandler.Overflow(aText); + return; + } + aText.Insert(positionOfDecimalSeparator, decimalSeparator); + } + if (CurrencyTriadsAllowed()) + { + TBuf<1> thousandsSeparator; + thousandsSeparator.Append(ThousandsSeparator()); + TInt numberOfThousandsSeparator = positionOfDecimalSeparator/3; + if ((aText.Length()+numberOfThousandsSeparator) > aText.MaxLength()) + { + aOverflowHandler.Overflow(aText); + return; + } + for (TInt i=positionOfDecimalSeparator-3; i>0; i-=3) + { + aText.Insert(i, thousandsSeparator); + } + } + TInt positionToInsertCurrencySymbol = 0; + switch (CurrencySymbolPosition()) + { + case ELocaleBefore: + { + if ((amountIsNegative) && (NegativeCurrencySymbolOpposite())) + { + positionToInsertCurrencySymbol=aText.Length(); + } + else + positionToInsertCurrencySymbol=0; + } + break; + case ELocaleAfter: + { + if ((amountIsNegative) && (NegativeCurrencySymbolOpposite())) + { + positionToInsertCurrencySymbol=0; + } + else + positionToInsertCurrencySymbol=aText.Length(); + } + break; + default: + Panic(ETRegionOutOfRange); + break; + } + if (CurrencySpaceBetween()) + { + if (aText.Length() == aText.MaxLength()) + { + aOverflowHandler.Overflow(aText); + return; + } + if ((amountIsNegative) && (NegativeLoseSpace())) + { + // don't add the space + } + else + { + aText.Insert(positionToInsertCurrencySymbol, KLitSpace); + if (positionToInsertCurrencySymbol>0) + { + ++positionToInsertCurrencySymbol; + } + } + } + TCurrencySymbol theCurrencySymbol; + if ((aText.Length()+theCurrencySymbol.Length()) > aText.MaxLength()) + { + aOverflowHandler.Overflow(aText); + return; + } + aText.Insert(positionToInsertCurrencySymbol,theCurrencySymbol); + if (amountIsNegative) + { + TInt positionToInsertInterveningMinusSign = 0; + if ((CurrencySpaceBetween()) && !(NegativeLoseSpace())) + { + if (positionToInsertCurrencySymbol>0) + { + positionToInsertInterveningMinusSign = positionToInsertCurrencySymbol-1; + } + else + { + positionToInsertInterveningMinusSign = theCurrencySymbol.Length()+1; + } + } + else + { + if (positionToInsertCurrencySymbol>0) + { + positionToInsertInterveningMinusSign = positionToInsertCurrencySymbol; + } + else + { + positionToInsertInterveningMinusSign = theCurrencySymbol.Length(); + } + } + switch (NegativeCurrencyFormat()) + { + case EInBrackets: + { + if ((aText.Length()+2) > aText.MaxLength()) + { + aOverflowHandler.Overflow(aText); + return; + } + aText.Insert(0, KLitOpeningBracket); + aText.Append(')'); + } + break; + case ELeadingMinusSign: + { + if (aText.Length() == aText.MaxLength()) + { + aOverflowHandler.Overflow(aText); + return; + } + aText.Insert(0, KLitMinusSign); + } + break; + case ETrailingMinusSign: + { + if (aText.Length() == aText.MaxLength()) + { + aOverflowHandler.Overflow(aText); + return; + } + aText.Append(KLitMinusSign); + } + break; + case EInterveningMinusSign: + { + if (aText.Length() == aText.MaxLength()) + { + aOverflowHandler.Overflow(aText); + return; + } + aText.Insert(positionToInsertInterveningMinusSign, KLitMinusSign); + } + break; + default: + Panic(ETRegionOutOfRange); + break; + } + } + } + + +EXPORT_C void TLocaleMessageText::Set(TLocaleMessage aMsgNo) +// +// Get some text from Locale +// + { + if(TUint(aMsgNo) < ELocaleMessages_LastMsg) + { + SLocaleLanguage localeLanguage; + LocaleLanguageGet(localeLanguage); + Copy((reinterpret_cast(localeLanguage.iMsgTable))[aMsgNo]); + } + else + SetLength(0); + } + + + +#ifndef __TOOLS2__ +EXPORT_C TInt TFindServer::Next(TFullName &aResult) +/** +Gets the full name of the next server which matches the match pattern. + +@param aResult A reference to a descriptor with a defined maximum length. + If a matching server is found, its full name is set into + this descriptor. If no matching server is found, + the descriptor length is set to zero. + +@return KErrNone if a matching server is found, KErrNotFound otherwise. +*/ + { + return NextObject(aResult,EServer); + } + + + + +EXPORT_C void RServer2::Receive(RMessage2& aMessage, TRequestStatus &aStatus) +// +// Receive a message from the server asynchronously. +// + { + + aStatus=KRequestPending; + Exec::ServerReceive(iHandle, aStatus, &aMessage); + } + +EXPORT_C void RServer2::Cancel() +// +// Cancel a pending message receive. +// + { + + Exec::ServerCancel(iHandle); + } + + + + +EXPORT_C TInt TFindMutex::Next(TFullName &aResult) +/** +Finds the next global mutex whose full name matches the match pattern. + +If a global mutex with a matching name is found, the function copies its full +name into the specified descriptor. It also saves the find-handle associated +with the global mutex into the TFindHandleBase part of this object. + +@param aResult A reference to a descriptor with a defined maximum length. + If a matching global mutex is found, its full name is set + into this descriptor. + If no matching global mutex is found, the descriptor length + is set to zero. + +@return KErrNone if a matching global mutex is found; + KErrNotFound otherwise. +*/ + { + return NextObject(aResult,EMutex); + } + + + + +/** +Acquire the mutex, waiting for it to become free if necessary. + +This function checks if the mutex is currently held. If not the mutex is marked +as held by the current thread and the call returns immediately. If the mutex is +held by another thread the current thread will suspend until the mutex becomes +free. If the mutex is already held by the current thread a count is maintained +of how many times the thread has acquired the mutex. +*/ +EXPORT_C void RMutex::Wait() + { + + Exec::MutexWait(iHandle); + } + + + + +/** +Release the mutex. + +This function decrements the count of how many times the current thread has +acquired this mutex. If the count is now zero the mutex is marked as free and, +if any other threads are waiting for the mutex to become free, the highest +priority among those is made ready to run. However the mutex is not marked as +held by any thread - the thread which has just been awakened must actually run +in order to acquire the mutex. + +@pre The mutex must previously have been acquired by the current thread calling +Wait(). + +@panic KERN-EXEC 1 If the mutex has not previously been acquired by the current +thread calling Wait(). +*/ +EXPORT_C void RMutex::Signal() + { + + Exec::MutexSignal(iHandle); + } + + + +/** +Test if this mutex is held by the current thread. +@return True if the current thread has waited on the mutex, false otherwise. +*/ +EXPORT_C TBool RMutex::IsHeld() + { + return Exec::MutexIsHeld(iHandle); + } + + +/** Wait on a condition variable + +This call releases the specified mutex then atomically blocks the current +thread on this condition variable. The atomicity here is with respect to the +condition variable and mutex concerned. Specifically if the condition variable +is signalled at any time after the mutex is released then this thread will be +awakened. Once the thread has awakened it will reacquire the specified mutex +before this call returns (except in the case where the condition variable has +been deleted). + +The usage pattern for this is as follows: + +@code + mutex.Wait(); + while(!CONDITION) + condvar.Wait(mutex); + STATEMENTS; + mutex.Signal(); +@endcode + +where CONDITION is an arbitrary condition involving any number of user-side +variables whose integrity is protected by the mutex. + +It is necessary to loop while testing the condition because there is **no** guarantee +that the condition has been satisfied when the condition variable is signalled. +Different threads may be waiting on different conditions or the condition may +have already been absorbed by another thread. All that can be said is that the +thread will awaken whenever something happens which **might** affect the condition. + +It needs to be stressed that if: + +@code +condvar.Wait(mutex); +@endcode + +completes, it does not necessarily mean that the condition is yet satisfied, hence the necessity for the loop. + +@param aMutex The mutex to be released and reacquired. +@return KErrNone if the condition variable has been signalled. + KErrInUse if another thread is already waiting on this condition + variable in conjunction with a different mutex. + KErrGeneral if the condition variable is deleted. + +@pre The specified mutex is held by the current thread. +@post The specified mutex is held by the current thread unless the return + value is KErrGeneral in which case the condition variable no longer + exists. + +@panic KERN-EXEC 0 if either the condition variable or mutex handles are not + valid. +@panic KERN-EXEC 54 if the current thread does not hold the specified mutex. + +@see RCondVar::Signal() +@see RCondVar::Broadcast() +*/ +EXPORT_C TInt RCondVar::Wait(RMutex& aMutex) + { + return Exec::CondVarWait(iHandle, aMutex.Handle(), 0); + } + + + +/** Wait on a condition variable with timeout + +This is the same as RCondVar::Wait(RMutex) except that there is a time limit on +how long the current thread will block while waiting for the condition variable. + +@param aMutex The mutex to be released and reacquired. +@param aTimeout The maximum time to wait in microseconds. + 0 means no maximum. +@return KErrNone if the condition variable has been signalled. + KErrInUse if another thread is already waiting on this condition + variable in conjunction with a different mutex. + KErrGeneral if the condition variable is deleted. + KErrTimedOut if the timeout expired before the condition variable was + signalled. + +@pre The specified mutex is held by the current thread. +@post The specified mutex is held by the current thread unless the return + value is KErrGeneral in which case the condition variable no longer + exists. + +@panic KERN-EXEC 0 if either the condition variable or mutex handles are not + valid. +@panic KERN-EXEC 54 if the current thread does not hold the specified mutex. + +@see RCondVar::Wait(RMutex) +*/ +EXPORT_C TInt RCondVar::TimedWait(RMutex& aMutex, TInt aTimeout) + { + return Exec::CondVarWait(iHandle, aMutex.Handle(), aTimeout); + } + + +/** Signal a condition variable + +This unblocks a single thread which is currently blocked on the condition +variable. The highest priority waiting thread which is not explicitly suspended +will be the one unblocked. If there are no threads currently waiting this call +does nothing. + +It is not required that any mutex is held when calling this function but it is +recommended that the mutex associated with the condition variable is held since +otherwise a race condition can result from the condition variable being signalled +just after the waiting thread testing the condition and before it calls Wait(). + +*/ +EXPORT_C void RCondVar::Signal() + { + Exec::CondVarSignal(iHandle); + } + + + +/** Broadcast to a condition variable + +This unblocks all threads which are currently blocked on the condition +variable. If there are no threads currently waiting this call does nothing. + +It is not required that any mutex is held when calling this function but it is +recommended that the mutex associated with the condition variable is held since +otherwise a race condition can result from the condition variable being signalled +just after the waiting thread testing the condition and before it calls Wait(). + +*/ +EXPORT_C void RCondVar::Broadcast() + { + Exec::CondVarBroadcast(iHandle); + } + + + + +EXPORT_C TInt TFindProcess::Next(TFullName &aResult) +/** +Gets the full name of the next process which matches the match pattern. + +@param aResult A reference to a TBuf descriptor with a defined maximum length. + If a matching process is found, its full name is set into + this descriptor. If no matching process is found, the descriptor + length is set to zero. + +@return KErrNone if successful, otherwise one of the other system-wide error + codes. +*/ + { + return NextObject(aResult,EProcess); + } + + + + +EXPORT_C TUidType RProcess::Type() const +/** +Gets the Uid type associated with the process. + +@return A reference to a TUidType object containing the process type. +*/ + { + + TUidType u; + Exec::ProcessType(iHandle,u); + return(u); + } + + + + +EXPORT_C TProcessId RProcess::Id() const +/** +Gets the Id of this process. + +@return The Id of this process. +*/ + { + + return TProcessId( (TUint)Exec::ProcessId(iHandle) ); + } + + + + +EXPORT_C void RProcess::Resume() +/** +Makes the first thread in the process eligible for execution. + +@panic KERN-EXEC 32 if the process is not yet fully loaded. + +@see RThread::Resume() +*/ + { + + Exec::ProcessResume(iHandle); + } + + + +EXPORT_C TFileName RProcess::FileName() const +/** +Gets a copy of the full path name of the loaded executable on which this +process is based. + +This is the file name which is passed to the Create() member function of this +RProcess. + +@return A TBuf descriptor with a defined maximum length containing the full + path name of the file. + +@see RProcess::Create() +*/ + { + + TFileName n; + TPtr8 n8(((TUint8*)n.Ptr()) + KMaxFileName, KMaxFileName); + Exec::ProcessFileName(iHandle,n8); + n.Copy(n8); + return(n); + } +#endif // __TOOLS2__ + + + +EXPORT_C void User::CommandLine(TDes &aCommand) +/** +Gets a copy of the data which is passed as an argument to the thread function +of the current process's main thread when it is first scheduled to run. + +@param aCommand A modifiable descriptor supplied by the caller into which the + argument data is put. The descriptor must be big enough to + contain the expected data, otherwise the function raises + a panic. + +@see User::CommandLineLength() +*/ + { + TPtr8 aCommand8((TUint8*)aCommand.Ptr(),aCommand.MaxLength()<<1); + Exec::ProcessCommandLine(KCurrentProcessHandle,aCommand8); + aCommand.SetLength(aCommand8.Length()>>1); + } + + + + +EXPORT_C TInt User::CommandLineLength() +/** +Gets the length of the data which is passed as an argument to the thread +function of the current process's main thread when it is first scheduled +to run. + +@return The length of the argument data. +*/ + { + return Exec::ProcessCommandLineLength(KCurrentProcessHandle); + } + + + +#ifndef __TOOLS2__ +EXPORT_C TExitType RProcess::ExitType() const +/** +Tests whether the process has ended and, if it has ended, return how it ended. + +This information allows the caller to distinguish between normal termination +and a panic. + +@return An enumeration whose enumerators describe how the process has ended. +*/ + { + + return(Exec::ProcessExitType(iHandle)); + } + + + + +EXPORT_C TInt RProcess::ExitReason() const +/** +Gets the specific reason associated with the end of this process. + +The reason number together with the category name is a way of distinguishing +between different causes of process termination. + +If the process has panicked, this value is the panic number. If the process +has ended as a result of a call to Kill(), then the value is the one supplied +by Kill(). + +If the process has not ended, then the returned value is zero. + +@return The reason associated with the end of the process. + +@see RProcess::Kill() +*/ + { + + return(Exec::ProcessExitReason(iHandle)); + } + + + + +EXPORT_C TExitCategoryName RProcess::ExitCategory() const +/** +Gets the name of the category associated with the end of the process. + +The category name together with the reason number is a way of distinguishing +between different causes of process termination. + +If the process has panicked, the category name is the panic category name; +for example, E32USER-CBase or KERN-EXEC. If the process has ended as a result +of a call to Kill(), then the category name is Kill. + +If the process has not ended, then the category name is empty, i.e. the length +of the category name is zero. + +@return A descriptor with a defined maximum length containing the + name of the category associated with the end of the process. + +@see RProcess::Kill() +*/ + { + + TExitCategoryName n; + TPtr8 n8(((TUint8*)n.Ptr()) + KMaxExitCategoryName, KMaxExitCategoryName); + Exec::ProcessExitCategory(iHandle,n8); + n.Copy(n8); + return(n); + } + + + + +EXPORT_C TProcessPriority RProcess::Priority() const +/** +Gets the priority of this process. + +@return One of the TProcessPriority enumerator values. +*/ + { + + return(Exec::ProcessPriority(iHandle)); + } + + + + +EXPORT_C void RProcess::SetPriority(TProcessPriority aPriority) const +/** +Sets the priority of this process to one of the values defined by theTProcessPriority +enumeration. The priority can be set to one of the four values: + +EPriorityLow + +EPriorityBackground + +EPriorityForeground + +EPriorityHigh + +The absolute priority of all threads owned by the process (and all threads +owned by those threads etc.) are re-calculated. + +Notes: + +The priority values EPriorityWindowServer, EPriorityFileServer, EPriorityRealTimeServer +and EPrioritySupervisor are internal to Symbian OS and any attempt to explicitly +set any of these priority values causes a KERN-EXEC 14 panic to be raised. + +Any attempt to set the priority of a process which is protected and is different +from the process owning the thread which invokes this function, causes a KERN-EXEC +1 panic to be raised. + +A process can set its own priority whether it is protected or not. + +@param aPriority The priority value. +*/ + { + + Exec::ProcessSetPriority(iHandle,aPriority); + } + + + + +/** +Tests whether "Just In Time" debugging is enabled or not for this process. + +@return True, when "Just In Time" debugging is enabled. False otherwise. +@see RProcess::SetJustInTime +*/ + +EXPORT_C TBool RProcess::JustInTime() const + { + + return (Exec::ProcessFlags(iHandle) & KProcessFlagJustInTime) != 0; + } + + +/** +Enables or disables "Just In Time" debugging for this process. +This will only have an effect when running on the emulator. + +"Just In Time" debugging catches a thread just before it executes a panic +or exception routine. Capturing a thread early, before it is terminated, +allows the developer to more closely inspect what went wrong, before the +kernel removes the thread. In some cases, the developer can modify context, +program counter, and variables to recover the thread. This is only possible +on the emulator. + +By default, "Just In Time" debugging is enabled. + +@param aBoolean ETrue, to enable just-in-time debugging. + EFalse, to disable just-in-time debugging. +*/ +EXPORT_C void RProcess::SetJustInTime(TBool aState) const + { + + TUint32 set = aState ? KProcessFlagJustInTime : 0; + Exec::ProcessSetFlags(iHandle, KProcessFlagJustInTime, set); + } + + + + +EXPORT_C TInt RProcess::SecureApi(TInt /*aState*/) + { + return ESecureApiOn; + } + +EXPORT_C TInt RProcess::DataCaging(TInt /*aState*/) + { + return EDataCagingOn; + } + + + +EXPORT_C TInt RProcess::GetMemoryInfo(TModuleMemoryInfo& aInfo) const +/** +Gets the size and base address of the code and various data +sections of the process. + +The run addresses are also returned. + +@param aInfo On successful return, contains the base address and size of the + sections. + +@return KErrNone, if successful; otherwise one of the other system wide error + codes. +*/ + { + + return Exec::ProcessGetMemoryInfo(iHandle,aInfo); + } + + +EXPORT_C TAny* RProcess::ExeExportData(void) +/** +Retrieves pointer to named symbol export data from the current process, i.e. the +process calling this function. + +@return Pointer to export data when it is present, NULL if export data not found +@internalTechnology +@released +*/ + { + + return Exec::ProcessExeExportData(); + } + + + +EXPORT_C TInt TFindSemaphore::Next(TFullName &aResult) +/** +Finds the next global semaphore whose full name matches the match pattern. + +If a global semaphore with a matching name is found, the function copies its +full name into the descriptor aResult. It also saves the find-handle associated +with the global semaphore into the TFindHandleBase part of this TFindSemaphore +object. + +@param aResult A reference to a TBuf descriptor with a defined maximum length. + If a matching global semaphore is found, its full name is set + into this descriptor. + If no matching global semaphore is found, the descriptor length + is set to zero. + +@return KErrNone if a matching global semaphore is found; + KErrNotFound otherwise. +*/ + { + return NextObject(aResult,ESemaphore); + } + + + + +EXPORT_C void RSemaphore::Wait() +/** +Waits for a signal on the semaphore. + +The function decrements the semaphore count by one and returns immediately +if it is zero or positive. + +If the semaphore count is negative after being decremented, the calling thread is +added to a queue of threads maintained by this semaphore. + +The thread waits until the semaphore is signalled. More than one thread can +be waiting on a particular semaphore at a time. When there are multiple threads +waiting on a semaphore, they are released in priority order. + +If the semaphore is deleted, all threads waiting on that semaphore are released. +*/ + { + + Exec::SemaphoreWait(iHandle, 0); + } + + + + +EXPORT_C TInt RSemaphore::Wait(TInt aTimeout) +/** +Waits for a signal on the semaphore, or a timeout. + +@param aTimeout The timeout value in micoseconds + +@return KErrNone if the wait has completed normally; + KErrGeneral if the semaphore is being reset, i.e the semaphore + is about to be deleted. + KErrArgument if aTimeout is negative; + otherwise one of the other system wide error codes indicating that + the timeout has expired. +*/ + { + + return Exec::SemaphoreWait(iHandle, aTimeout); + } + + + + +EXPORT_C void RSemaphore::Signal() +/** +Signals the semaphore once. + +The function increments the semaphore count by one. If the count was negative +before being incremented, the highest priority thread waiting on the semaphore's queue +of threads is removed from that queue and, provided that it is not suspended +for any other reason, is marked as ready to run. +*/ + { + + Exec::SemaphoreSignal1(iHandle); + } + + + + +EXPORT_C void RSemaphore::Signal(TInt aCount) +/** +Signals the semaphore one or more times. + +The function increments the semaphore count. If the count was negative +before being incremented, the highest priority thread waiting on the semaphore's queue +of threads is removed from that queue and, provided that it is not suspended +for any other reason, is marked as ready to run. + +@param aCount The number of times the semaphore is to be signalled. +*/ + { + + __ASSERT_ALWAYS(aCount>=0,Panic(ESemSignalCountNegative)); + Exec::SemaphoreSignalN(iHandle,aCount); + } + + + + +EXPORT_C RCriticalSection::RCriticalSection() + : iBlocked(1) +/** +Default constructor. +*/ + {} + + + + +EXPORT_C void RCriticalSection::Close() +/** +Closes the handle to the critical section. + +As a critical section object is implemented using a semaphore, this has the +effect of closing the handle to the semaphore. +*/ + { + + RSemaphore::Close(); + } + + + + +EXPORT_C void RCriticalSection::Wait() +/** +Waits for the critical section to become free. + +If no other thread is in the critical section, control returns immediately +and the current thread can continue into the section. + +If another thread is already in the critical section, the current thread is +marked as waiting (on a semaphore); the current thread is added to a queue +of threads maintained by this critical section. +*/ + { + + if (User::LockedDec(iBlocked)!=1) + RSemaphore::Wait(); + } + + + + +EXPORT_C void RCriticalSection::Signal() +/** +Signals an exit from the critical section. + +A thread calls this function when it exits from the critical section. +The first eligible thread waiting on the critical section's queue of threads +is removed from that queue and, provided that it is not suspended for any other +reason, is marked as ready to run. That thread will, therefore, be the next to +proceed into the critical section. +*/ + { + + __ASSERT_ALWAYS(iBlocked<1,Panic(ECriticalSectionStraySignal)); + if (User::LockedInc(iBlocked)<0) + RSemaphore::Signal(); + } + + + + +EXPORT_C TInt TFindThread::Next(TFullName &aResult) +/** +Gets the full name of the next global thread which matches the match pattern. + +@param aResult A reference to a TBuf descriptor with a defined maximum length. + If a matching global thread is found, its full name is set into + this descriptor. If no matching global thread is found, + the descriptor length is set to zero. + +@return KErrNone if successful, otherwise one of the other system-wide error + codes. +*/ + { + return NextObject(aResult,EThread); + } + + + + +EXPORT_C TThreadId RThread::Id() const +/** +Gets the Id of this thread. + +@return The Id of this thread. +*/ + { + + return TThreadId( (TUint)Exec::ThreadId(iHandle) ); + } +#endif + + + +EXPORT_C void RThread::HandleCount(TInt& aProcessHandleCount, TInt& aThreadHandleCount) const +/** +Gets the number of handles open in this thread, and the number of handles open +in the process which owns this thread. + +@param aProcessHandleCount On return, contains the number of handles open in + the process which owns this thread. +@param aThreadHandleCount On return, contains the number of handles open in + this thread. +*/ + { +#ifndef __TOOLS2__ + Exec::HandleCount(iHandle,aProcessHandleCount,aThreadHandleCount); +#else + aProcessHandleCount = aThreadHandleCount = 0; +#endif // __TOOLS2__ + } + + + +#ifndef __TOOLS2__ +EXPORT_C TExceptionHandler User::ExceptionHandler() +/** +Gets a pointer to the exception handler for the current thread. + +@return A pointer to the exception handler. +*/ + { + return(Exec::ExceptionHandler(KCurrentThreadHandle)); + } + + + + +EXPORT_C TInt User::SetExceptionHandler(TExceptionHandler aHandler,TUint32 aMask) +/** +Sets a new exception handler for the current thread. Note that the handler is not +guaranteed to receive floating point exceptions (KExceptionFpe) when a hardware +floating point implementation is in use - see User::SetFloatingPointMode for +hardware floating point modes and whether they cause user-trappable exceptions. + +@param aHandler The new exception handler. +@param aMask One or more flags defining the exception categories which + the handler can handle. + +@return KErrNone if successful, otherwise another of the system-wide error codes. + +@see KExceptionAbort +@see KExceptionKill +@see KExceptionUserInterrupt +@see KExceptionFpe +@see KExceptionFault +@see KExceptionInteger +@see KExceptionDebug +*/ + { + return(Exec::SetExceptionHandler(KCurrentThreadHandle, aHandler, aMask)); + } + + + + +EXPORT_C void User::ModifyExceptionMask(TUint32 aClearMask, TUint32 aSetMask) +/** +Changes the set of exceptions which the current thread's exception +handler can deal with. + +aClearMask is the set of flags defining the set of exceptions which the +exception handler no longer deals with, while aSetMask is the set of flags +defining the new set of exceptions to be set. + +Flag clearing is done before flag setting. + +@param aClearMask One or more flags defining the exceptions which the current + exception handler no longer deals with. +@param aSetMask One or more flags defining the new set of exceptions which + the current exception handler is to deal with. +*/ + { + Exec::ModifyExceptionMask(KCurrentThreadHandle, aClearMask, aSetMask); + } + + + + +_LIT(KLitUserExec, "USER-EXEC"); +EXPORT_C TInt User::RaiseException(TExcType aType) +/** +Raises an exception of a specified type on the current thread. + +If the thread has an exception handler to handle this type of exception, +then it is called. + +If the thread has no exception handler to handle this type of exception, then +the function raises a USER-EXEC 3 panic. + +Note that exception handlers are executed in the context of the thread on which +the exception is raised; control returns to the point of the exception. + +@param aType The type of exception. + +@return KErrNone if successful, otherwise another of the system-wide + error codes. +*/ + { + if (Exec::IsExceptionHandled(KCurrentThreadHandle,aType,ETrue)) + { + Exec::ThreadSetFlags(KCurrentThreadHandle, 0, KThreadFlagLastChance); + TUint32 type = aType; + User::HandleException(&type); + } + else + User::Panic(KLitUserExec, ECausedException); + return KErrNone; + } + + + + +EXPORT_C TBool User::IsExceptionHandled(TExcType aType) +/** +Tests whether the specified exception type can be handled by the +current thread. + +@param aType The type of exception. + +@return True, if the thread has an exception handler which can handle + an exception of type aType. + False, if the thread has no exception handler or the thread has + an exception handler which cannot handle the exception defined + by aType. +*/ + { + return (Exec::IsExceptionHandled(KCurrentThreadHandle,aType,EFalse)); + } + + + + +EXPORT_C void RThread::Context(TDes8 &aDes) const +/** +Gets the register contents of this thread. + +@param aDes On return, contains the register contents, starting with R0. +*/ + { + + Exec::ThreadContext(iHandle,aDes); + } + + + + +EXPORT_C void RThread::Resume() const +/** +Makes the thread eligible for execution. + +After a thread is created, it is put into a suspended state; the thread is +not eligible to run until Resume() is called. + +This function must also be called to resume execution of this thread after +it has been explicitly suspended by a call to Suspend(). + +Note that when a thread is created, it is given the priority EPriorityNormal +by default. The fact that a thread is initially put into a suspended state +means that the thread priority can be changed by calling the thread's +SetPriority() member function before the thread is started by a call to Resume(). +*/ + { + + Exec::ThreadResume(iHandle); + } + + + + +EXPORT_C void RThread::Suspend() const +/** +Suspends execution of this thread. + +The thread is not scheduled to run until a subsequent call to Resume() is made. +*/ + { + + Exec::ThreadSuspend(iHandle); + } + + + + +EXPORT_C TThreadPriority RThread::Priority() const +/** +Gets the priority of this thread. + +@return The priority. +*/ + { + + return(Exec::ThreadPriority(iHandle)); + } + + + + +EXPORT_C void RThread::SetProcessPriority(TProcessPriority aPriority) const +/** +Sets the priority of the process which owns this thread to one of the values +defined by the TProcessPriority enumeration. + +The priority can be set to one of the four values: + +EPriorityLow + +EPriorityBackground + +EPriorityForeground + +EPriorityHigh + +The absolute priority of all threads owned by the process (and all threads +owned by those threads etc.) are re-calculated. + +Note: + +The use of the priority values EPriorityWindowServer, EPriorityFileServer, +EPriorityRealTimeServer and EPrioritySupervisor is restricted to Symbian OS, +and any attempt to explicitly set any of these priority values raises a KERN-EXEC +14 panic. + +@param aPriority The priority value. + +@deprecated Not allowed on threads in a different process. + Replace with RProcess::SetPriority or RMessagePtr2::SetProcessPriority +*/ + { + + Exec::ThreadSetProcessPriority(iHandle,aPriority); + } + + + + +EXPORT_C TProcessPriority RThread::ProcessPriority() const +/** +Gets the priority of the process which owns this thread. + +@return The process priority. +*/ + { + + return(Exec::ThreadProcessPriority(iHandle)); + } + + + + +EXPORT_C void RThread::SetPriority(TThreadPriority aPriority) const +/** +Sets the priority of the thread to one of the values defined by +the TThreadPriority enumeration. + +The resulting absolute priority of the thread depends on the value of aPriority +and the priority of the owning process. + +Use of the priority value EPriorityNull is restricted to Symbian OS, and any +attempt to explicitly set this value causes a KERN-EXEC 14 panic to be raised. + +@param aPriority The priority value. + +@capability ProtServ if aPriority is EPriorityAbsoluteRealTime1 or higher + +@panic KERN-EXEC 14, if aPriority is invalid or set to EPriorityNull +@panic KERN-EXEC 46, if aPriority is EPriorityAbsoluteRealTime1 or higher + and calling process does not have ProtServ capability +*/ + { + + Exec::ThreadSetPriority(iHandle,aPriority); + } + + + + +EXPORT_C User::TCritical User::Critical(RThread aThread) +/** +Gets the critical state associated with the specified thread. + +@param aThread The thread whose critical state is to be retrieved. + +@return The critical state. + +@see User::SetCritical() +*/ + { + TUint32 flags = Exec::ThreadFlags(aThread.Handle()); + if (flags & KThreadFlagSystemPermanent) + return ESystemPermanent; + if (flags & KThreadFlagSystemCritical) + return ESystemCritical; + if (flags & KThreadFlagProcessPermanent) + return EProcessPermanent; + if (flags & KThreadFlagProcessCritical) + return EProcessCritical; + return ENotCritical; + } + + + + +EXPORT_C User::TCritical User::Critical() +/** +Gets the critical state associated with the current thread. + +@return The critical state. + +@see User::SetCritical() +*/ + { + RThread me; + return User::Critical(me); + } + + + + +/** +Sets up or changes the effect that termination of the current +thread has, either on its owning process, or on the whole system. + +The precise effect of thread termination is defined by +the following specific values of the TCritical enum: +- ENotCritical +- EProcessCritical +- EProcessPermanent +- ESystemCritical +- ESystemPermanent + +Notes: +-# The enum value EAllThreadsCritical cannot be set using this function. It is +associated with a process, not a thread, and, if appropriate, should be set +using User::SetProcessCritical(). +-# The states associated with ENotCritical, EProcessCritical, +EProcessPermanent, ESystemCritical and ESystemPermanent +are all mutually exclusive, i.e. the thread can only be in one of these states +at any one time + +@param aCritical The state to be set. + +@return KErrNone, if successful; + KErrArgument, if EAllThreadsCritical is passed - this is a + state associated with a process, and + you use User::SetProcessCritical() to set it. + +@capability ProtServ if aCritical==ESystemCritical or ESystemPermanent + +@see User::Critical() +@see User::ProcessCritical() +@see User::SetProcessCritical() +*/ +EXPORT_C TInt User::SetCritical(TCritical aCritical) + { + const TUint32 clear = KThreadFlagSystemPermanent | KThreadFlagSystemCritical | + KThreadFlagProcessPermanent | KThreadFlagProcessCritical; + TUint32 set; + switch (aCritical) + { + case ENotCritical: set = 0; break; + case EProcessCritical: set = KThreadFlagProcessCritical; break; + case EProcessPermanent: set = KThreadFlagProcessPermanent; break; + case ESystemCritical: set = KThreadFlagSystemCritical; break; + case ESystemPermanent: set = KThreadFlagSystemPermanent; break; + default: return KErrArgument; + } + Exec::ThreadSetFlags(KCurrentThreadHandle, clear, set); + return KErrNone; + } + + + + +EXPORT_C TInt User::SetRealtimeState(TRealtimeState aState) + { + const TUint32 clear = KThreadFlagRealtime | KThreadFlagRealtimeTest; + TUint32 set; + switch (aState) + { + case ERealtimeStateOff: set = 0; break; + case ERealtimeStateOn: set = KThreadFlagRealtime; break; + case ERealtimeStateWarn: set = KThreadFlagRealtime|KThreadFlagRealtimeTest; break; + default: return KErrArgument; + } + Exec::ThreadSetFlags(KCurrentThreadHandle, clear, set); + return KErrNone; + } + + + + +EXPORT_C User::TCritical User::ProcessCritical(RProcess aProcess) +/** +Gets the critical state associated with the specified process. + +@param aProcess The process whose critical state is to be retrieved. + +@return The critical state. + +@see User::SetProcessCritical() +*/ + { + TUint32 flags = Exec::ProcessFlags(aProcess.Handle()); + if (flags & KProcessFlagSystemPermanent) + return ESystemPermanent; + if (flags & KProcessFlagSystemCritical) + return ESystemCritical; + if (flags & (KThreadFlagProcessPermanent | KThreadFlagProcessCritical)) + return EAllThreadsCritical; + return ENotCritical; + } + + + + +EXPORT_C User::TCritical User::ProcessCritical() +/** +Gets the critical state associated with the current process. + +@return The critical state. + +@see User::SetProcessCritical() +*/ + { + RProcess me; + return User::ProcessCritical(me); + } + + + + +EXPORT_C TInt User::SetProcessCritical(TCritical aCritical) +/** +Sets up or changes the effect that termination of subsequently created threads +will have, either on the owning process, or on the whole system. + +It is important to note that we are not referring to threads that have already +been created, but threads that will be created subsequent to a call to this function. + +The precise effect of thread termination is defined by the following specific +values of the TCritical enum: +- ENotCritical +- EAllThreadsCritical +- ESystemCritical +- ESystemPermanent + +Notes: +-# The enum values EProcessCritical and EProcessPermanent cannot be set using +this function. They are states associated with +a thread, not a process, and, if appropriate, should be set +using User::SetCritical(). +-# The states associated with ENotCritical, EAllThreadsCritical, +ESystemCritical and ESystemPermanent are all mutually exclusive, i.e. the +process can only be in one of these states at any one time. + +@param aCritical The state to be set. + +@return KErrNone, if successful; + KErrArgument, if either EProcessCritical or EProcessPermanent + is passed - these are states associated with a thread, and + you use User::SetCritical() to set them. + +@capability ProtServ if aCritical==ESystemCritical or ESystemPermanent + +@see User::ProcessCritical() +@see User::SetCritical() +@see User::Critical() +*/ + { + const TUint32 clear = KProcessFlagSystemPermanent | KProcessFlagSystemCritical | + KThreadFlagProcessPermanent | KThreadFlagProcessCritical; + TUint32 set; + switch (aCritical) + { + case ENotCritical: set = 0; break; + case EAllThreadsCritical: set = KThreadFlagProcessCritical; break; + case ESystemCritical: set = KProcessFlagSystemCritical; break; + case ESystemPermanent: set = KProcessFlagSystemPermanent|KProcessFlagSystemCritical; break; + default: return KErrArgument; + } + Exec::ProcessSetFlags(KCurrentProcessHandle, clear, set); + return KErrNone; + } + + + + +EXPORT_C TBool User::PriorityControl() +/** +Tests whether the current process allows other processes to switch its priority +between 'foreground' and 'background'. + +@return True, if the current process allows other processes to switch its priority; + false, otherwise. +*/ + { + return Exec::ProcessFlags(KCurrentProcessHandle) & KProcessFlagPriorityControl; + } + + + + +EXPORT_C void User::SetPriorityControl(TBool aEnable) +/** +Allows the current process to choose to have its priority switched by another +process between 'foreground' and 'background'. + +By default a process does not allow this. + +@param aEnable If ETrue, allows other processes to switch the current process's + priority. + If EFalse, prevents other processes from switching the current + process's priority. +*/ + { + TUint32 set = aEnable ? KProcessFlagPriorityControl : 0; + Exec::ProcessSetFlags(KCurrentProcessHandle, KProcessFlagPriorityControl, set); + } + + + +EXPORT_C TInt RThread::RequestCount() const +/** +Gets this thread's request semaphore count. + +The request semaphore is created when a thread is created, and is used to +support asynchronous requests. + +A negative value implies that this thread is waiting for at least +one asynchronous request to complete. + +@return This thread's request semaphore count. +*/ + { + + return(Exec::ThreadRequestCount(iHandle)); + } + + + + +EXPORT_C TExitType RThread::ExitType() const +/** +Tests whether the thread has ended and, if it has ended, return how it ended. + +This information allows the caller to distinguish between normal termination +and a panic. + +@return An enumeration whose enumerators describe how the thread has ended. +*/ + { + + return(Exec::ThreadExitType(iHandle)); + } + + + + +EXPORT_C TInt RThread::ExitReason() const +/** +Gets the specific reason associated with the end of this thread. + +The reason number together with the category name is a way of distinguishing +between different causes of thread termination. + +If the thread has panicked, this value is the panic number. If the thread +has ended as a result of a call to Kill(), then the value is the one supplied +by Kill(). + +If the thread is still alive, then the returned value is zero. + +@return The reason associated with the end of the thread. +*/ + { + + return(Exec::ThreadExitReason(iHandle)); + } + + + + +EXPORT_C TExitCategoryName RThread::ExitCategory() const +/** +Gets the name of the category associated with the end of the thread. + +The category name together with the reason number is a way of distinguishing +between different causes of thread termination. + +If the thread has panicked, the category name is the panic category name; +for example, E32USER-CBase or KERN-EXEC. If the thread has ended as a result +of call to Kill(), then the category name is Kill. + +If the thread has not ended, then the category name is empty, i.e. the length +of the category name is zero. + +@return A TBuf descriptor with a defined maximum length containing the name + of the category associated with the end of the thread. + +@see TBuf +*/ + { + TExitCategoryName n; + TPtr8 n8(((TUint8*)n.Ptr()) + KMaxExitCategoryName, KMaxExitCategoryName); + Exec::ThreadExitCategory(iHandle,n8); + n.Copy(n8); + return(n); + } + + + + +EXPORT_C TInt RThread::StackInfo(TThreadStackInfo& aInfo) const +/** +Gets information about a thread's user mode stack. + +@param aInfo The TThreadStackInfo object to write the stack infomation to. + +@return KErrNone, if sucessful; + KErrGeneral, if the thread doesn't have a user mode stack, + or it has terminated. + +@see TThreadStackInfo +*/ + { + return(Exec::ThreadStackInfo(iHandle,aInfo)); + } + + + + +EXPORT_C TInt RThread::GetCpuTime(TTimeIntervalMicroSeconds& aCpuTime) const +/** +Gets the CPU usage for this thread. + +This function is not supported on version 8.0b or 8.1b, and returns +KErrNotSupported. From 9.1 onwards it may be supported if the kernel has been +compiled with the MONITOR_THREAD_CPU_TIME macro defined. + +@param aCpuTime A reference to a time interval object supplied by the caller. + +@return KErrNone - if thread CPU time is available. + + KErrNotSupported - if this feature is not supported on this + version or build of the OS. +*/ + { + return Exec::ThreadGetCpuTime(iHandle, (TInt64&)aCpuTime.Int64()); + } +#endif // __TOOLS2__ + + + +EXPORT_C void User::After(TTimeIntervalMicroSeconds32 aInterval) +/** +Suspends the current thread until a specified time interval has expired. + +The resolution of the timer depends on the hardware, but is normally +1 Symbian OS tick (approximately 1/64 second). + +@param aInterval The time interval for which the current thread is to be + suspended, in microseconds. + +@panic USER 86, if the time interval is negative. +*/ + { + + __ASSERT_ALWAYS(aInterval.Int()>=0,::Panic(EExecAfterTimeNegative)); + TRequestStatus s=KRequestPending; + Exec::After(aInterval.Int(),s); + User::WaitForRequest(s); + } + + + + +EXPORT_C void User::AfterHighRes(TTimeIntervalMicroSeconds32 aInterval) +/** +Suspends the current thread until a specified time interval has expired to +a resolution of 1ms . + +@param aInterval The time interval for which the current thread is to be + suspended, in microseconds. + +@panic USER 86, if the time interval is negative. +*/ + { + + __ASSERT_ALWAYS(aInterval.Int()>=0,::Panic(EExecAfterTimeNegative)); + TRequestStatus s=KRequestPending; + Exec::AfterHighRes(aInterval.Int(),s); + User::WaitForRequest(s); + } + + + +#ifndef __TOOLS2__ +EXPORT_C TInt User::At(const TTime &aTime) +/** +Suspends the current thread until the specified absolute time, in the current time zone. + +If the machine is off at that time, the machine will be turned on again. + +@param aTime The absolute time, in the current time zone, until which the current thread is to + be suspended. + +@return On completion, contains the status of the request to suspend the + current thread: + + KErrNone - suspension of the current thread completed normally at + the requested time. + + KErrAbort - suspension of the current thread was aborted + because the system time changed. + + KErrUnderflow - the requested completion time is in the past. + + KErrOverFlow - the requested completion time is too far in the future. +*/ + { + + TRequestStatus s=KRequestPending; + TInt64 time=aTime.Int64(); + time -= ((TInt64)User::UTCOffset().Int()) * 1000000; + Exec::At(time,s); + User::WaitForRequest(s); + return(s.Int()); + } + + + + +EXPORT_C void RTimer::Cancel() +/** +Cancels any outstanding request for a timer event. + +Any outstanding timer event completes with KErrCancel. +*/ + { + + Exec::TimerCancel(iHandle); + } + + + + +EXPORT_C void RTimer::After(TRequestStatus &aStatus,TTimeIntervalMicroSeconds32 aInterval) +// +// Request a relative timer. +// +/** +Requests an event after the specified interval. + +The counter for this type of request stops during power-down. +A 5 second timer will complete late if, for example, the machine is turned off +2 seconds after the request is made. + +@param aStatus On completion, contains the status of the request. + This is KErrNone if the timer completed normally at the + requested time, otherwise another of the + system-wide error codes. + +@param aInterval The time interval, in microseconds, after which an event + is to occur. + +@panic USER 87, if aInterval is negative. +@panic KERN-EXEC 15, if this function is called while a request for a timer + event is still outstanding. +*/ + { + + __ASSERT_ALWAYS(aInterval.Int()>=0,::Panic(ERTimerAfterTimeNegative)); + aStatus=KRequestPending; + Exec::TimerAfter(iHandle,aStatus,aInterval.Int()); + } + + + + +EXPORT_C void RTimer::AfterTicks(TRequestStatus& aStatus, TInt aTicks) +// +// Request a relative timer in system ticks. +// +/** +Requests an event after the specified interval. + +The counter for this type of request stops during power-down. +A 5 tick timer will complete late if, for example, the machine is turned off +2 ticks after the request is made. + +@param aStatus On completion, contains the status of the request. + This is KErrNone if the timer completed normally at the + requested time, otherwise another of the + system-wide error codes. + +@param aTicks The time interval, in system ticks, after which an event + is to occur. + +@panic USER 87, if aTicks is negative. +@panic KERN-EXEC 15, if this function is called while a request for a timer + event is still outstanding. +*/ + { + __ASSERT_ALWAYS(aTicks >= 0, ::Panic(ERTimerAfterTimeNegative)); + aStatus = KRequestPending; + Exec::TimerAfter(iHandle, aStatus, -aTicks); + } + + + + +EXPORT_C void RTimer::HighRes(TRequestStatus &aStatus,TTimeIntervalMicroSeconds32 aInterval) +// +// Request a relative timer to a resolution of 1ms. +// +/** +Requests an event after the specified interval to a resolution of 1ms. +The "HighRes timer" counter stops during power-down (the same as "after timer"). + +@param aStatus On completion, contains the status of the request. + This is KErrNone if the timer completed normally at the + requested time, otherwise another of the + system-wide error codes. + +@param aInterval The time interval, in microseconds, after which an event + is to occur. + +@panic USER 87, if aInterval is negative. +@panic KERN-EXEC 15, if this function is called while a request for a timer + event is still outstanding. +*/ + { + + __ASSERT_ALWAYS(aInterval.Int()>=0,::Panic(ERTimerAfterTimeNegative)); + aStatus=KRequestPending; + Exec::TimerHighRes(iHandle,aStatus,aInterval.Int()); + } + + + + +EXPORT_C void RTimer::At(TRequestStatus &aStatus,const TTime &aTime) +// +// Request an absolute timer. +// +/** +Requests an event at a given system time (in the current time zone). + +If the machine is off at that time, it is automatically turned on. + +@param aStatus On completion, contains the status of the request: + KErrNone, the timer completed normally at the requested time; + KErrCancel, the timer was cancelled; + KErrAbort, the timer was aborted because the system time changed; + KErrUnderflow, the requested completion time is in the past; + KErrOverFlow, the requested completion time is too far in the future; +@param aTime The time at which the timer will expire. + +@panic KERN-EXEC 15, if this function is called while a request for a timer + event is still outstanding. +*/ + { + + aStatus=KRequestPending; + TInt64 time=aTime.Int64(); + time -= ((TInt64)User::UTCOffset().Int()) * 1000000; + Exec::TimerAt(iHandle,aStatus,time); + } + + + + +EXPORT_C void RTimer::AtUTC(TRequestStatus &aStatus,const TTime &aUTCTime) +// +// Request an absolute timer in UTC time. +// +/** +Requests an event at a given UTC time. + +If the machine is off at that time, it is automatically turned on. + +@param aStatus On completion, contains the status of the request: + KErrNone, the timer completed normally at the requested time; + KErrCancel, the timer was cancelled; + KErrAbort, the timer was aborted because the system time changed; + KErrUnderflow, the requested completion time is in the past; + KErrOverFlow, the requested completion time is too far in the future; +@param aTime The time at which the timer will expire. + +@panic KERN-EXEC 15, if this function is called while a request for a timer + event is still outstanding. +*/ + { + + aStatus=KRequestPending; + Exec::TimerAt(iHandle,aStatus,aUTCTime.Int64()); + } + + + + +EXPORT_C void RTimer::Lock(TRequestStatus &aStatus,TTimerLockSpec aLock) +// +// Request an absolute timer. +// +/** +Requests an event on a specified second fraction. + +@param aStatus On completion, contains the status of the request: + KErrGeneral, the first time this is called; + KErrNone, the timer completed normally at the requested time; + KErrCancel, the timer was cancelled; + KErrAbort, the timer was aborted because the system time changed; + KErrUnderflow, the requested completion time is in the past; + KErrOverFlow, the requested completion time is too far in the future. +@param aLock The fraction of a second at which the timer completes. + +@panic KERN-EXEC 15, if this function is called while a request for a timer + event is still outstanding. +*/ + { + aStatus=KRequestPending; + Exec::TimerLock(iHandle,aStatus,aLock); + } + + +/** +Requests an event to be triggered when aSeconds is exactly, (ie not greater or +less than), the time elapsed (to the nearest second) since the last user activity. +If the event trigger time has been "missed", instead of triggering late, +the timer waits for the next user activity, to try and satisfy the condition. + +That is to say, if there was user activity within the last aSeconds, +the event will be triggered after aSeconds of continuous inactivity following that activity. +Otherwise, if there has been no such activity within this time, an event is +triggered after aSeconds of continuous inactivity following the next user activity +in the future. + +It follows from this, that you can request an event directly after the next +user activity by supplying a time interval of zero. + + +@param aStatus On completion, contains the status of the request: + KErrNone, the timer completed normally; + KErrCancel, the timer was cancelled; + KErrArgument, if aSeconds is less then zero; + KErrOverflow, if aSecond reaches its limit (which is platform specific but greater then one and a half day). +@param aSeconds The time interval in seconds. + +@panic KERN-EXEC 15, if this function is called while a request for a timer + event is still outstanding. +*/ +EXPORT_C void RTimer::Inactivity(TRequestStatus &aStatus, TTimeIntervalSeconds aSeconds) + { + aStatus=KRequestPending; + Exec::TimerInactivity(iHandle, aStatus, aSeconds.Int()); + } + + + + +EXPORT_C TInt RChangeNotifier::Logon(TRequestStatus& aStatus) const +/** +Issues a request for notification when changes occur in the environment. + +A switch in locale, or crossing over past midnight, are examples of changes +that are reported. + +When a change in the environment occurs, the request completes and the +TRquestStatus object will contain one or more of the bit values defined +by the TChanges enum. + +Alternatively, if an outstanding request is cancelled by a call to +this handle's LogonCancel() member function, then the request completes +with a KErrCancel. + +Note that if this is the first notification request after creation of +the change notifier, then this request completes immediately. + +@param aStatus A reference to the request status object. + +@return KErrInUse, if there is an outstanding request; KErrNone otherwise. + +@see TChanges +@see RChangeNotifier::Logon() +*/ + { + + aStatus=KRequestPending; + return(Exec::ChangeNotifierLogon(iHandle,aStatus)); + } + + + + +EXPORT_C TInt RChangeNotifier::LogonCancel() const +/** +Cancels an outstanding change notification request. + +@return KErrGeneral, if there is no outstanding request; KErrNone otherwise. + +@see RChangeNotifier::Logon() +*/ + { + + return(Exec::ChangeNotifierLogoff(iHandle)); + } + + + + +EXPORT_C void UserSvr::CaptureEventHook() +// +// Capture the event hook +// + { + + Exec::CaptureEventHook(); + } + +EXPORT_C void UserSvr::ReleaseEventHook() +// +// Release the event hook +// + { + + Exec::ReleaseEventHook(); + } + +EXPORT_C void UserSvr::RequestEvent(TRawEventBuf &anEvent,TRequestStatus &aStatus) +// +// Request the next event. +// + { + + aStatus=KRequestPending; + Exec::RequestEvent(anEvent,aStatus); + } + +EXPORT_C void UserSvr::RequestEventCancel() +// +// Cancel the event request. +// + { + + Exec::RequestEventCancel(); + } + +/** +Add an event to the queue. + +@param anEvent The raw hardware event to be added to the event queue. +@return KErrNone, if successful; KErrPermissionDenied, if the caller has +insufficient capability; otherwise, one of the other system-wide error codes. + +@capability SwEvent +@capability PowerMgmt for ESwitchOff, ERestartSystem, ECaseOpen and ECaseClose +*/ +EXPORT_C TInt UserSvr::AddEvent(const TRawEvent& anEvent) + { + + return(Exec::AddEvent(anEvent)); + } + +EXPORT_C void UserSvr::ScreenInfo(TDes8 &anInfo) +// +// Get the screen info. +// + { + + Exec::HalFunction(EHalGroupDisplay,EDisplayHalScreenInfo,(TAny*)&anInfo,NULL); + } + +#ifdef __USERSIDE_THREAD_DATA__ + +EXPORT_C TAny* UserSvr::DllTls(TInt aHandle) +// +// Return the value of the Thread Local Storage variable. +// + { + return LocalThreadData()->DllTls(aHandle, KDllUid_Default); + } + +EXPORT_C TAny* UserSvr::DllTls(TInt aHandle, TInt aDllUid) +// +// Return the value of the Thread Local Storage variable. +// + { + return LocalThreadData()->DllTls(aHandle, aDllUid); + } + +#else + +EXPORT_C TAny* UserSvr::DllTls(TInt aHandle) +// +// Return the value of the Thread Local Storage variable. +// + { + + return Exec::DllTls(aHandle, KDllUid_Default); + } + +EXPORT_C TAny* UserSvr::DllTls(TInt aHandle, TInt aDllUid) +// +// Return the value of the Thread Local Storage variable. +// + { + + return Exec::DllTls(aHandle, aDllUid); + } + +#endif + +EXPORT_C void UserSvr::DllFileName(TInt aHandle, TDes& aFileName) +// +// Return the filename of this dll +// + { + TBuf8 n8; + Exec::DllFileName(aHandle, n8); + aFileName.Copy(n8); + } + +EXPORT_C TBool UserSvr::TestBootSequence() +// +// Is the machine being booted by the test department? +// + { + + return Exec::HalFunction(EHalGroupPower,EPowerHalTestBootSequence,NULL,NULL); + } + +/** +Register whether the W/S takes care of turning the screen on +*/ +EXPORT_C void UserSvr::WsRegisterSwitchOnScreenHandling(TBool aState) + { + + Exec::HalFunction(EHalGroupDisplay,EDisplayHalWsRegisterSwitchOnScreenHandling,(TAny*)aState,NULL); + } + +EXPORT_C void UserSvr::WsSwitchOnScreen() +// +// W/S switch on the screen +// + { + + Exec::HalFunction(EHalGroupDisplay,EDisplayHalWsSwitchOnScreen,NULL,NULL); + } + + +EXPORT_C TUint32 UserSvr::DebugMask() +/** +Return the kernel debug mask at index 0 +*/ + { + return Exec::DebugMask(); + } + + +EXPORT_C TUint32 UserSvr::DebugMask(TUint aIndex) +/** +Return the kernel debug mask at the given index position + +@param aIndex An index of which 32 bit mask word is to be accessed +*/ + { + return Exec::DebugMaskIndex(aIndex); + } +#endif // __TOOLS2__ + + +EXPORT_C TTrapHandler *User::TrapHandler() +/** +Gets a pointer to the current thread's trap handler. + +Note that TTrapHandler is an abstract base class; a trap handler must be +implemented as a derived class. + +@return A pointer to the current thread's trap handler, if any. NULL, if no + pre-existing trap handler is set. +*/ + { + + return GetTrapHandler(); + } + + + + +EXPORT_C TTrapHandler *User::SetTrapHandler(TTrapHandler *aHandler) +/** +Sets the current thread's trap handler and returns a pointer to any pre-existing +trap handler. + +Pass a NULL pointer to this function to clear the trap handler. + +The trap handler works with the TRAP mechanism to handle the effects of a +leave. + +Note that TTrapHandler is an abstract base class; a trap handler must be +implemented as a derived class. + +@param aHandler A pointer to the trap handler which is to be installed as + the current thread's trap handler. + +@return A pointer to the current thread's pre-existing trap handler, if any. + NULL, if no pre-existing trap handler is set. + +@see TRAP +@see TRAPD +*/ + { + + TTrapHandler* prev; +#if defined(__USERSIDE_THREAD_DATA__) && defined(__LEAVE_EQUALS_THROW__) + prev = LocalThreadData()->iTrapHandler; +#else + prev = Exec::SetTrapHandler(aHandler); +#endif +#ifdef __USERSIDE_THREAD_DATA__ + LocalThreadData()->iTrapHandler = aHandler; +#endif + return prev; + } + +#ifndef __LEAVE_EQUALS_THROW__ +EXPORT_C TTrapHandler* User::MarkCleanupStack() +/** +If there's a TTrapHandler installed marks the cleanup stack and returns +the TTrapHandler for subsequent use in UnMarkCleanupStack. + +Only intended for use in the defintion of TRAP and TRAPD and only when +User::Leave is defined in terms of THROW. + +@return A pointer to the current thread's pre-existing trap handler, if any. + NULL, if no pre-existing trap handler is set. + +@see TRAP +@see TRAPD +*/ + { + return (TTrapHandler*)0; + } + + +EXPORT_C void User::UnMarkCleanupStack(TTrapHandler* /*aHandler*/) +/** +If passed a non-null TTrapHandler unmarks the cleanup stack. + +Only intended for use in the defintion of TRAP and TRAPD and only when +User::Leave is defined in terms of THROW. + +@see TRAP +@see TRAPD +*/ + {} + +#else + +EXPORT_C TTrapHandler* User::MarkCleanupStack() +/** +If there's a TTrapHandler installed marks the cleanup stack and returns +the TTrapHandler for subsequent use in UnMarkCleanupStack. + +Only intended for use in the defintion of TRAP and TRAPD and only when +User::Leave is defined in terms of THROW. + +@return A pointer to the current thread's pre-existing trap handler, if any. + NULL, if no pre-existing trap handler is set. + +@see TRAP +@see TRAPD +*/ + { + + TTrapHandler* pH = GetTrapHandler(); + if (pH) + pH->Trap(); + return pH; + } + +EXPORT_C void User::UnMarkCleanupStack(TTrapHandler* aHandler) +/** +If passed a non-null TTrapHandler unmarks the cleanup stack. + +Only intended for use in the defintion of TRAP and TRAPD and only when +User::Leave is defined in terms of THROW. + +@see TRAP +@see TRAPD +*/ + { + + if (aHandler) + aHandler->UnTrap(); + } + +#endif + +#ifndef __TOOLS2__ +EXPORT_C TInt User::Beep(TInt aFrequency,TTimeIntervalMicroSeconds32 aDuration) +/** +Makes a beep tone with a specified frequency and duration. + +This function should not be used. It exists to maintain compatibility with +older versions of Symban OS. +*/ + { + + return Exec::HalFunction(EHalGroupSound,ESoundHalBeep,(TAny*)aFrequency,(TAny*)aDuration.Int()); + } + + + + +// Unused, exists only for BC reasons +EXPORT_C TInt UserSvr::HalGet(TInt, TAny*) + { + return KErrNotSupported; + } + +// Unused, exists only for BC reasons +EXPORT_C TInt UserSvr::HalSet(TInt, TAny*) + { + return KErrNotSupported; + } + +EXPORT_C TInt UserSvr::HalFunction(TInt aGroup, TInt aFunction, TAny* a1, TAny* a2) + { + + return Exec::HalFunction(aGroup, aFunction, a1, a2); + } + +EXPORT_C TInt UserSvr::HalFunction(TInt aGroup, TInt aFunction, TAny* a1, TAny* a2, TInt aDeviceNumber) + { + + return Exec::HalFunction(aGroup | (aDeviceNumber<<16), aFunction, a1, a2); + } + +/** +@capability WriteDeviceData +*/ +EXPORT_C TInt UserSvr::SetMemoryThresholds(TInt aLowThreshold, TInt aGoodThreshold) + { + return Exec::SetMemoryThresholds(aLowThreshold,aGoodThreshold); + } + +/** +@deprecated +@internalAll +@return EFalse +*/ +EXPORT_C TBool UserSvr::IpcV1Available() + { + return EFalse; + } + + + +EXPORT_C void User::SetDebugMask(TUint32 aVal) +/** +Sets the debug mask. + +@param aVal A set of bit values as defined in nk_trace.h +*/ + { + Exec::SetDebugMask(aVal); + } + +EXPORT_C void User::SetDebugMask(TUint32 aVal, TUint aIndex) +/** +Sets the debug mask at the given index + +@param aVal A set of bit values as defined in nk_trace.h +@param aIndex An index of which 32 bit mask word is to be accessed +*/ + { + Exec::SetDebugMaskIndex(aVal, aIndex); + } + + +/** +Gets machine information. + +@publishedPartner +@deprecated Use HAL::Get() from the HAL library instead. +*/ +EXPORT_C TInt UserHal::MachineInfo(TDes8& anInfo) + { + TInt bufLength=anInfo.MaxLength(); + __ASSERT_ALWAYS(bufLength==sizeof(TMachineInfoV2) || bufLength==sizeof(TMachineInfoV1),Panic(ETDes8BadDescriptorType)); + + // assemble a TMachineInfoV1 buffer + TMachineInfoV2* info=&((TMachineInfoV2Buf&)anInfo)(); + // Variant stuff + TVariantInfoV01Buf infoBuf; + TInt r = Exec::HalFunction(EHalGroupVariant, EVariantHalVariantInfo, (TAny*)&infoBuf, NULL); + if (KErrNone != r) return r; // must always be implemented! + TVariantInfoV01& variantInfo = infoBuf(); + + info->iRomVersion=variantInfo.iRomVersion; + info->iMachineUniqueId=variantInfo.iMachineUniqueId; + info->iLedCapabilities=variantInfo.iLedCapabilities; + info->iProcessorClockInKHz=variantInfo.iProcessorClockInKHz; + info->iSpeedFactor=variantInfo.iSpeedFactor; + + // Video driver stuff + TVideoInfoV01Buf vidinfoBuf; + r = Exec::HalFunction(EHalGroupDisplay, EDisplayHalCurrentModeInfo, (TAny*)&vidinfoBuf, NULL); + if (KErrNone == r) + { + TVideoInfoV01& vidinfo = vidinfoBuf(); + info->iDisplaySizeInPixels=vidinfo.iSizeInPixels; + info->iPhysicalScreenSize=vidinfo.iSizeInTwips; + } + else // no display driver + { + info->iDisplaySizeInPixels.iWidth=0; + info->iDisplaySizeInPixels.iHeight=0; + info->iPhysicalScreenSize.iWidth=0; + info->iPhysicalScreenSize.iHeight=0; + } + TInt colors = 0; + r = Exec::HalFunction(EHalGroupDisplay, EDisplayHalColors, &colors, NULL); + info->iMaximumDisplayColors=(KErrNone == r)?colors:0; + TInt val; + info->iBacklightPresent= (KErrNone == Exec::HalFunction(EHalGroupDisplay, EDisplayHalBacklightOn, &val, NULL)); + + // Pointing device stuff + TDigitiserInfoV01Buf xyinfoBuf; + r = Exec::HalFunction(EHalGroupDigitiser, EDigitiserHalXYInfo, (TAny*)&xyinfoBuf, NULL); + if (KErrNone == r) + { + info->iXYInputType=EXYInputPointer; // XY is Digitiser + TDigitiserInfoV01& xyinfo = xyinfoBuf(); + info->iXYInputSizeInPixels=xyinfo.iDigitiserSize; + info->iOffsetToDisplayInPixels=xyinfo.iOffsetToDisplay; + } + else + { + TMouseInfoV01Buf mouseinfoBuf; + r = Exec::HalFunction(EHalGroupMouse, EMouseHalMouseInfo, (TAny*)&mouseinfoBuf, NULL); + if (KErrNone == r) + { + info->iXYInputType=EXYInputMouse; // XY is Mouse + TMouseInfoV01& mouseinfo = mouseinfoBuf(); + info->iXYInputSizeInPixels=mouseinfo.iMouseAreaSize; + info->iOffsetToDisplayInPixels=mouseinfo.iOffsetToDisplay; + } + else + { + info->iXYInputType=EXYInputNone; // no XY + info->iXYInputSizeInPixels.iWidth=0; + info->iXYInputSizeInPixels.iHeight=0; + info->iOffsetToDisplayInPixels.iX=0; + info->iOffsetToDisplayInPixels.iY=0; + } + } + + // Keyboard stuff + TKeyboardInfoV01Buf kbdinfoBuf; + info->iKeyboardPresent= (KErrNone == Exec::HalFunction(EHalGroupKeyboard, EKeyboardHalKeyboardInfo, (TAny*)&kbdinfoBuf, NULL)); + + // Unused, obsolete parameters + info->iKeyboardId=0; + info->iDisplayId=0; + if(bufLength==sizeof(TMachineInfoV2)) + { + // assemble a TMachineInfoV2 buffer + info->iLanguageIndex=0; + info->iKeyboardIndex=0; + } + + anInfo.SetLength(bufLength); + + return KErrNone; + } + +/** +Gets memory information. + +@see HAL::Get() + +@publishedPartner +@deprecated Use HAL::Get() from the HAL library instead with attributes EMemoryRAM, EMemoryRAMFree or EMemoryROM. +*/ +EXPORT_C TInt UserHal::MemoryInfo(TDes8& anInfo) + { + return Exec::HalFunction(EHalGroupKernel,EKernelHalMemoryInfo,(TAny*)&anInfo,NULL); + } + +/** +Gets ROM configuration information. + +@publishedPartner +@deprecated No replacement. +*/ +EXPORT_C TInt UserHal::RomInfo(TDes8& anInfo) + { + return Exec::HalFunction(EHalGroupKernel,EKernelHalRomInfo,(TAny*)&anInfo,NULL); + } + + + + +/** +Gets drive information. + +@param anInfo A package buffer (TPckgBuf) containing a TDriveInfoV1 structure. + On return, this structure will contain the drive information. + +@return KErrNone + +@see TDriveInfoV1Buf +@see TDriveInfoV1 +@see TPckgBuf +*/ +EXPORT_C TInt UserHal::DriveInfo(TDes8& anInfo) + { + TDriveInfoV1Buf8 anInfo8; + TInt r = Exec::HalFunction(EHalGroupMedia,EMediaHalDriveInfo,(TAny*)&anInfo8,NULL); + TDriveInfoV18& driveInfo8 = anInfo8(); + TDriveInfoV1* driveInfo = NULL; + switch(((SBuf8*)&anInfo)->length>>KShiftDesType8) //type + { + case EPtr: + driveInfo = &((TPckg&)anInfo)(); + break; + case EBuf: + driveInfo = &((TDriveInfoV1Buf&)anInfo)(); + break; + default: + __ASSERT_ALWAYS(EFalse,Panic(ETDes8BadDescriptorType)); + } + + // A compile time assert to make sure that this function is examined if TDriveInfoV1 + // structure changes + extern int TDriveInfoV1_structure_assert[( + _FOFF(TDriveInfoV1,iRegisteredDriveBitmask)+4 == sizeof(TDriveInfoV1) + && + sizeof(TDriveInfoV1) == 816 + )?1:-1]; + (void)TDriveInfoV1_structure_assert; + + // Set length to size of old EKA1 TDriveInfoV1 (Will Panic if not big enough) + TInt len = (TUint)_FOFF(TDriveInfoV1,iRegisteredDriveBitmask); + anInfo.SetLength(len); + + // Fill in info for old EKA1 TDriveInfoV1 + driveInfo->iTotalSupportedDrives = driveInfo8.iTotalSupportedDrives; + driveInfo->iTotalSockets = driveInfo8.iTotalSockets; + driveInfo->iRuggedFileSystem = driveInfo8.iRuggedFileSystem; + TInt index; + for(index=0;indexiDriveName[index].Copy(driveInfo8.iDriveName[index]); + for(index=0;indexiSocketName[index].Copy(driveInfo8.iSocketName[index]); + + // If anInfo is big enough then set new EKA2 members of TDriveInfoV1 + if((TUint)anInfo.MaxLength()>=(TUint)sizeof(TDriveInfoV1)) + { + anInfo.SetLength(sizeof(TDriveInfoV1)); + driveInfo->iRegisteredDriveBitmask = driveInfo8.iRegisteredDriveBitmask; + } + return r; + } + + + + +/** +Gets the startup reason. + +@see HAL::Get() + +@publishedPartner +@deprecated Use HAL::Get() from the HAL library instead with attributes ESystemStartupReason. +*/ +EXPORT_C TInt UserHal::StartupReason(TMachineStartupType& aReason) + { + return Exec::HalFunction(EHalGroupKernel,EKernelHalStartupReason,(TAny*)&aReason,NULL); + } + + + + +/** +Gets the reason why the kernel last faulted. + +@param aReason An integer that, on return, contains the reason code describing + why the kernel faulted. This is the fault number passed + in a call to Kern::Fault(). + +@return KErrNone + +@see Kern::Fault() +*/ +EXPORT_C TInt UserHal::FaultReason(TInt &aReason) + { + + return Exec::HalFunction(EHalGroupKernel,EKernelHalFaultReason,(TAny *)&aReason,NULL); + } + + + + +/** +Gets the exception Id that describes the type of fault when +the kernel last faulted. + +The Id is the value contained in TArmExcInfo::iExcCode. + +@param anId An integer that, on return, contains the exception Id. + +@return KErrNone + +@see TArmExcInfo::iExcCode +@see TArmExcInfo +*/ +EXPORT_C TInt UserHal::ExceptionId(TInt &anId) + { + + return Exec::HalFunction(EHalGroupKernel,EKernelHalExceptionId, (TAny *)&anId, NULL); + } + + + +/** +Gets the available exception information that describes the last kernel fault. + +@param aInfo A TExcInfo structure that, on return, contains the available + exception information. + +@return KErrNone + +@see TExcInfo +*/ +EXPORT_C TInt UserHal::ExceptionInfo(TExcInfo &aInfo) + { + + return Exec::HalFunction(EHalGroupKernel,EKernelHalExceptionInfo, (TAny *)&aInfo, NULL); + } + + + + +/** +Gets the page size for this device. + +@param anId An integer that, on return, contains the page size, in bytes, + for this device. + +@return KErrNone +*/ +EXPORT_C TInt UserHal::PageSizeInBytes(TInt& aSize) + { + + return Exec::HalFunction(EHalGroupKernel,EKernelHalPageSizeInBytes,(TAny*)&aSize,NULL); + } + + + + +/** +Switches the device off. + +@return KErrNone, if successful; KErrPermissionDenied, if the calling process + has insufficient capability. + +@capability PowerMgmt +*/ +EXPORT_C TInt UserHal::SwitchOff() + { + if(!RProcess().HasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by UserHal::SwitchOff"))) + return KErrPermissionDenied; + TInt r = Power::EnableWakeupEvents(EPwStandby); + if(r!=KErrNone) + return r; + TRequestStatus s; + Power::RequestWakeupEventNotification(s); + Power::PowerDown(); + User::WaitForRequest(s); + return s.Int(); +// return Exec::HalFunction(EHalGroupPower,EPowerHalSwitchOff,NULL,NULL); + } + + + + +/** +Sets the calibration data for the digitiser (i.e. XY) input device. + +@param aCalibration The calibration data. + +@return KErrNone, if successful; KErrPermissionDenied, if the calling process + has insufficient capability. + +@see TDigitizerCalibration + +@capability WriteDeviceData +*/ +EXPORT_C TInt UserHal::SetXYInputCalibration(const TDigitizerCalibration& aCalibration) + { + return Exec::HalFunction(EHalGroupDigitiser,EDigitiserHalSetXYInputCalibration,(TAny*)&aCalibration,NULL); + } + + + + +/** +Gets the points on the display that the user should point to in order +to calibrate the digitiser (i.e. XY) input device. + +@param aCalibration A TDigitizerCalibration object that, on return, contains + the appropriate information. + +@return KerrNone, if successful; otherwise one of the other system wide + error codes. +*/ +EXPORT_C TInt UserHal::CalibrationPoints(TDigitizerCalibration& aCalibration) + { + + return Exec::HalFunction(EHalGroupDigitiser,EDigitiserHalCalibrationPoints,(TAny*)&aCalibration,NULL); + } + + + + +/** +Gets the platform tick period. + +@param aTime The tick period in microseconds. + +@return KErrNone, if successful; otherwise one of the other system wide + error codes. +*/ +EXPORT_C TInt UserHal::TickPeriod(TTimeIntervalMicroSeconds32 &aTime) + { + + return Exec::HalFunction(EHalGroupKernel,EKernelHalTickPeriod,(TAny*)&aTime,NULL); + } + + + +/** +Saves the current digitiser (i.e. XY) input device calibration data. + +@return KErrNone, if successful; otherwise one of the other system wide + error codes, e.g. KErrNotSupported. +*/ +EXPORT_C TInt UserHal::SaveXYInputCalibration() + { + + return Exec::HalFunction(EHalGroupDigitiser,EDigitiserHalSaveXYInputCalibration,NULL,NULL); + } + + + + +/** +Restores the digitiser (i.e. XY) input device calibration data. + +@param aType A TDigitizerCalibration object that, on return, contains + the calibration data. + +@return KErrNone, if successful; KErrPermissionDenied, if the calling process + has insufficient capability; otherwise one of the other system wide + error codes, e.g. KErrNotSupported. + +@capability WriteDeviceData +*/ +EXPORT_C TInt UserHal::RestoreXYInputCalibration(TDigitizerCalibrationType aType) + { + return Exec::HalFunction(EHalGroupDigitiser,EDigitiserHalRestoreXYInputCalibration,(TAny*)aType,NULL); + } + + + + +/** +Gets the machine configuration. + +@param aConfig On return contains the machine configuration data. +@param aSize On return, contains the size of the data. + +@return KErrNone, if sucessful, otherwise one of the other system-wide + error codes. + +@capability ReadDeviceData +*/ +EXPORT_C TInt User::MachineConfiguration(TDes8& aConfig,TInt& aSize) + { + return(Exec::MachineConfiguration(aConfig,aSize)); + } +#endif // __TOOLS2__ + + + +EXPORT_C TInt RDebug::Print(TRefByValue aFmt,...) +// +// Print to the comms port +// + { + + TestOverflowTruncate overflow; + VA_LIST list; + VA_START(list,aFmt); + TBuf<0x100> buf; + buf.AppendFormatList(aFmt,list,&overflow); +#ifdef _UNICODE + TPtr8 p(buf.Collapse()); + Exec::DebugPrint((TAny*)&p, 0); +#else + Exec::DebugPrint((TAny*)&buf, 0); +#endif + return 0; + } + +class TestOverflowTruncate8 : public TDes8Overflow + { +public: + virtual void Overflow(TDes8& /*aDes*/) {} + }; + +EXPORT_C void RDebug::Printf(const char* aFmt, ...) +// +// Print to the comms port +// + { + + TestOverflowTruncate8 overflow; + VA_LIST list; + VA_START(list,aFmt); + TPtrC8 fmt((const TText8*)aFmt); + TBuf8<0x100> buf; + buf.AppendFormatList(fmt,list,&overflow); + Exec::DebugPrint((TAny*)&buf, 0); + } + +EXPORT_C void RDebug::RawPrint(const TDesC8& aDes) + { + Exec::DebugPrint((TAny*)&aDes, 1); + } + +EXPORT_C void RDebug::RawPrint(const TDesC16& aDes) +// +// Print to the comms port +// + { + TBuf8<0x100> aDes8; + if(aDes.Length()>0x100) + { + TPtrC ptr(aDes.Ptr(), 0x100); + aDes8.Copy(ptr); + } + else + aDes8.Copy(aDes); + Exec::DebugPrint((TAny*)&aDes8, 1); + } + +EXPORT_C TUint32 Math::Random() +/** +Gets 32 random bits from the kernel's random pool. + +@return The 32 random bits. +*/ + { + + return Exec::MathRandom(); + } + + +#ifndef __TOOLS2__ +EXPORT_C void User::IMB_Range(TAny* aStart, TAny* aEnd) +/** +Does the necessary preparations to guarantee correct execution of code in the +specified virtual address range. + +The function assumes that this code has been loaded or modified by user code. +Calling this function against uncommitted memory region is considered as S/W +bug and may generate exception on some memory models. + +The specified addresses are associated with a user writable code chunk as +created by RChunk::CreateLocalCode(). + +The function cleans the data cache to ensure that written data has been +committed to main memory and then flushes the instruction cache and branch +target buffer (BTB) to ensure that the code is loaded from main memory when +it is executed. +The Kernel uses the size of the range specified to decide whether to clean/flush +line-by-line or to simply clean/flush the entire cache. + +@param aStart The start virtual address of the region. +@param aEnd The end virtual address of the region. This location is not within + the region. + +@see RChunk::CreateLocalCode() +@see UserHeap::ChunkHeap() +*/ + { + + Exec::IMB_Range(aStart,(TUint32)aEnd-(TUint32)aStart); + } + + + + +/** +Sets the specified handle into the specified environment data slot +for this process. + +The APPARC framework (class CApaApplication etc.) uses some of the slots internally, +so programs that use this framework should ensure that they only use slots available +for public use. + +@param aSlot An index that identifies the environment data slot. + This is a value relative to zero; + i.e. 0 is the first item/slot. + This can range from 0 to 15. +@param aHandle The handle to be passed to this process. + +@return KErrNone, always. + +@panic KERN-EXEC 46 if this function is called by a thread running + in a process that is not the creator of this process, or + the handle is not local. +@panic KERN-EXEC 51 if aSlot is negative or is greater than or equal to + the value of KArgIndex. +@panic KERN-EXEC 52 if the specified slot is already in use. + +@see CApaApplication +@see CApaCommandLine::EnvironmentSlotForPublicUse() +*/ +EXPORT_C TInt RProcess::SetParameter(TInt aSlot, RHandleBase aHandle) + { + return Exec::ProcessSetHandleParameter(iHandle, aSlot, aHandle.Handle()); + } + + + + +/** +Sets the specified 16-bit descriptor data into the specified environment +data slot for this process. + +The APPARC framework (class CApaApplication etc.) uses some of the slots internally, +so programs that use this framework should ensure that they only use slots available +for public use. + +@param aSlot An index that identifies the environment data slot. + This is a value relative to zero; + i.e. 0 is the first item/slot. + This can range from 0 to 15. +@param aDes The 16-bit descriptor containing data be passed to this process. + +@return KErrNone, if successful, otherwise one of the other system + wide error codes. + +@panic KERN-EXEC 46 if this function is called by a thread running + in a process that is not the creator of this process. +@panic KERN-EXEC 51 if aSlot is negative or is greater than or equal to + the value of KArgIndex. +@panic KERN-EXEC 52 if the specified slot is already in use. +@panic KERN-EXEC 53 if the length of data passed is negative. + +@see CApaApplication +@see CApaCommandLine::EnvironmentSlotForPublicUse() +*/ +EXPORT_C TInt RProcess::SetParameter(TInt aSlot, const TDesC16& aDes) + { + return Exec::ProcessSetDataParameter(iHandle, aSlot, (const TUint8*)aDes.Ptr(), 2*aDes.Length()); + } + + + + +/** +Sets the specified 8-bit descriptor data into the specified environment +data slot for this process. + +The APPARC framework (class CApaApplication etc.) uses some of the slots internally, +so programs that use this framework should ensure that they only use slots available +for public use. + +@param aSlot An index that identifies the environment data slot. + This is a value relative to zero; + i.e. 0 is the first item/slot. + This can range from 0 to 15. +@param aDes The 8-bit descriptor containing data be passed to this process. + +@return KErrNone, if successful, otherwise one of the other system + wide error codes. + +@panic KERN-EXEC 46 if this function is called by a thread running + in a process that is not the creator of this process. +@panic KERN-EXEC 51 if aSlot is negative or is greater than or equal to + the value of KArgIndex. +@panic KERN-EXEC 52 if the specified slot is already in use. +@panic KERN-EXEC 53 if the length of data passed is negative. + +@see CApaApplication +@see CApaCommandLine::EnvironmentSlotForPublicUse() +*/ +EXPORT_C TInt RProcess::SetParameter(TInt aSlot, const TDesC8& aDes) + { + return Exec::ProcessSetDataParameter(iHandle, aSlot, aDes.Ptr(), aDes.Length()); + } + + + + +/** +Sets the specfied sub-session into the specified environment +data slot for this process. + +The APPARC framework (class CApaApplication etc.) uses some of the slots internally, +so programs that use this framework should ensure that they only use slots available +for public use. + +@param aSlot An index that identifies the environment data slot. + This is a value relative to zero; + i.e. 0 is the first item/slot. + This can range from 0 to 15. +@param aSession The sub-session. + +@return KErrNone, if successful, otherwise one of the other system + wide error codes. + +@panic KERN-EXEC 46 if this function is called by a thread running + in a process that is not the creator of this process. +@panic KERN-EXEC 51 if aSlot is negative or is greater than or equal to + the value of KArgIndex. +@panic KERN-EXEC 52 if the specified slot is already in use. +@panic KERN-EXEC 53 if the length of data passed is negative. + +@see CApaApplication +@see CApaCommandLine::EnvironmentSlotForPublicUse() +*/ +EXPORT_C TInt RProcess::SetParameter(TInt aSlot, const RSubSessionBase& aSession) + { + TInt handle = aSession.SubSessionHandle(); + return Exec::ProcessSetDataParameter(iHandle, aSlot, (const TUint8*)&handle, sizeof(handle)); + } + + + + +/** +Sets the specfied integer value into the specified environment +data slot for this process. + +The APPARC framework (class CApaApplication etc.) uses some of the slots internally, +so programs that use this framework should ensure that they only use slots available +for public use. + +@param aSlot An index that identifies the environment data slot. + This is a value relative to zero; + i.e. 0 is the first item/slot. + This can range from 0 to 15. +@param aData The integer value. + +@return KErrNone, if successful, otherwise one of the other system + wide error codes. + +@panic KERN-EXEC 46 if this function is called by a thread running + in a process that is not the creator of this process. +@panic KERN-EXEC 51 if aSlot is negative or is greater than or equal to + the value of KArgIndex. +@panic KERN-EXEC 52 if the specified slot is already in use. +@panic KERN-EXEC 53 if the length of data passed is negative. + +@see CApaApplication +@see CApaCommandLine::EnvironmentSlotForPublicUse() +*/ +EXPORT_C TInt RProcess::SetParameter(TInt aSlot, TInt aData) + { + return Exec::ProcessSetDataParameter(iHandle, aSlot, (TUint8*)&aData, sizeof(aData)); + } + + + + +EXPORT_C TInt User::GetTIntParameter(TInt aSlot, TInt& aData) +/** +Gets the specified environment data item belonging to the +current process; this is assumed to be a 32 bit value. + +Environment data may be stored in the process and is passed to a child process +on creation of that child process. + +On successful return from this function, the data item is deleted from +the process. + +@param aSlot An index that identifies the data item. + This is an index whose value is relative to zero; + i.e. 0 is the first item/slot. + This can range from 0 to 15, i.e. there are 16 slots. + +@param aData On sucessful return, contains the environment data item. + +@return KErrNone, if successful; + KErrNotFound, if there is no data; + KErrArgument, if the data is not binary data, or the data item in the + process is longer than 32 bits. + +@panic KERN-EXEC 51, if aSlot is negative or is greater than or equal to 16. +*/ + { + TInt ret = Exec::ProcessGetDataParameter(aSlot, (TUint8*)&aData, sizeof(TInt)); + if (ret < 0) + return ret; + return KErrNone; + } + + + + +EXPORT_C TInt User::ParameterLength(TInt aSlot) +/** +Gets the length of the specified item of environment data belonging to the +current process. + +Environment data may be stored in the process and is passed to a child process +on creation of that child process. + +@param aSlot An index that identifies the data item whose length is to be + retrieved. This is an index whose value is relative to zero; + i.e. 0 is the first item/slot. + This can range from 0 to 15, i.e. there are 16 slots. + +@return KErrNotFound, if there is no data; + KErrArgument, if the data is not binary data; + The length of the data item. + +@panic KERN-EXEC 51, if aSlot is negative or is greater than or equal to 16. +*/ + { + TInt ret = Exec::ProcessDataParameterLength(aSlot); + return ret; + } + + + + +EXPORT_C TInt User::GetDesParameter(TInt aSlot, TDes8& aDes) +/** +Gets the specified environment data item belonging to the +current process; this is assumed to be an 8-bit descriptor. + +Environment data may be stored in the process and is passed to a child process +on creation of that child process. + +On successful return from this function, the data item is deleted from +the process. + +@param aSlot An index that identifies the data item. + This is an index whose value is relative to zero; + i.e. 0 is the first item/slot. + This can range from 0 to 15, i.e. there are 16 slots. + +@param aDes On sucessful return, contains the environment data item; the + length of the descriptor is set to the length of the data item. + +@return KErrNone, if successful; + KErrNotFound, if there is no data; + KErrArgument, if the data is not binary data, or the data item in the + process is longer than the maximum length of aDes. + +@panic KERN-EXEC 51, if aSlot is negative or is greater than or equal to 16. +*/ + { + TInt ret = Exec::ProcessGetDataParameter(aSlot, (TUint8*)aDes.Ptr(), aDes.MaxLength()); + if (ret < 0) + return ret; + aDes.SetLength(ret); + return KErrNone; + } + + + + +EXPORT_C TInt User::GetDesParameter(TInt aSlot, TDes16& aDes) +/** +Gets the specified environment data item belonging to the +current process; this is assumed to be an 16-bit descriptor. + +Environment data may be stored in the process and is passed to a child process +on creation of that child process. + +On successful return from this function, the data item is deleted from +the process. + +@param aSlot An index that identifies the data item. + This is an index whose value is relative to zero; + i.e. 0 is the first item/slot. + This can range from 0 to 15, i.e. there are 16 slots. + +@param aDes On sucessful return, contains the environment data item; the + length of the descriptor is set to the length of the data item. + +@return KErrNone, if successful; + KErrNotFound, if there is no data; + KErrArgument, if the data is not binary data, or the data item in the + process is longer than the maximum length of aDes. + +@panic KERN-EXEC 51, if aSlot is negative or is greater than or equal to 16. +*/ + { + TInt ret = Exec::ProcessGetDataParameter(aSlot, (TUint8*)aDes.Ptr(), 2*aDes.MaxLength()); + if (ret < 0) + return ret; + aDes.SetLength(ret/2); + return KErrNone; + } + +/** +Gets the linear address of the exception descriptor for the code module in which +a specified code address resides. + +@param aCodeAddress The code address in question. +@return The address of the exception descriptor, or zero if there is none. + +*/ +EXPORT_C TLinAddr UserSvr::ExceptionDescriptor(TLinAddr aCodeAddress) + { + return Exec::ExceptionDescriptor(aCodeAddress); + } + +EXPORT_C TInt User::SetFloatingPointMode(TFloatingPointMode aMode, TFloatingPointRoundingMode aRoundingMode) +/** +Sets the hardware floating point mode for the current thread. This does not affect +software floating point calculations. The rounding mode can also be set. New threads created +by this thread will inherit the mode, thus to set the mode for a whole process, call this +method before you create any new threads. + +@param aMode The floating point calculation mode to use. +@param aRoundingMode The floating point rounding mode to use, defaults to nearest. + +@return KErrNone if successful, KErrNotSupported if the hardware does not support the + chosen mode, or there is no floating point hardware present. + +@see TFloatingPointMode +@see TFloatingPointRoundingMode +*/ + { + return(Exec::SetFloatingPointMode(aMode, aRoundingMode)); + } + + +EXPORT_C TUint32 E32Loader::PagingPolicy() +/** + Accessor function returns the code paging policy, as defined at ROM build time. + + @return Paging policy only. This function applies + EKernelConfigPagingPolicyMask to the config flags + before returning the value. + */ + { + return Exec::KernelConfigFlags() & EKernelConfigPagingPolicyMask; + } + + +/** Queue a notifier to detect system idle + +@internalTechnology +@prototype +*/ +EXPORT_C void User::NotifyOnIdle(TRequestStatus& aStatus) + { + aStatus = KRequestPending; + Exec::NotifyOnIdle(&aStatus); + } + + +/** Cancel a miscellaneous notification requested by this thread + +Cancels a currently outstanding notification for system idle or object +deletion. + +@internalTechnology +@prototype +*/ +EXPORT_C void User::CancelMiscNotifier(TRequestStatus& aStatus) + { + Exec::CancelMiscNotifier(&aStatus); + } + + +/** Queue a notifier to detect destruction of this object + +To cancel the notifier, use User::CancelMiscNotifier(). + +@internalTechnology +@prototype +*/ +EXPORT_C void RHandleBase::NotifyDestruction(TRequestStatus& aStatus) + { + aStatus = KRequestPending; + Exec::NotifyObjectDestruction(iHandle, &aStatus); + } + +#else // __TOOLS2__ + +#ifdef _DEBUG +// The following are for simulating heap failure +TInt gAllocCount = 0; +TInt gAllocFailRate = 0; +RAllocator::TAllocFail gAllocFailType = RAllocator::ENone; +#endif + +EXPORT_C void User::__DbgMarkStart(TBool aKernel) + { + } + +EXPORT_C TUint32 User::__DbgMarkEnd(TBool aKernel, TInt aCount) + { + return 0; + } + +EXPORT_C void User::__DbgSetAllocFail(TBool aKernel, RAllocator::TAllocFail aFail, TInt aRate) + { +#ifdef _DEBUG + gAllocFailType = aFail; + + switch (gAllocFailType) + { + case RAllocator::EFailNext: + gAllocFailRate = gAllocCount + aRate; + break; + case RAllocator::EDeterministic: + gAllocCount = 0; + gAllocFailRate = aRate; + break; + default: + break; + } +#endif + } + +EXPORT_C void User::__DbgMarkCheck(int, int, int, unsigned char const*, int) + { + } + +EXPORT_C void RHandleBase::Close() + { + } + +#endif // __TOOLS2__