Category: +USER

diff -r 4816d766a08a -r f345bda72bc4 Symbian3/PDK/Source/GUID-7F04A8FF-7D3B-53DA-95D1-7BBB9C2949CD.dita --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Symbian3/PDK/Source/GUID-7F04A8FF-7D3B-53DA-95D1-7BBB9C2949CD.dita Tue Mar 30 11:56:28 2010 +0100 @@ -0,0 +1,1238 @@ + + + + + +Category: +USER +

Panics with this category are raised on the user side by member functions +of T type and R type classes, which reside in the euser.dll file.

They are also raised by some static member functions of the User, UserHeap and RHeap classes. +Typically, they are caused by passing bad or contradictory values to class +constructors or member functions.

The thread causing the panic is terminated.

+ + + + +

This panic is raised when a thread calls Invariant .

The Invariant function +is called when a test for a class invariant fails while checking the internal +data of an object is self-consistent.

Check the design and implementation +of the class.

+ + +

This panic is raised when a TDateTime object +is constructed with an invalid date or time field.

+ + +

This panic is raised by the Ptr() member function +of a 16-bit variant descriptor if the descriptor is invalid.

Check +for ways in which the descriptor may have become corrupted, including an unsafe +use of cast.

+ + +

This panic is raised when a length value passed to a 16-bit variant +descriptor member function is invalid. It may be raised by some descriptor +constructors and, specifically, by the Replace() and Set() descriptor +member functions.

+ + +

This panic is raised when the index value passed to the 16-bit variant +descriptor Operator() is out of bounds

+ + +

This panic is raised when the position value passed to a 16-bit +variant descriptor member function is out of bounds. It may be raised by the Left(), Right(), Mid(), Insert(), Delete() and Replace() member +functions of TDes16.

+ + +

This panic is raised when any operation that moves or copies data +to a 16-bit variant descriptor, causes the length of that descriptor to exceed +its maximum length.

It may be caused by any of the copying, appending +or formatting member functions and, specifically, by the Insert, Replace, Fill, Fillz and ZeroTerminate descriptor member functions. It can also +be caused by the SetLength function. See TDes16.

+ + +

This panic is raised when the format string passed to the 16-bit +variant descriptor member functions Format and AppendFormat has +invalid syntax.

See TDes16::Format() and TDes16::AppendFormat().

+ + +

This panic is raised in debug builds only.

It is +raised by the AppendFormatList() member function of the 16-bit +variant descriptor TDes16, if an invalid variable list +is passed to the function when the format is %S or %s.

+ + +

This panic is raised when expanding or contracting an HBufC16 buffer +using the ReAlloc() or ReAllocL() descriptor +member functions. Specifically, the panic occurs if the new length being specified +is too small to contain the data.

+ + +

This panic is raised by the Replace() member function +of the 16-bit variant descriptor TDes16 when the length +of the source descriptor is negative or exceeds the maximum length of the +target descriptor.

+ + +

This panic is raised when 16-bit variant descriptors are constructed +with negative length values. It may also be raised if the Set(), Repeat() and +the Find() member functions are passed negative length values.

+ + +

This panic is raised when 16-bit variant descriptors are constructed +with negative maximum length values.

+ + +

This panic is raised by the Ptr() member function +of an 8 bit variant descriptor if the descriptor is invalid. Check for ways +in which the descriptor may have become corrupted, including an unsafe use +of cast.

+ + +

This panic is raised when a length value passed to an 8 bit variant +descriptor member function is invalid. It may be raised by some descriptor +constructors and, specifically, by the Replace() and Set() descriptor +member functions.

+ + +

This panic is raised when the index value passed to the 8 bit variant +descriptor Operator[] is out of bounds.

+ + +

This panic is raised when the position value passed to an 8 bit +variant descriptor member function is out of bounds. It may be raised by the Left(), Right(), Mid(), Insert(), Delete() and Replace() descriptor +member functions.

+ + +

This panic is raised when any operation that moves or copies data +to an 8 bit variant descriptor, causes the length of that descriptor to exceed +its maximum length.

It may be caused by any of the copying, appending +or formatting member functions and, specifically, by the Insert(), Replace(), Fill(), Fillz() and ZeroTerminate() descriptor member functions. It can +also be caused by the SetLength() function. See TDes8.

+ + +

This panic is raised when the format string passed to the 8 bit +variant descriptor member functions Format() and AppendFormat() has +invalid syntax.

See TDes8::Format() and TDes8::AppendFormat().

+ + +

This panic is raised in debug builds only.

This +panic is raised by the AppendFormatList() member function +of the 8-bit variant descriptor TDes8, if an invalid variable +list is passed to the function when the format is %S or %s.

+ + +

This panic is raised when expanding or contracting an HBufC8 buffer +using the ReAlloc() or ReAllocL() descriptor +member functions. Specifically, the panic occurs if the new length being specified +is too small to contain the data.

+ + +

This panic is raised by the Replace() member function +of the 8-bit variant descriptor TDes8, when the length +of the source descriptor is negative or exceeds the maximum length of the +target descriptor.

+ + +

This panic is raised when 8-bit variant descriptors are constructed +with negative length values. It may also be raised if the Set(), Repeat() and +the Find() member functions are passed negative length values.

+ + +

This panic is raised when 8-bit variant descriptors are constructed +with negative maximum length values.

+ + +

This panic is raised in debug builds only.

It is +raised by the Pos() member function of a TRawEvent. +The function returns the mouse/pen position encapsulated by the TRawEvent. +The panic is raised when the event is not a mouse/pen type event.

+ + +

This panic is raised in debug builds only.

It is +raised by the ScanCode() member function of a TRawEvent. +The function returns the scan code associated with a key down or key up event +encapsulated by the TRawEvent. The panic is raised when the +event is not a key down or key up event.

+ + +

This panic is raised in debug builds only.

It is +raised by the Modifiers() member function of a TRawEvent. +The function returns the modifers associated with a modifiers update event +encapsulated by the TRawEvent. The panic is raised when the +event is not a modifier update event.

+ + +

This panic is raised by the default At() virtual +member function of TKey. The function is intended to be +overridden by a derived class.

+ + +

This panic is raised by the default Swap() virtual +member function of TSwap. The function is intended to be +overridden by a derived class.

+ + +

This panic is raised by the operator() of a TUidType when +the index value passed to the operator is either negative or is greater than +or equal to the constant KMaxCheckedUid defined in e32const.h.

+ + +

This panic is raised by the Set(TDesC8&) member +function of TCheckedUid when the length of the descriptor +passed to the function is not equal to the size of a TCheckedUid object.

+ + +

This panic is raised when the size of a new heap is smaller than +the permitted minimum. It must be at least the size of an RHeap object.

On +the user side this is associated with the USER category. On the kernel side +this is associated with the KERN-HEAP category.

+ + +

This panic is caused by the UserHeap::ChunkHeap() static +function when the value defining the minimum length of the heap is greater +than the value defining the maximum length to which the heap can grow.

+ + +

This panic is raised by a number of RHeap member +functions, AllocLen(), Free(), FreeZ(), ReAlloc(), ReAllocL(), Adjust() and AdjustL() when a pointer +passed to these functions does not point to a valid cell.

+ + +

This panic is raised by the Adjust() and AdjustL() member +functions of an RHeap. It is caused when a heap cell is +being shrunk and the amount by which the cell is being shrunk is less than +the current length of the cell.

+ + +

This panic is raised by the Free() and FreeZ() member +functions of an RHeap. It is caused when the cell being +freed overlaps the next cell on the free list (i.e. the first cell on the +free list with an address higher than the one being freed).

+ + +

This panic is raised by the Free() and FreeZ() member +functions of an RHeap. It is caused when the cell being +freed overlaps the previous cell on the free list (i.e. the last cell on the +free list with an address lower than the one being freed).

+ + +

This panic is raised by the ReAlloc() and ReAllocL() member +functions of an RHeap. It is caused when the cell being +reallocated overlaps the next cell on the free list (i.e. the first cell on +the free list with an address higher than the one being reallocated).

+ + +

This panic is raised by the Alloc(), AllocL() or AllocLC() member +functions of RHeap. It is caused by trying to allocate +a cell from a heap, specifying an unsigned size value which is greater than +or equal to the value of KMaxTInt/2. The constant KMaxTInt is +defined in the e32const.h file.

This panic may +also be raised by the heap walker when it finds a bad allocated heap cell +size.

+ + +

This panic is raised by the heap walker when it finds a bad allocated +heap cell address.

+ + +

This panic is raised by the heap walker when it finds a bad free +heap cell address.

+ + +

This panic is raised in debug builds only.

It is +raised by the DbgMarkEnd() member function of RHeap in +debug builds when there has been no corresponding call to the DbgMarkStart() member +function; it is also caused when there are more calls to DbgMarkEnd() than +to DbgMarkStart(). These functions are part of the debug +assistance provided by the RHeap class.

+ + +

This panic is raised by the Adjust() and AdjustL() member +functions of an RHeap. It is caused when the offset from +the start of the cell being stretched or shrunk is a negative value.

+ + +

This panic is raised by the ReAlloc() and ReAllocL() member +functions of an RHeap. It is caused when the new size for +the cell being reallocated is a negative value.

+ + +

This panic is caused by the UserHeap::ChunkHeap() static +function when the value defining the minimum length of the heap is negative.

+ + +

This panic is caused by the UserHeap::ChunkHeap() static +function when the value defining the maximum length to which the heap can +grow, is negative.

+ + +

This panic is raised when closing a shared heap using the Close() member +function of RHeap and the access count is zero or negative. +A zero or negative access count suggests that an attempt is being made to +close the heap too many times.

+ + +

This panic is raised when opening a heap for shared access using +the Open() member function of RHeap and +the heap type is not EChunkNormal.

+ + +

This panic is raised by the UnGet() member function +of the 8-bit variant lexical analyzer, TLex8, if the character +position is already at the start of the string.

+ + +

This panic is raised by the Inc() member function +of the 8-bit variant lexical analyzer, TLex8, if the resulting +character position lies before the start of the string or after the end of +the string.

+ + +

This panic is raised by the SkipAndMark() member +function of the 8-bit variant lexical analyzer, TLex8, +if the resulting character position lies before the start of the string or +after the end of the string.

+ + +

This panic is raised by the ValidateMark() member +function of the 8-bit variant lexical analyzer, TLex8, +if the position of the extraction mark lies before the start of the string +or after the end of the string.

+ + +

This panic is raised by the UnGet() member function +of the 16-bit variant lexical analyzer, TLex16, if the +character position is already at the start of the string.

+ + +

This panic is raised by the Inc() member function +of the 16-bit variant lexical analyzer, TLex16, if the +resulting character position lies before the start of the string or after +the end of the string.

+ + +

This panic is raised by the SkipAndMark() member +function of the 16-bit variant lexical analyzer, TLex16, +if the resulting character position lies before the start of the string or +after the end of the string.

+ + +

This panic is raised by the ValidateMark() member +function of the 16-bit variant lexical analyzer, TLex16, +if the position of the extraction mark lies before the start of the string +or after the end of the string.

+ + +

This panic is raised by the TDateSuffix constructor +or its Set() member function when the suffix index specified +is negative or is greater than or equal to the value KMaxSuffixes defined +in e32const.h. The index is used to access a locale dependent +table of suffix characters which can be appended to the dates of the month +(e.g. the characters "st" for 1st, "nd" for 2nd, "st" for 31st).

+ + +

Introduced in 6.0: This panic is raised when attempting +to complete a client/server request and the RMessagePtr is +null.

Withdrawn in 6.0: This panic is raised by the SetRetry() member +function of RSessionBase, the client interface for communication +with a server, when the specified delay time between resending a message to +the server is either negative or a value greater than KMaxTInt (defined in +the e32const.h file).

+ + +

Withdrawn in 6.0: This panic is raised by the SetRetry member +function of RSessionBase, the client interface for communication +with a server, when the specified operation code identifying the required +service is either negative or a value greater than KMaxTInt (defined +in the e32const.h file).

Introduced in 6.0: This +panic is raised by the Send() and SendReceive() member +functions of RSessionBase, the client interface for communication +with a server, when the specified operation code identifying the required +service is either negative or a value greater than KMaxTInt (defined +in the e32const.h file).

+ + +

This panic is raised by the Receive() member function +of RServer, the handle to the server, when the attempt to +receive a message for the server, synchronously, fails.

+ + +

This panic is raised by the constructor of a singly linked list +header, a TSglQue or by the SetOffset() member +function when the specified offset is not 4 byte aligned, i.e. when it is +not divisible by 4.

+ + +

This panic is raised when attempting to remove an object from a +singly linked list, using the Remove() member function of TSglQue, +when that object is not in the list.

+ + +

This panic is raised by the constructor of a doubly linked list +header, a TDblQue or by the SetOffset() member +function, when the specified offset is not 4 byte aligned, i.e. when it is +not divisible by 4.

+ + +

This panic is raised in debug builds only.

It is +raised by a call to either the First() and Last() member +functions of a doubly linked list, a TDblQue, which return +pointers to the first and last element in the list respectively; the panic +occurs when the list is empty.

+ + +

This panic is raised in debug builds only.

It is +raised by the post increment operator, operator++, the post +decrement operator, operator— and the return current element +operator, operator T*, of the doubly linked list iterator, +a TDblQueIter; the panic occurs when the element returned +by these operators is not in the list. Typically, this is caused by the removal +of the element from the list prior to calling these operators.

+ + +

This panic is raised by the get rectangle operator, operator[], +of a clipping region, derived from the abstract base class TRegion. +The panic occurs when the index, which refers to the specific rectangle within +the region, is greater than or equal to the number of rectangles contained +within the region (as returned by the Count() member function).

The +index must be strictly less than the number of contained rectangles.

+ + +

This panic is raised in debug builds only.

It is +raised when sorting the rectangles within a clipping region, derived from +the abstract base class TRegion, using the Sort() member +function of TRegion. The panic occurs when the region is +invalid.

+ + +

This panic occurs when the Kernel sends a message to the Kernel +server and this completes with an error, i.e. an error code which is not KErrNone.

+ + +

This panic is raised by the Panic() member function +of RTest, the test class.

+ + +

This panic is raised by the CheckConsoleCreated() member +functions of RTest and RTestJ, the test +classes, when the creation of a console, as derived from a CConsoleBase, +fails.

+ + +

This panic is raised by the User::After() static +function which is used to suspend the current thread until the specified time +interval, in microseconds, has expired. The panic occurs when the specified +time interval is negative.

+ + +

This panic is raised when a relative timer event is requested from +an asynchronous timer service, an RTimer, using the After() member +function. The panic occurs when the requested time interval is negative.

+ + +

This panic is raised in debug builds only.

This +panic is raised by Mem::Compare(), Mem::CompareC() and Mem::CompareF(), +which compare two areas of memory. The panic occurs when the length of the +area of memory designated as the left hand area, is negative.

On the +user side this is associated with the USER category. On the kernel side this +is associated with the KERN-COMMON category.

+ + +

This panic is raised in debug builds only.

On +the user side this is associated with the USER category. On the kernel side +this is associated with the KERN-COMMON category.

+ + +

This panic is raised in debug builds only.

This +panic is raised by Mem::Copy(), which copies the content +of one area of memory to another. The panic occurs when the length of the +area of memory to be copied, is negative

On the user side this is +associated with the USER category. On the kernel side this is associated with +the KERN-COMMON category.

+ + +

This panic is raised in debug builds only.

This +panic is raised by Mem::Move(), which moves the content +of one area of memory to another. The panic occurs when the length of the +area of memory to be moved, is not a multiple of 4.

On the user side +this is associated with the USER category. On the kernel side this is associated +with the KERN-COMMON category.

+ + +

This panic is raised in debug builds only.

This +panic is raised by Mem::Move(), which moves the content of +one area of memory to another. The panic occurs when the address of the source +for the move operation, is not aligned on a 4 byte boundary.

On the +user side this is associated with the USER category. On the kernel side this +is associated with the KERN-COMMON category.

+ + +

This panic is raised in debug builds only.

This +panic is raised by Mem::Move(), which moves the content of +one area of memory to another. The panic occurs when the address of the target +for the move operation, is not aligned on a 4 byte boundary.

On the +user side this is associated with the USER category. On the kernel side this +is associated with the KERN-COMMON category.

+ + +

This panic is raised in debug builds only.

This +panic is raised by Mem::Swap(), which swaps the content +of one area of memory with another. The panic occurs when the length of the +area of memory to be swapped, is negative.

On the user side this is +associated with the USER category. On the kernel side this is associated with +the KERN-COMMON category.

+ + +

This panic is raised in debug builds only.

This +panic is raised by Mem::Fill() and Mem::FillZ(), +both of which fill an area of memory. The panic occurs when the length of +the area of memory to be filled, is negative.

On the user side this +is associated with the USER category. On the kernel side this is associated +with the KERN-COMMON category.

+ + +

This panic is raised by User::QuickSort(), when +the value for the number of records to be sorted, is negative.

+ + +

This panic is raised by User::BinarySearch(), +when the value for the number of records taking part in the search, is negative.

+ + +

This panic is raised by the constructor of the base key class, TKey. +It occurs when the offset value passed to the constructor is negative.As TKey is +an abstract class, i.e. objects of type TKey are not intended +to be explicitly constructed, look at the offset value passed to the constructors +of derived classes such as TKeyArrayFix, TKeyArrayVar and TKeyArrayPak for +the cause of the panic.

+ + +

This panic is raised when a local or global chunk is created using +the RChunk member functions: CreateLocal(), CreateGlobal(), CreateDoubleEndedLocal() and CreateDoubleEndedGlobal(). It occurs when the value +for the maximum size to which this chunk can be adjusted, is negative.

+ + +

100

This panic is raised when a local or global chunk is created using +the RChunk member functions: CreateLocal() and CreateGlobal(). +It occurs when the value for the number of bytes to be committed to this chunk +on creation, is negative.

+ + +

101

+ + +

102

This panic is raised when changing the number of bytes committed +to a chunk by calling the Adjust() member function of RChunk. +The panic occurs when the value passed to the function is negative.

+ + +

105

This panic is raised when a local or global semaphore is created +using the RSemaphore member functions: CreateLocal() and CreateGlobal(). +It occurs when the value for the initial semaphore count is negative.

+ + +

106

This panic is raised when a semaphore, an RSemaphore, +is signaled using the Signal(TInt aCount) member function +and the count value is negative.

+ + +

107

This panic is raised when a critical section, an RCriticalSection, +is signalled using the Signal() member function. The panic +occurs when the Signal() is not matched by an earlier call +to Wait() and suggests that this is a stray signal.

+ + +

109

This panic is raised when creating a thread using the Create() member +functions of RThread. The panic occurs when the value of +the stack size passed to these functions is negative.

+ + +

110

This panic is raised when creating a thread using the Create() member +functions of RThread. The panic is only raised by those +variants of Create() which create a new heap for the new +thread. The panic occurs if the minimum heap size specified is less than KMinHeapSize , +defined in e32const.h.

+ + +

111

+ + +

112

This panic is raised by the Alloc() and AllocL() member +functions of class RRef when the size value passed is negative.

+ + +

113

This panic is raised by:

the constructor of a +time representation object, a TTime, which takes a text +string, when the format of that text string is incorrect or represents an +invalid date or time.
the Parse() member +function of a time representation object, a TTime, if the +century offset value is either negative or is greater than or equal to 100.
the Time::DaysInMonth() function, +if an invalid month value is passed.

+ + +

114

This panic is raised in debug builds only.

This +panic is raised by member functions of a TBusLocalDrive when +no connection has been made to a local drive.

+ + +

115

This panic is raised when attempting to connect to a local drive +using the Connect() member function of TBusLocalDrive and +the specified drive number is out of range, i.e. the drive number is negative +or is greater than or equal to KMaxLocalDrives, defined in e32const.h.

+ + +

116

This panic is raised by the Lookup() member function +of an RLibrary, a handle to a dynamically loaded DLL, when +the ordinal number of the required DLL function, is zero or negative.

+ + +

119

This panic is raised when setting a new currency symbol using the User::SetCurrencySymbol() function. +The panic occurs when the length of the descriptor containing the new symbol +is greater than KMaxCurrencySymbol, defined in e32const.h.

+ + +

120

This panic is raised by the CreateDoubleEndedLocal() and CreateDoubleEndedGlobal() member +functions of an RChunk when the lower address of the committed +region is negative.

+ + +

121

This panic is raised by the CreateDoubleEndedLocal() and CreateDoubleEndedGlobal() member +functions of an RChunk when the upper address of the committed +region is negative.

+ + +

122

This panic is raised by the CreateDoubleEndedLocal() and CreateDoubleEndedGlobal() member +functions of an RChunk when the upper address of the committed +region is lower than the lower address of the committed region.

+ + +

123

+ + +

124

This panic is raised by the AdjustDoubleEnded() member +function of an RChunk when the lower address of the committed +region is negative.

+ + +

125

This panic is raised by the AdjustDoubleEnded() member +function of an RChunk when the upper address of the committed +region is negative.

+ + +

126

This panic is raised by the AdjustDoubleEnded() member +function of an RChunk when the upper address of the committed +region is lower than the lower address of the committed region.

+ + +

127

This panic is raised when constructing an array of pointers, an RPointerArray, +and specifying a granularity value which is one of the following:

zero
negative
greater than 0x10000000.

+ + +

128

This panic is raised when constructing an array of fixed length +objects, an RArray, and specifying a key offset value which +is one of the following:

negative
not a multiple of 4
greater than or equal +to the size of the array elements.

+ + +

129

This panic is raised when constructing an array of fixed length +objects, an RArray, and the length of the array elements +is one of the following:

zero
negative
greater than 640.

+ + +

130

This panic is raised when an index value passed to a member function +of a RArray or a RPointerArray identifying +an array element, is out of bounds.

+ + +

131

This panic is raised when the value identifying the insertion position +in a call to RArray::Insert() or RPointerArray::Insert() is +either negative or greater than the number of elements in the array.

+ + +

132

This panic is raised when an index value passed to Mem::CollationMethodByIndex() or Mem::CollationMethodId() is out of bounds.

+ + +

133

This panic is raised when an index value passed to TFixedArray::At() or TFixedArray::operator() is +out of bounds.

+ + +

137

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists. The panic is caused when +a parameter is too big.

+ + +

138

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists when an index value for +the parameters is outside its permitted range.

+ + +

139

This panic is raised in debug builds only.

This +panic is raised internally by the descriptor formatting functions during the +handling of the variable parameter lists when an index value for the parameters +is outside its permitted range.

+ + +

140

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

141

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

142

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

143

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

144

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

145

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

146

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

147

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

148

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

149

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

150

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

151

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

152

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

153

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

154

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

156

This panic is raised by the variants of the RArray or RPointerArray constructors +that take a value that defines the number of entries for the array. The panic +is caused when this number is not positive.

+ + +

157

This panic is raised by RChunk::Commit() when +the value of the offset of the committed region is negative.

+ + +

158

This panic is raised by RChunk::Commit() when the +size of the committed region is negative.

+ + +

159

This panic is raised by RChunk::Allocate() when +the size of the committed region is negative.

+ + +

160

This panic is raised by RChunk::Decommit() when +the value of the offset of the committed region is negative.

+ + +

161

This panic is raised by RChunk::Decommit() when +the size of the committed region is negative.

+ + +

162

This panic is raised when an invalid chunk type is passed to the +internal RChunk::Create() member function

See RChunk

+ + +

163

This panic is raised when a global chunk is being created and no +name has been specified.

See RChunk

+ + +

164

This panic is raised when creating a 'normal' chunk, and the offset +of the bottom of the new committed region from the base of the chunk's reserved +region is not zero.

See RChunk

+ + +

165

This panic is raised by the RLibrary::Init() internal +function when the function that constructs static data following a DLL load, +leaves.

See RLibrary

+ + +

166

This panic is raised internally, if a call to the static data destructors, +following closure of a library handle, leaves.

+ + +

167

This panic is raised in a call to RAllocator::Close() when +the number of handles is found to be greater than the maximum allowed, i.e. RAllocator::EMaxHandles.

+ + +

168

This panic is raised by the internal RHeap constructor +when the offset value is invalid, i.e. is negative or not appropriate for +the pagesize.

+ + +

169

This panic is raised by the RHeap::Reduce() internal +function on failure.

+ + +

170

This panic is raised by the RHeap::Reset() internal +function on failure.

+ + +

171

This panic is raised by the RHeap::WalkCheckCell() internal +function if it detects a free cell with an invalid size.

+ + +

172

This panic is raised by the RHeap::Initialise() internal +function when an alignment value is invalid, i.e is either less than the size +of a TAny* type, or is not a power of 2 (i.e. 2, 4, 8, 16 +etc).

+ + +

174

This panic is raised if any not implemented pure virtual function +is called.

+ + +

175

This panic is raised when a User::Leave() function +is called and there is no TRAP frame.

+ + +

176

This panic is raised when a mathematical function fails with an +unrecognized exception, i.e. one that is none of: KErrArgument, KErrDivideByZero, KErrOverflow or KErrUnderflow.

+ + +

177

This panic is raised by the RHeap::WalkCheckCell() internal +function on a bad cell type.

+ + +

178

This panic is raised when descriptors convert integers into text, +and an invalid radix is passed, i.e. a value that is not one of the TRadix enum +values.

+ + +

179

This panic is raised in debug builds only.

This +panic is raised when converting and appending numbers in descriptors, and +buffers are not aligned on even addresses.

+ + +

181

This is raised by an internal component related to Huffman encoding +or decoding.

+ + +

182

This is raised by an internal component related to Huffman encoding +or decoding.

+ + +

183

This panic is raised by member functions of the internal classes RArrayBase and RPointerArrayBase; +specifically:

RArrayBase::BinarySearch()
RArrayBase::BinarySearchUnsigned()
RArrayBase::BinarySearchSigned()
RPointerArrayBase::BinarySearch()
RPointerArrayBase::BinarySearchUnsigned()
RPointerArrayBase::BinarySearchSigned()

when the find mode passed to these functions is not recognized.

+ + +

184

This panic is raised on a call to RNotifier::Notify() when +the length of one or more of the descriptors containing the displayable text +is bigger than the maximum value that a TUint16 can hold.

+ + +

185

This panic is raised by the following functions when the month or +day value is outside its permitted range of values:

TMonthName::Set()
TMonthNameAbb::Set()
TDayName::Set()
TDayNameAbb::Set()

See also: TMonthName, TMonthNameAbb, TDayName and TDayNameAbb.

+ + +

186

This panic is raised internally by the descriptor formatting functions +during the handling of the variable parameter lists.

+ + +

187

This panic is raised in a call to TDes8::Expand(), +if either the length, or the maximum length, or the pointer to the data is +not an even number.

+ + +

188

This panic is raised in a call to TDes8::Collapse(), +if either the length, or the maximum length, or the pointer to the data is +not an even number.

+ + +

189

This panic is raised in calls to the TSecurityPolicy constructors, +if the specified capability is found to be invalid.

See TCapability.

+ + +

190

This panic is raised in a call to TSecurityPolicy::CheckPolicy(), +if the security policy is found to be corrupt.

See TSecurityPolicy.

+ + +

191

This panic is raised in a call to:

TSecurityPolicy::TSecurityPolicy(TSecPolicyType aType)

if aType is neither ETypePass nor ETypeFail.

See TSecurityPolicy.

+ + +

192

This panic is raised when constructing an RPointerArray or +an RArray if the specified minimum growth step is less +than or equal to zero or is greater than 65535.

+ + +

193

This panic is raised when constructing an RPointerArray or +an RArray if the specified exponential growth factor is +less than or equal to 1 or is greater than or equal to 128.

+ + +

194

This panic is raised if code inside an ASSERT_ALWAYS_NO_LEAVE harness +leaves.

+ + +

195

This panic is raised when the attempt to grow a cell on the heap +fails.

+ + +

196

This panic is raised when an attempt is made to install a Win32 +SE handler that is not on the stack.

See the internal class TWin32SEHTrap.

+ + +

197

This panic is raised when the caller of an API does not have the +right capabilities to call that API. You need to consult the documentation +for the specific API for the capabilities needed to call it.

+ + +

198

This panic is raised by the constructor of the internal class RHashTableBase if +a NULL function pointer is passed in as the hash function.

+ + +

199

This panic is raised by the constructor of the internal class RHashTableBase if +a NULL function pointer is passed in as the identity relation.

+ + +

200

This panic is raised by the constructor of the internal class RHashTableBase if +a negative element size is specified.

+ + +

201

This panic is raised by the constructor of the internal class RHashTableBase if +the specified key offset is inconsistent with the specified element size.

+ + +

202

This panic is raised by the member function VerifyReform() of +the internal class RHashTableBase if a deleted entry still +remains after a hash table reform. This panic should never occur as it indicates +an error in the hash table implementation.

+ + +

203

This panic is raised by the member function ConsistencyCheck() of +the internal class RHashTableBase. It indicates an error +in the hash table implementation.

+ + +

204

This panic is raised by the member function ConsistencyCheck() of +the internal class RHashTableBase. It indicates an error +in the hash table implementation.

+ + +

205

This panic is raised by the member function ConsistencyCheck() of +the internal class RHashTableBase. It indicates an error +in the hash table implementation.

+ + +

206

This panic is raised by the member function ConsistencyCheck() of +the internal class RHashTableBase. It indicates an error +in the hash table implementation.

+ + +

207

This panic is raised by the member function ConsistencyCheck() of +the internal class RHashTableBase. It indicates an error +in the hash table implementation.

+ + +

208

This panic is raised by the member function Next() of +the internal class THashTableIterBase if, while attempting +to step a hash table iterator to the next entry, the iterator is found to +point to an invalid table entry. This will typically occur if elements have +been removed from the hash table without resetting the iterator.

+ + +

209

This panic is raised by the member function Current() of +the internal class THashTableIterBase if, while interrogating +the current position of a hash table iterator, the iterator is found to point +to an invalid table entry. This will typically occur if elements have been +added to or removed from the hash table without resetting the iterator.

+ + +

210

This panic is raised if an invalid argument is passed to the Reserve() function +on any of the hash table classes derived from the internal class RHashTableBase.

+ + +

211

This panic is raised if the Win32 SE handler chain has been corrupted.

See +the internal class TWin32SEHTrap.

+ + +

212

This panic is raised if a negative valued argument is passed to +the Reserve() member function of the RArray or RPointerArray classes +.

+ + +

213

This panic is raised when attempting to set a new debug failure +mode on a heap with an invalid argument.

For example, if aBurst +> KMaxTUint6 when invoking __UHEAP_BURSTFAILNEXT, +when an RHeap object is used for the user heap.

On the user side this +is associated with the USER category. On the kernel side this is associated +with the KERN-HEAP category.

+ + +

214

This panic is raised when an invalid chunk attribute has been passed +to the method RChunk::Create().

+ + +

215

This panic is raised when a TChunkCreateInfo object +with an invalid version number has been passed to the method RChunk::Create().

+ + + +

\ No newline at end of file