kernel/eka/include/e32panic.h
changeset 0 a41df078684a
equal deleted inserted replaced
-1:000000000000 0:a41df078684a
       
     1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     2 // All rights reserved.
       
     3 // This component and the accompanying materials are made available
       
     4 // under the terms of the License "Eclipse Public License v1.0"
       
     5 // which accompanies this distribution, and is available
       
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 //
       
     8 // Initial Contributors:
       
     9 // Nokia Corporation - initial contribution.
       
    10 //
       
    11 // Contributors:
       
    12 //
       
    13 // Description:
       
    14 // e32\include\e32panic.h
       
    15 // 
       
    16 //
       
    17 
       
    18 /**
       
    19  @file e32panic.h
       
    20  @publishedAll
       
    21  @released
       
    22 */
       
    23 
       
    24 #ifndef __E32PANIC_H__
       
    25 #define __E32PANIC_H__
       
    26 
       
    27 
       
    28 
       
    29 
       
    30 /**
       
    31 Defines a set of panic numbers associated with the USER panic category.
       
    32 
       
    33 Some of these numbers are also associated with panics raised on
       
    34 the kernel side, and may be associated with 
       
    35 a number of category names, including KERN-COMMON, KERN-HEAP etc.
       
    36 */
       
    37 enum TCdtPanic
       
    38 	{
       
    39 	
       
    40 	/**
       
    41 	A thread has called User::Invariant(). 
       
    42 
       
    43     Typically, User::Invariant() is called when a test for a class
       
    44     invariant fails, i.e. when a test which checks that the internal data
       
    45     of an object is self-consistent, fails. 
       
    46 
       
    47     Check the design and implementation of your class.
       
    48     
       
    49     @see User
       
    50 	*/
       
    51 	EInvariantFalse=0,
       
    52 		
       
    53 	
       
    54 	/**
       
    55 	Not used.
       
    56 	*/
       
    57 	ETDateTimeUnderflow=1,
       
    58 	
       
    59 		
       
    60 	
       
    61 	/**
       
    62     Not used.
       
    63 	*/
       
    64 	ETDateTimeBadDate=2,
       
    65 	
       
    66 	
       
    67 	/**
       
    68 	A TDateTime object has been constructed with an invalid date or time field.
       
    69 
       
    70     @see TDateTime
       
    71 	*/
       
    72 	ETDateTimeBadDateTime=3,
       
    73 	
       
    74 	
       
    75     /**
       
    76     Not used.
       
    77 	*/
       
    78 	ETDateTimeAddDaysRange=4,
       
    79 	
       
    80 	
       
    81 	/**
       
    82     Not used.
       
    83 	*/
       
    84 	ETDateTimeAddMonthsRange=5,
       
    85 
       
    86 
       
    87 	/**
       
    88     Not used.
       
    89 	*/
       
    90 	ETDateTimeDaySecNegative=6,
       
    91 	
       
    92 	
       
    93 	/**
       
    94 	A panic raised by the Ptr() member function of a 16-bit descriptor
       
    95 	if the descriptor is invalid.
       
    96 	
       
    97 	@see TDesC16::Ptr()
       
    98 	*/
       
    99 	ETDes16BadDescriptorType=7,
       
   100 	
       
   101 	
       
   102 	/**
       
   103 	The length value passed to a 16-bit variant descriptor member
       
   104 	function is invalid.
       
   105 	
       
   106 	This panic may be raised by some descriptor constructors and, specifically,
       
   107 	by the Replace() and Set() descriptor member functions.
       
   108 	
       
   109 	@see TDes16
       
   110 	*/
       
   111 	ETDes16LengthOutOfRange=8,
       
   112 	
       
   113 	
       
   114 	/**
       
   115 	The index value passed to the 16-bit variant descriptor Operator[] is
       
   116 	out of bounds.
       
   117 	*/
       
   118 	ETDes16IndexOutOfRange=9,
       
   119 	
       
   120 	
       
   121 	/**
       
   122 	The position value passed to a 16-bit variant descriptor member function
       
   123 	is out of bounds.
       
   124 
       
   125 	The panic can be raised by the Left(), Right(), Mid(), Insert(), Delete()
       
   126 	and Replace() member functions of TDes16.
       
   127 
       
   128     @see TDes16
       
   129 	*/
       
   130 	ETDes16PosOutOfRange=10,
       
   131 	
       
   132 	
       
   133 	/**
       
   134 	An operation to move or copy data to a 16-bit variant descriptor,
       
   135 	will cause the length of that descriptor to exceed its maximum length.
       
   136 	
       
   137 	This may be caused by any of the copying, appending or formatting member
       
   138 	functions but, specifically, by the Insert(), Replace(), Fill(), Fillz(),
       
   139 	and ZeroTerminate() descriptor member functions. It can also be caused by
       
   140 	the SetLength() function.
       
   141 
       
   142     @see TDes16
       
   143 	*/
       
   144 	ETDes16Overflow=11,
       
   145 	
       
   146 	
       
   147 	/**
       
   148 	The format string passed to the 16-bit variant descriptor member functions
       
   149 	Format() and AppendFormat() has incorrect syntax.
       
   150 	
       
   151     @see TDes16
       
   152 	*/
       
   153 	ETDes16BadFormatDescriptor=12,
       
   154 	
       
   155 	
       
   156 	/**
       
   157 	An invalid variable list has been passed to the AppendFormatList() member
       
   158 	function of the 16-bit variant descriptor TDes16, when the format is %S or %s.
       
   159 	
       
   160     This panic is raised in debug builds only.
       
   161     
       
   162     @see TDes16
       
   163 	*/
       
   164 	ETDes16BadFormatParams=13,
       
   165 	
       
   166 	
       
   167 	/**
       
   168 	This panic is raised when expanding or contracting an HBufC16 buffer using
       
   169 	the ReAlloc() or ReAllocL() descriptor member functions and the new
       
   170 	specified length is too small to contain the data.
       
   171 	
       
   172 	@see HBufC16
       
   173 	*/
       
   174 	ETDes16ReAllocTooSmall=14,
       
   175 	
       
   176 	
       
   177 	/**
       
   178 	Not used.
       
   179 	*/
       
   180 	ETDes16RemoteBadDescriptorType=15,
       
   181 	
       
   182 	
       
   183     /**
       
   184 	In a call to the Replace() member function of the 16-bit variant
       
   185 	descriptor TDes16,the length of the source descriptor is negative
       
   186 	or exceeds the maximum length of the target descriptor.
       
   187 	
       
   188     @see TDes16
       
   189 	*/
       
   190 	ETDes16RemoteLengthOutOfRange=16,
       
   191 	
       
   192 	
       
   193 	/**
       
   194 	A 16-bit variant descriptor is being constructed with a negative
       
   195 	length value.
       
   196 	
       
   197 	This panic may also be raised if the Set(), Repeat() and the Find() member
       
   198 	functions are passed negative length values.
       
   199 	*/
       
   200 	ETDes16LengthNegative=17,
       
   201 	
       
   202 	
       
   203 	/**
       
   204 	A 16-bit variant descriptor is being constructed with a negative maximum 
       
   205 	length value.
       
   206 	*/
       
   207 	ETDes16MaxLengthNegative=18,
       
   208 	
       
   209 	
       
   210 	/**
       
   211 	A panic raised by the Ptr() member function of an 8-bit descriptor
       
   212 	if the descriptor is invalid.
       
   213 	
       
   214 	@see TDesC8::Ptr()
       
   215 	*/
       
   216 	ETDes8BadDescriptorType=19,
       
   217 	
       
   218 	
       
   219 	/**
       
   220 	The length value passed to an 8-bit variant descriptor member
       
   221 	function is invalid.
       
   222 	
       
   223 	This panic may be raised by some descriptor constructors and, specifically,
       
   224 	by the Replace() and Set() descriptor member functions.
       
   225 	
       
   226 	@see TDes8
       
   227 	*/
       
   228 	ETDes8LengthOutOfRange=20,
       
   229 	
       
   230 	
       
   231 	/**
       
   232 	The index value passed to the 8-bit variant descriptor Operator[] is
       
   233 	out of bounds.
       
   234 	*/
       
   235 	ETDes8IndexOutOfRange=21,
       
   236 	
       
   237 	
       
   238 	/**
       
   239 	The position value passed to an 8-bit variant descriptor member function
       
   240 	is out of bounds.
       
   241 
       
   242 	The panic can be raised by the Left(), Right(), Mid(), Insert(), Delete()
       
   243 	and Replace() member functions of TDes8
       
   244 
       
   245     @see TDes8
       
   246 	*/
       
   247 	ETDes8PosOutOfRange=22,
       
   248 	
       
   249 	
       
   250 	/**
       
   251 	An operation to move or copy data to an 8-bit variant descriptor,
       
   252 	will cause the length of that descriptor to exceed its maximum length.
       
   253 	
       
   254 	This may be caused by any of the copying, appending or formatting member
       
   255 	functions but, specifically, by the Insert(), Replace(), Fill(), Fillz(),
       
   256 	and ZeroTerminate() descriptor member functions. It can also be caused by
       
   257 	the SetLength() function.
       
   258 
       
   259     @see TDes8
       
   260 	*/
       
   261     ETDes8Overflow=23,
       
   262    	
       
   263 	
       
   264 	/**
       
   265 	The format string passed to the 8-bit variant descriptor member functions
       
   266 	Format() and AppendFormat() has incorrect syntax.
       
   267 	
       
   268     @see TDes8
       
   269 	*/
       
   270 	ETDes8BadFormatDescriptor=24,
       
   271 	
       
   272 	
       
   273 	/**
       
   274 	An invalid variable list has been passed to the AppendFormatList() member
       
   275 	function of the 8-bit variant descriptor TDes8, when the format is %S or %s.
       
   276 	
       
   277     This panic is raised in debug builds only.
       
   278     
       
   279     @see TDes8
       
   280 	*/
       
   281 	ETDes8BadFormatParams=25,
       
   282 		
       
   283 	
       
   284 	/**
       
   285 	This panic is raised when expanding or contracting an HBufC8 buffer using
       
   286 	the ReAlloc() or ReAllocL() descriptor member functions and the new
       
   287 	specified length is too small to contain the data.
       
   288 	
       
   289 	@see HBufC8
       
   290 	*/
       
   291 	ETDes8ReAllocTooSmall=26,
       
   292 	
       
   293 	
       
   294 	/**
       
   295 	Not used.
       
   296 	*/
       
   297 	ETDes8RemoteBadDescriptorType=27,
       
   298 	
       
   299 	
       
   300 	
       
   301     /**
       
   302 	In a call to the Replace() member function of the 8-bit variant
       
   303 	descriptor TDes8,the length of the source descriptor is negative
       
   304 	or exceeds the maximum length of the target descriptor.
       
   305 	
       
   306     @see TDes8
       
   307 	*/
       
   308 	ETDes8RemoteLengthOutOfRange=28,
       
   309 	
       
   310 	
       
   311 	/**
       
   312 	An 8-bit variant descriptor is being constructed with a negative
       
   313 	length value.
       
   314 	
       
   315 	This panic may also be raised if the Set(), Repeat() and the Find() member
       
   316 	functions are passed negative length values.
       
   317 	*/
       
   318 	ETDes8LengthNegative=29,
       
   319 	
       
   320 	
       
   321 	/**
       
   322 	An 8-bit variant descriptor is being constructed with a negative maximum 
       
   323 	length value.
       
   324 	*/
       
   325 	ETDes8MaxLengthNegative=30,
       
   326 	
       
   327 	
       
   328 	/**
       
   329 	Not used.
       
   330 	*/
       
   331 	ETEntLeaveWithoutEnter=31,
       
   332 	
       
   333 	
       
   334 	/**
       
   335 	It is raised by TRawEvent::Pos() when
       
   336 	the event is not a mouse/pen type event.
       
   337     
       
   338     This panic is raised in debug builds only.
       
   339     */
       
   340 	ETEventNotMoveType=32,
       
   341 	
       
   342 	
       
   343 	/**
       
   344     It is raised by TRawEvent::ScanCode() when
       
   345     the event is not a key down, up or repeat event.
       
   346     
       
   347    	This panic is raised in debug builds only.
       
   348 	*/
       
   349 	ETEventNotKeyType=33,
       
   350 	
       
   351 	
       
   352 	/**
       
   353     It is raised by TRawEvent::Modifiers() when
       
   354     the event is not a modifier update event.
       
   355 	
       
   356    	This panic is raised in debug builds only.
       
   357 	*/
       
   358     ETEventNotUpdateModifiersType=34,
       
   359     
       
   360     
       
   361     /**
       
   362     This panic is raised by the default At() virtual member function of TKey.
       
   363     
       
   364     The function is intended to be overridden by a derived class.
       
   365     
       
   366     @see TKey
       
   367     */
       
   368 	ETFuncTKeyVirtualAt=35,
       
   369 	
       
   370 	
       
   371 	/**
       
   372 	This panic is raised by the default Swap() virtual member function of TSwap.
       
   373 	
       
   374 	The function is intended to be overridden by a derived class.
       
   375 
       
   376 	@see TSwap
       
   377 	*/
       
   378 	ETFuncTSwapVirtualSwap=36,
       
   379 	
       
   380 	
       
   381 	/**
       
   382 	The index value passed to the operator[] of a TUidType is negative
       
   383 	or is greater than or equal to KMaxCheckedUid.
       
   384 	
       
   385 	@see KMaxCheckedUid
       
   386 	@see TUidType
       
   387 	*/
       
   388 	ETFuncUidTypeBadIndex=37,
       
   389 	
       
   390 	
       
   391 	/**
       
   392 	The length of the descriptor passed to the Set(TDesC8&) member function of TCheckedUid 
       
   393 	is not equal to the size of a TCheckedUid object.
       
   394 	
       
   395 	@see TCheckedUid
       
   396 	*/
       
   397 	ETFuncCheckedUidBadSet=38,
       
   398 	
       
   399 	
       
   400 	/**
       
   401 	The size specified of a new heap is smaller than the permitted minimum;
       
   402 	it must be at least the size of a RHeap object.
       
   403 	
       
   404 	On the user side this is associated with the USER category; on the kernel side
       
   405 	this is associated with the KERN-HEAP category.
       
   406 	*/
       
   407 	ETHeapNewBadSize=39,
       
   408 
       
   409 	
       
   410 	/**
       
   411 	Not used.
       
   412 	*/
       
   413 	ETHeapCreateSizeTooSmall=40,
       
   414 	
       
   415 	
       
   416 	/**
       
   417 	In a call to UserHeap::ChunkHeap(), the value defining the minimum length
       
   418 	of the heap is greater than the value defining the maximum length to
       
   419 	which the heap can grow.
       
   420 
       
   421     @see UserHeap
       
   422 	*/
       
   423 	ETHeapCreateMaxLessThanMin=41,
       
   424 	
       
   425 	
       
   426 	/**
       
   427 	In a call to the RHeap member functions, AllocLen(), Free(), FreeZ(),
       
   428 	ReAlloc(), ReAllocL(), Adjust() and AdjustL(), a pointer passed to these
       
   429 	functions does not point to a valid cell.
       
   430 
       
   431 	On the user side this is associated with the USER category; on the kernel side
       
   432 	this is associated with the KERN-HEAP category.
       
   433 	*/
       
   434 	ETHeapBadCellAddress=42,
       
   435 	
       
   436 	
       
   437 	/**
       
   438 	In a call to the Adjust() and AdjustL() member functions of RHeap, a heap
       
   439 	cell is being shrunk and the amount by which the cell is being shrunk
       
   440 	is less than the current length of the cell.
       
   441 	*/
       
   442 	ETHeapAdjustTooSmall=43,
       
   443 	
       
   444 	
       
   445 	/**
       
   446 	In a call to the Free() and FreeZ() member functions of RHeap,the cell
       
   447 	being freed overlaps the next cell on the free list (i.e. the first cell
       
   448 	on the free list with an address higher than the one being freed).
       
   449 	*/
       
   450 	ETHeapFreeBadNextCell=44,
       
   451 	
       
   452 	
       
   453 	/**
       
   454 	In a call to the Free() and FreeZ() member functions of RHeap, the cell
       
   455 	being freed overlaps the previous cell on the free list (i.e. the last cell
       
   456 	on the free list with an address lower than the one being freed).
       
   457 	*/
       
   458 	ETHeapFreeBadPrevCell=45,
       
   459 	
       
   460 	
       
   461 	/**
       
   462 	In a call to the ReAlloc() and ReAllocL() member functions of RHeap, the
       
   463 	cell being reallocated overlaps the next cell on the free list (i.e. the
       
   464 	first cell on the free list with an address higher than the one being
       
   465 	reallocated).
       
   466 	*/
       
   467 	ETHeapReAllocBadNextCell=46,
       
   468 	
       
   469 	
       
   470 	/**
       
   471 	In a call to the Alloc(), AllocL() or AllocLC() member functions of RHeap,
       
   472 	an attempt has been made to allocate a cell from a heap, using an unsigned
       
   473 	size value which is greater than or equal to the value of KMaxTInt/2.
       
   474 
       
   475     This panic may also be raised by the heap walker when it finds a bad
       
   476     allocated heap cell size.
       
   477     
       
   478     @see User::Check()
       
   479     @see RAllocator::Check()
       
   480     @see KMaxTInt
       
   481 	*/
       
   482 	ETHeapBadAllocatedCellSize=47,
       
   483 	
       
   484 	
       
   485 	/**
       
   486 	This panic is raised by the heap walker when it finds a bad
       
   487 	allocated heap cell address.
       
   488 	*/
       
   489 	ETHeapBadAllocatedCellAddress=48,
       
   490 	
       
   491 	
       
   492 	/**
       
   493 	This panic is raised by the heap walker when it finds a bad
       
   494 	free heap cell address.
       
   495 	*/
       
   496 	ETHeapBadFreeCellAddress=49,
       
   497 	
       
   498 	
       
   499 	/**
       
   500 	Not used.
       
   501 	*/
       
   502 	ETHeapDebugBufferOverflow=50,
       
   503 	
       
   504 	
       
   505 	/**
       
   506 	A call has been made to the __DbgMarkEnd() member function of RHeap, when
       
   507 	there has been no corresponding call to the __DbgMarkStart() member function.
       
   508 	
       
   509 	This panic is also raised when there are more calls to __DbgMarkEnd() than
       
   510 	to __DbgMarkStart(). These functions are part of the debug assistance provided by
       
   511 	the RHeap class.
       
   512 
       
   513     This panic is raised in debug builds only.
       
   514 	*/
       
   515 	ETHeapDebugUnmatchedCallToCheckHeap=51,
       
   516 	
       
   517 	
       
   518 	/**
       
   519 	In a call to the Adjust() and AdjustL() member functions of an RHeap,
       
   520 	the offset from the start of the cell being stretched or shrunk is
       
   521 	a negative value.
       
   522 	*/
       
   523 	ETHeapAdjustOffsetNegative=52,
       
   524 	
       
   525 	
       
   526 	/**
       
   527 	Not used.
       
   528 	*/
       
   529 	ETHeapAllocSizeNegative=53,
       
   530 	
       
   531 	
       
   532 	/**
       
   533 	In a call to the ReAlloc() and ReAllocL() member functions of an RHeap,
       
   534 	the new size for the cell being reallocated is a negative value.
       
   535 	*/
       
   536 	ETHeapReAllocSizeNegative=54,
       
   537 	
       
   538 	
       
   539 	/**
       
   540 	This panic is caused by the UserHeap::ChunkHeap() static function when
       
   541 	the value defining the minimum length of the heap is negative.
       
   542 	*/
       
   543 	ETHeapMinLengthNegative=55,
       
   544 	
       
   545 	
       
   546 	/**
       
   547 	This panic is caused by the UserHeap::ChunkHeap() static function when
       
   548 	the value defining the maximum length to which the heap can grow,
       
   549 	is negative.
       
   550 	*/
       
   551 	ETHeapMaxLengthNegative=56,
       
   552 	
       
   553 	
       
   554 	/**
       
   555 	This panic is raised when closing a shared heap using the Close() member
       
   556 	function of RHeap and the access count is zero or negative.
       
   557 	
       
   558 	A zero or negative access count suggests that an attempt is being made
       
   559 	to close the heap too many times.
       
   560 	*/
       
   561 	EAllocatorClosedTooManyTimes=57,
       
   562 	
       
   563 	
       
   564 	/**
       
   565 	This panic is raised when opening a heap for shared access using the Open()
       
   566 	member function of RHeap and the heap type is not EChunkNormal.
       
   567 	*/
       
   568 	ETHeapOnlyChunkHeaps=58,
       
   569 	
       
   570 	
       
   571 	/**
       
   572 	This panic is raised by the UnGet() member function of the 8-bit variant
       
   573 	lexical analyzer, TLex8, if the character position is already at
       
   574 	the start of the string.
       
   575 
       
   576     @see TLex8
       
   577 	*/
       
   578 	ETLex8UnGetUnderflow=59,
       
   579 	
       
   580 	
       
   581 	/**
       
   582 	This panic is raised by the Inc() member function of the 8-bit variant
       
   583 	lexical analyzer, TLex8, if the resulting character position lies before
       
   584 	the start of the string or after the end of the string.
       
   585 
       
   586     @see TLex8
       
   587 	*/
       
   588 	ETLex8IncOutOfRange=60,
       
   589 	
       
   590 	
       
   591 	/**
       
   592 	This panic is raised by the SkipAndMark() member function of the 8-bit
       
   593 	variant lexical analyzer, TLex8, if the resulting character position lies
       
   594 	before the start of the string, or after the end of the string.
       
   595 
       
   596     @see TLex8
       
   597 	*/
       
   598 	ETLex8SkipOutOfRange=61,
       
   599 	
       
   600 	
       
   601 	/**
       
   602 	Not used.
       
   603 	*/
       
   604 	ETLex8BadFormatList=62,
       
   605 	
       
   606 	
       
   607 	/**
       
   608 	This panic is raised by the ValidateMark() member function of the 8-bit
       
   609 	variant lexical analyzer, TLex8, if the position of the extraction mark
       
   610 	lies before the start of the string or after the end of the string.
       
   611 
       
   612     @see TLex8
       
   613 	*/
       
   614 	ETLex8MarkOutOfRange=63,
       
   615 	
       
   616 	
       
   617 	/**
       
   618 	This panic is raised by the UnGet() member function of the 16-bit variant
       
   619 	lexical analyzer, TLex16, if the character position is already at the start
       
   620 	of the string.
       
   621 
       
   622     @see TLex16
       
   623 	*/
       
   624 	ETLex16UnGetUnderflow=64,
       
   625 	
       
   626 	
       
   627 	/**
       
   628 	This panic is raised by the Inc() member function of the 16-bit variant
       
   629 	lexical analyzer, TLex16, if the resulting character position lies before
       
   630 	the start of the string or after the end of the string.
       
   631 
       
   632     @see TLex16
       
   633 	*/
       
   634 	ETLex16IncOutOfRange=65,
       
   635 	
       
   636 	
       
   637 	/**
       
   638 	This panic is raised by the SkipAndMark() member function of the 16-bit
       
   639 	variant lexical analyzer, TLex16, if the resulting character position lies
       
   640 	before the start of the string or after the end of the string.
       
   641 
       
   642     @see TLex16
       
   643 	*/
       
   644 	ETLex16SkipOutOfRange=66,
       
   645 	
       
   646 	
       
   647 	/**
       
   648 	Not used.
       
   649 	*/
       
   650 	ETLex16BadFormatList=67,
       
   651 	
       
   652 	
       
   653 	/**
       
   654 	This panic is raised by the ValidateMark() member function of the 16-bit
       
   655 	variant lexical analyzer, TLex16, if the position of the extraction mark
       
   656 	lies before the start of the string or after the end of the string.
       
   657 
       
   658     @see TLex16
       
   659 	*/
       
   660 	ETLex16MarkOutOfRange=68,
       
   661 	
       
   662 	
       
   663 	/**
       
   664 	This panic is raised by the TDateSuffix constructor or its Set() member
       
   665 	function when the suffix index specified is negative or is greater than or
       
   666 	equal to the value KMaxSuffixes.
       
   667 	
       
   668 	The index is used to access a locale dependent table of suffix characters,
       
   669 	which can be appended to the dates of the month (e.g. the characters "st" 
       
   670 	for 1st, "nd" for 2nd, "st" for 31st).
       
   671 	
       
   672 	@see TDateSuffix
       
   673 	@see KMaxSuffixes
       
   674 	*/
       
   675 	ETLoclSuffixOutOfRange=69,
       
   676 	
       
   677 	
       
   678 	/**
       
   679 	This panic is raised when attempting to complete a client/server request
       
   680 	and the RMessagePtr is null.
       
   681 	*/
       
   682 	ETMesCompletion=70,
       
   683 	
       
   684 	
       
   685 	/**
       
   686 	Not used.
       
   687 	*/
       
   688 	EMesBadRetryCount=71,
       
   689 	
       
   690 	
       
   691 	/**
       
   692 	This panic is raised by the Send() and SendReceive() member functions
       
   693 	of RSessionBase, the client interface for communication with a server,
       
   694 	when the specified operation code identifying the required service is
       
   695 	either negative or a value greater than KMaxTint.
       
   696 	
       
   697 	@see RSessionBase
       
   698 	@see KMaxTint
       
   699 	*/
       
   700 	ETMesBadFunctionNumber=72,
       
   701 	
       
   702 	
       
   703 	/**
       
   704 	This panic is raised by the Receive() member function of RServer,
       
   705 	the handle to the server, when the attempt to receive a message
       
   706 	for the server, synchronously, fails.
       
   707 
       
   708     @see RServer
       
   709 	*/
       
   710 	ETMesReceiveFailed=73,
       
   711 	
       
   712 	
       
   713 	/**
       
   714 	Not used.
       
   715 	*/
       
   716 	ESQueOffsetNegative=74,
       
   717 	
       
   718 	
       
   719 	/**
       
   720 	This panic is raised by the constructor of a singly linked list header,
       
   721 	a TSglQue or by the SetOffset() member function when the specified offset
       
   722 	is not 4 byte aligned, i.e. when it is not divisible by 4.
       
   723 
       
   724     @see TSglQue
       
   725 	*/
       
   726 	ESQueOffsetNotAligned=75,
       
   727 	
       
   728 	
       
   729 	/**
       
   730 	This panic is raised when attempting to remove an object from a singly
       
   731 	linked list, using the Remove() member function of TSglQue, when
       
   732 	that object is not in the list.
       
   733 
       
   734     @see TSglQue
       
   735 	*/
       
   736 	ESQueLinkNotQueued=76,
       
   737 	
       
   738 	
       
   739 	/**
       
   740 	Not used.
       
   741 	*/
       
   742 	ETQueOffsetNegative=77,
       
   743 
       
   744 	
       
   745 	/**
       
   746 	This panic is raised by the constructor of a doubly linked list header,
       
   747 	a TDblQue or by the SetOffset() member function, when the specified
       
   748 	offset is not 4 byte aligned, i.e. when it is not divisible by 4.
       
   749 
       
   750     @see TDblQue
       
   751 	*/
       
   752 	ETQueOffsetNotAligned=78,
       
   753 	
       
   754 	
       
   755 	/**
       
   756 	This panic is raised by a call to either the First() or the Last() member
       
   757 	functions of a doubly linked list, a TDblQue, which return pointers
       
   758 	to the first and last element in the list respectively; the panic
       
   759 	occurs when the list is empty.
       
   760 
       
   761     This panic is raised in debug builds only.
       
   762 
       
   763     @see TDblQue
       
   764 	*/
       
   765 	ETQueQueueEmpty=79,
       
   766 	
       
   767 	
       
   768 	/**
       
   769     This panic is raised by the post increment operator, operator++, the post
       
   770     decrement operator, operator- and the return current element
       
   771     operator, operator T*, of the doubly linked list iterator, a TDblQueIter;
       
   772     the panic occurs when the element returned by these operators is not in
       
   773     the list.
       
   774     
       
   775     Typically, this is caused by the removal of the element from the list prior
       
   776     to calling these operators.
       
   777 	
       
   778     This panic is raised in debug builds only.
       
   779     
       
   780     @see TDblQueIter
       
   781 	*/
       
   782 	ETQueLinkHasBeenRemoved=80,
       
   783 	
       
   784 	
       
   785 	/**
       
   786 	This panic is raised by the get rectangle operator, operator[], of
       
   787 	a clipping region, derived from the abstract base class TRegion.
       
   788 	
       
   789 	The panic occurs when the index, which refers to the specific rectangle
       
   790 	within the region, is greater than or equal to the number of rectangles
       
   791 	contained within the region (as returned by the Count() member function).
       
   792 
       
   793     The index must be strictly less than the number of contained rectangles.
       
   794 
       
   795     @see TRegion
       
   796 	*/
       
   797 	ETRegionOutOfRange=81,
       
   798 	
       
   799 	
       
   800 	/**
       
   801 	This panic is raised when sorting the rectangles within a clipping region,
       
   802 	derived from the abstract base class TRegion, using the Sort() member
       
   803 	function of TRegion.
       
   804 	
       
   805 	The panic occurs when the region is invalid.
       
   806 
       
   807     This panic is raised in debug builds only.
       
   808 
       
   809     @see TRegion
       
   810 	*/
       
   811 	ETRegionInvalidRegionInSort=82,
       
   812 	
       
   813 	
       
   814 	/**
       
   815 	This panic occurs when the Kernel sends a message to the Kernel server
       
   816 	and this completes with an error, i.e. an error code which is not KErrNone.
       
   817 	*/
       
   818 	ETUtlKernelServerSend=83,
       
   819 	
       
   820 	
       
   821 	/**
       
   822 	This panic is raised by the Panic() member function of RTest, the test class.
       
   823 	*/
       
   824 	ERTestFailed=84,
       
   825 	
       
   826 	
       
   827 	/**
       
   828 	This panic is raised by the CheckConsoleCreated() member functions of
       
   829 	RTest and RTestJ, the test classes, when the creation of a console, 
       
   830 	as derived from a CConsoleBase, fails.
       
   831 	*/
       
   832 	ERTestCreateConsole=85,
       
   833 	
       
   834 	
       
   835 	/**
       
   836 	This panic is raised by the static function User::After() when
       
   837 	the specified time interval is negative.
       
   838 	*/
       
   839 	EExecAfterTimeNegative=86,
       
   840 	
       
   841 	
       
   842 	/**
       
   843 	This panic is raised when the time interval passed to the After() member
       
   844 	function of RTimer is negative.
       
   845 
       
   846     @see RTimer
       
   847 	*/
       
   848 	ERTimerAfterTimeNegative=87,
       
   849 	
       
   850 	
       
   851 	/**
       
   852 	This panic is raised by Mem::Compare(), Mem::CompareC() and Mem::CompareF()
       
   853 	when the length of the area of memory designated as the left hand area,
       
   854 	is negative.
       
   855 	
       
   856 	This panic is raised in debug builds only.
       
   857 
       
   858 	On the user side this is associated with the USER category; on the kernel side
       
   859 	this is associated with the KERN-COMMON category.
       
   860 
       
   861 	@see Mem
       
   862 	*/
       
   863 	EMemLeftNegative=88,
       
   864 	
       
   865 	
       
   866 	/**
       
   867 	This panic is raised by Mem::Compare(), Mem::CompareC() and Mem::CompareF()
       
   868 	when the length of the area of memory designated as the right hand area,
       
   869 	is negative.
       
   870 	
       
   871 	This panic is raised in debug builds only.
       
   872 
       
   873 	On the user side this is associated with the USER category; on the kernel side
       
   874 	this is associated with the KERN-COMMON category.
       
   875 
       
   876 	@see Mem
       
   877 	*/
       
   878 	EMemRightNegative=89,
       
   879 	
       
   880 	
       
   881 	/**
       
   882 	This panic is raised by Mem::Copy() when the length of the area of memory
       
   883 	to be copied is negative.
       
   884 
       
   885 	This panic is raised in debug builds only.
       
   886 
       
   887 	On the user side this is associated with the USER category; on the kernel side
       
   888 	this is associated with the KERN-COMMON category.
       
   889 
       
   890 	@see Mem
       
   891 	*/
       
   892 	EMemCopyLengthNegative=90,
       
   893 	
       
   894 	
       
   895 	/**
       
   896 	This panic is raised by Mem::Move() when the length of the area of memory
       
   897 	to be moved is not a multiple of 4.
       
   898 
       
   899 	This panic is raised in debug builds only.
       
   900 
       
   901 	On the user side this is associated with the USER category; on the kernel side
       
   902 	this is associated with the KERN-COMMON category.
       
   903 
       
   904 	@see Mem
       
   905 	*/
       
   906 	EWordMoveLengthNotMultipleOf4=91,
       
   907 	
       
   908 	
       
   909 	/**
       
   910 	This panic is raised by Mem::Move() when the address of the source for
       
   911 	the move operation is not aligned on a 4 byte boundary.
       
   912 
       
   913 	This panic is raised in debug builds only.
       
   914 
       
   915 	On the user side this is associated with the USER category; on the kernel side
       
   916 	this is associated with the KERN-COMMON category.
       
   917 
       
   918 	@see Mem
       
   919 	*/
       
   920 	EWordMoveSourceNotAligned=92,
       
   921 	
       
   922 	
       
   923 	/**
       
   924 	This panic is raised by Mem::Move() when the address of the target for
       
   925 	the move operation is not aligned on a 4 byte boundary.
       
   926 
       
   927 	This panic is raised in debug builds only.
       
   928 
       
   929 	On the user side this is associated with the USER category; on the kernel side
       
   930 	this is associated with the KERN-COMMON category.
       
   931 
       
   932 	@see Mem
       
   933 	*/
       
   934 	EWordMoveTargetNotAligned=93,
       
   935 	
       
   936 	
       
   937 	/**
       
   938 	This panic is raised by Mem::Swap() when the length of the area of
       
   939 	memory to be swapped is negative.
       
   940 
       
   941 	This panic is raised in debug builds only.
       
   942 
       
   943 	On the user side this is associated with the USER category; on the kernel side
       
   944 	this is associated with the KERN-COMMON category.
       
   945 
       
   946 	@see Mem
       
   947 	*/
       
   948 	EMemSwapLengthNegative=94,
       
   949 	
       
   950 	
       
   951 	/**
       
   952 	This panic is raised by Mem::Fill() and Mem::FillZ() when the length of
       
   953 	the area of memory to be filled is negative.
       
   954 
       
   955 	This panic is raised in debug builds only.
       
   956 
       
   957 	On the user side this is associated with the USER category; on the kernel side
       
   958 	this is associated with the KERN-COMMON category.
       
   959 
       
   960 	@see Mem
       
   961 	*/
       
   962 	EMemFillLengthNegative=95,
       
   963 	
       
   964 	
       
   965 	/**
       
   966 	The value for the number of records to be sorted passed
       
   967 	to User::QuickSort() is negative.
       
   968 
       
   969     @see User
       
   970 	*/
       
   971 	ESortCountNegative=96,
       
   972 	
       
   973 	
       
   974 	/**
       
   975 	The value for the number of records taking part in the search passed
       
   976 	to User::BinarySearch() is negative.
       
   977 	
       
   978 	@see User
       
   979 	*/
       
   980 	EBinarySearchCountNegative=97,
       
   981 	
       
   982 	
       
   983 	/**
       
   984 	This panic is raised by the constructor of the base key class, TKey.
       
   985 	
       
   986 	It occurs when the offset value passed to the constructor is negative.
       
   987 	As TKey is an abstract class, i.e. objects of type TKey are not intended
       
   988 	to be explicitly constructed, look at the offset value passed to
       
   989 	the constructors of derived classes such as TKeyArrayFix, TKeyArrayVar,
       
   990 	and TKeyArrayPak for the cause of the panic.
       
   991 
       
   992     @see TKey
       
   993     @see TKeyArrayFix
       
   994     @see TKeyArrayVar
       
   995 	@see TKeyArrayPak
       
   996 	*/
       
   997 	EKeyOffsetNegative=98,
       
   998 	
       
   999 	
       
  1000 	/**
       
  1001 	This panic is raised when a local or global chunk is created using
       
  1002 	the RChunk member functions: CreateLocal(), CreateGlobal(),
       
  1003 	CreateDoubleEndedLocal() and CreateDoubleEndedGlobal().
       
  1004 	
       
  1005 	It occurs when the value for the maximum size to which this chunk can
       
  1006 	be adjusted, is negative.
       
  1007 	
       
  1008 	@see RChunk
       
  1009 	*/
       
  1010 	EChkCreateMaxSizeNegative=99,
       
  1011 	
       
  1012 	
       
  1013 	/**
       
  1014 	This panic is raised when a local or global chunk is created using
       
  1015 	the RChunk member functions: CreateLocal() and CreateGlobal().
       
  1016 	
       
  1017 	It occurs when the value for the number of bytes to be committed to 
       
  1018 	this chunk on creation, is negative.
       
  1019 
       
  1020 	@see RChunk
       
  1021 	*/
       
  1022 	EChkCreateSizeNotPositive=100,
       
  1023 	
       
  1024 	
       
  1025 	/**
       
  1026 	This panic is raised when a local or global chunk is created using
       
  1027 	the RChunk member functions: CreateLocal() and CreateGlobal().
       
  1028 	
       
  1029 	It occurs when the value for the number of bytes to be committed to
       
  1030 	this chunk on creation is greater than the value for the maximum size
       
  1031 	to which this chunk can be adjusted.
       
  1032 
       
  1033 	@see RChunk
       
  1034 	*/
       
  1035 	EChkCreateMaxLessThanMin=101,
       
  1036 	
       
  1037 	
       
  1038 	/**
       
  1039 	This panic is raised when changing the number of bytes committed to a chunk
       
  1040 	by calling the Adjust() member function of RChunk.
       
  1041 	
       
  1042 	The panic occurs when the value passed to the function is negative.
       
  1043 	
       
  1044 	@see RChunk
       
  1045 	*/
       
  1046 	EChkAdjustNewSizeNegative=102,
       
  1047 	
       
  1048 	
       
  1049 	/**
       
  1050 	Not used.
       
  1051 	*/
       
  1052 	ESesDelayTimeNegative=103,
       
  1053 	
       
  1054 	
       
  1055 	/**
       
  1056 	Not used.
       
  1057 	*/
       
  1058 	ESesRetryCountNegative=104,
       
  1059 	
       
  1060 	
       
  1061 	/**
       
  1062 	This panic is raised when a local or global semaphore is created using
       
  1063 	the RSemaphore member functions: CreateLocal() and CreateGlobal(), and
       
  1064 	the value for the initial semaphore count is negative.
       
  1065 	
       
  1066 	@see RSemaphore
       
  1067 	*/
       
  1068 	ESemCreateCountNegative=105,
       
  1069 	
       
  1070 	
       
  1071 	/**
       
  1072 	This panic is raised when a semaphore is signaled using
       
  1073 	the Signal(TInt aCount) member function and the count value is negative.
       
  1074 
       
  1075     @see RSemaphore
       
  1076 	*/
       
  1077 	ESemSignalCountNegative=106,
       
  1078 	
       
  1079 	
       
  1080 	/**
       
  1081 	This panic is raised when a critical section is signalled using
       
  1082 	the Signal() member function and the call to Signal() is not matched
       
  1083 	by an earlier call to Wait(), which suggests that this is a stray signal.
       
  1084 
       
  1085     @see RCriticalSection
       
  1086 	*/
       
  1087 	ECriticalSectionStraySignal=107,
       
  1088 	
       
  1089 	
       
  1090 	/**
       
  1091 	Not used.
       
  1092 	*/
       
  1093 	EThrdHeapNotChunkType=108,
       
  1094 	
       
  1095 	
       
  1096 	/**
       
  1097 	This panic is raised when creating a thread using the Create() member
       
  1098 	functions of RThread.
       
  1099 	
       
  1100 	The panic occurs when the value of the stack size passed to
       
  1101 	these functions is negative.
       
  1102 	
       
  1103     @see RThread
       
  1104 	*/
       
  1105 	EThrdStackSizeNegative=109,
       
  1106 	
       
  1107 	
       
  1108 	/**
       
  1109 	This panic is raised when creating a thread using the Create() member
       
  1110 	functions of RThread.
       
  1111 	
       
  1112 	The panic is only raised by those variants of Create() that create a new
       
  1113 	heap for the new thread. The panic occurs if the minimum heap size
       
  1114 	specified is less than KMinHeapSize.
       
  1115 
       
  1116     @see RThread
       
  1117     @see KMinHeapSize
       
  1118 	*/
       
  1119 	EThrdHeapMinTooSmall=110,
       
  1120 	
       
  1121 	
       
  1122 	/**
       
  1123 	This panic is raised when creating a thread using the Create() member
       
  1124 	functions of RThread.
       
  1125 	
       
  1126 	The panic is only raised by those variants of Create() which create a new
       
  1127 	heap for the new thread. The panic occurs if the minimum heap size
       
  1128 	specified is greater than the maximum size to which the heap can grow.
       
  1129 	
       
  1130     @see RThread
       
  1131 	*/
       
  1132 	EThrdHeapMaxLessThanMin=111,
       
  1133 	
       
  1134 	
       
  1135 	/**
       
  1136 	This panic is raised by the Alloc() and AllocL() member functions of class
       
  1137 	RRef when the size value passed is negative.
       
  1138 	*/
       
  1139 	ERefAllocSizeNegative=112,
       
  1140 	
       
  1141 	
       
  1142 	/**
       
  1143 	This panic is raised by:
       
  1144 
       
  1145     1. the constructor of a time representation object, a TTime, which takes
       
  1146        a text string, when the format of that text string is incorrect
       
  1147        or represents an invalid date/time.
       
  1148        
       
  1149     2. the Parse() member function of a time representation object, a TTime,
       
  1150        if the century offset value is either negative or is greater than
       
  1151        or equal to 100.
       
  1152        
       
  1153     3. the Time::DaysInMonth() function, if an invalid month value is passed.
       
  1154 
       
  1155     @see TTime
       
  1156     @see Time
       
  1157 	*/
       
  1158 	ETTimeValueOutOfRange=113,
       
  1159 	
       
  1160 	
       
  1161 	/**
       
  1162     This panic is raised by member functions of TBusLocalDrive when no
       
  1163     connection has been made to a local drive.
       
  1164     
       
  1165 	This panic is raised in debug builds only.
       
  1166 	
       
  1167 	@see TBusLocalDrive
       
  1168 	*/
       
  1169 	EDriveNotConnected=114,
       
  1170 	
       
  1171 	
       
  1172 	/**
       
  1173 	This panic is raised when attempting to connect to a local drive
       
  1174 	using the Connect() member function of TBusLocalDrive, and
       
  1175 	the specified drive number is out of range, i.e. the drive number
       
  1176 	is negative or is greater than or equal to KMaxLocalDrives.
       
  1177 	
       
  1178 	@see TBusLocalDrive
       
  1179 	@see KMaxLocalDrives
       
  1180 	*/
       
  1181 	EDriveOutOfRange=115,
       
  1182 	
       
  1183 	
       
  1184 	/**
       
  1185 	This panic is raised by the Lookup() member function of RLibrary when
       
  1186 	the ordinal number of the required DLL function, is zero or negative.
       
  1187     
       
  1188     @see RLibrary
       
  1189 	*/
       
  1190 	EBadLookupOrdinal=116,
       
  1191 	
       
  1192 	
       
  1193 	/**
       
  1194 	Not used.
       
  1195 	*/
       
  1196 	EChunkHeapBadOffset=117,
       
  1197 	
       
  1198 	
       
  1199 	/**
       
  1200 	Not used.
       
  1201 	*/
       
  1202 	ETQueLinkAlreadyInUse=118,
       
  1203 	
       
  1204 	
       
  1205 	/**
       
  1206 	This panic is raised when setting a new currency symbol using
       
  1207 	the User::SetCurrencySymbol() function.
       
  1208 	
       
  1209 	The panic occurs when the length of the descriptor containing
       
  1210 	the new symbol is greater than KMaxCurrencySymbol.
       
  1211  	
       
  1212  	@see User
       
  1213  	@see KMaxCurrencySymbol
       
  1214 	*/
       
  1215 	ECurrencySymbolOverflow=119,
       
  1216 	
       
  1217 	
       
  1218 	/**
       
  1219 	This panic is raised by the CreateDoubleEndedLocal()
       
  1220 	and CreateDoubleEndedGlobal() member functions of RChunk when the lower
       
  1221 	address of the committed region is negative.
       
  1222 	
       
  1223 	@see RChunk
       
  1224 	*/
       
  1225 	EChkCreateBottomNegative=120,
       
  1226 	
       
  1227 	
       
  1228 	/**
       
  1229 	This panic is raised by the CreateDoubleEndedLocal()
       
  1230 	and CreateDoubleEndedGlobal() member functions of RChunk when the upper
       
  1231 	address of the committed region is negative.
       
  1232 	
       
  1233 	@see RChunk
       
  1234 	*/
       
  1235 	EChkCreateTopNegative=121,
       
  1236 	
       
  1237 	
       
  1238 	/**
       
  1239 	This panic is raised by the CreateDoubleEndedLocal()
       
  1240 	and CreateDoubleEndedGlobal() member functions of RChunk when the upper
       
  1241 	address of the committed region is lower than the lower address of
       
  1242 	the committed region.
       
  1243 
       
  1244 	@see RChunk
       
  1245 	*/
       
  1246 	EChkCreateTopLessThanBottom=122,
       
  1247 	
       
  1248 	
       
  1249 	/**
       
  1250 	This panic is raised by the CreateDoubleEndedLocal()
       
  1251 	and CreateDoubleEndedGlobal() member functions of RChunk when the upper
       
  1252 	address of the committed region is lower than the maximum size to which
       
  1253 	this chunk can be adjusted.
       
  1254 
       
  1255 	@see RChunk
       
  1256 	*/
       
  1257 	EChkCreateTopBiggerThanMax=123,
       
  1258 	
       
  1259 	
       
  1260 	/**
       
  1261 	This panic is raised by RChunk::AdjustDoubleEnded() when the lower address
       
  1262 	of the committed region is negative.
       
  1263 	
       
  1264     @see RChunk
       
  1265 	*/
       
  1266 	EChkAdjustBottomNegative=124,
       
  1267 	
       
  1268 	
       
  1269 	/**
       
  1270 	This panic is raised by RChunk::AdjustDoubleEnded() when the upper address
       
  1271 	of the committed region is negative.
       
  1272 	
       
  1273     @see RChunk
       
  1274 	*/
       
  1275 	EChkAdjustTopNegative=125,
       
  1276 	
       
  1277 	
       
  1278 	/**
       
  1279 	This panic is raised by RChunk::AdjustDoubleEnded() when the upper address
       
  1280 	of the committed region is lower than the lower address of the committed
       
  1281 	region.
       
  1282 	
       
  1283     @see RChunk
       
  1284 	*/
       
  1285 	EChkAdjustTopLessThanBottom=126,
       
  1286 	
       
  1287 	
       
  1288 	/**
       
  1289 	This panic is raised when constructing an array of pointers,
       
  1290 	an RPointerArray, and specifying a granularity value which is
       
  1291 	one of the following:
       
  1292 
       
  1293     1. zero
       
  1294 
       
  1295     2. negative
       
  1296 
       
  1297     3. greater than 0x10000000.
       
  1298     
       
  1299     @see RPointerArray
       
  1300 	*/
       
  1301 	EBadArrayGranularity=127,
       
  1302 	
       
  1303 	
       
  1304 	/**
       
  1305 	This panic is raised when constructing an array of fixed length objects,
       
  1306 	an RArray, and specifying a key offset value which is one of the following:
       
  1307 
       
  1308     1. negative
       
  1309 
       
  1310     2. not a multiple of 4
       
  1311 
       
  1312     3. greater than or equal to the size of the array elements.
       
  1313     
       
  1314     @see RArray
       
  1315 	*/
       
  1316 	EBadArrayKeyOffset=128,
       
  1317 	
       
  1318 	
       
  1319 	/**
       
  1320 	This panic is raised when constructing an array of fixed length objects,
       
  1321 	an RArray, and the length of the array elements is one of the following:
       
  1322 
       
  1323     1. zero
       
  1324 
       
  1325     2. negative
       
  1326 
       
  1327     3. greater than 640.
       
  1328     
       
  1329     @see RArray
       
  1330 	*/
       
  1331 	EBadArrayEntrySize=129,
       
  1332 	
       
  1333 	
       
  1334 	/**
       
  1335 	This panic is raised when an index value passed to a member function
       
  1336 	of RArray or RPointerArray identifying an array element, is out of bounds.
       
  1337 
       
  1338     @see RArray
       
  1339     @see RPointerArray
       
  1340 	*/
       
  1341 	EBadArrayIndex=130,
       
  1342 	
       
  1343 	
       
  1344 	/**
       
  1345 	This panic is raised when the value identifying the insertion position
       
  1346 	in a call to RArray::Insert() or RPointerArray::Insert(), is either
       
  1347 	negative or greater than the number of elements in the array.
       
  1348 
       
  1349     @see RArray
       
  1350     @see RPointerArray
       
  1351 	*/
       
  1352 	EBadArrayPosition=131,
       
  1353 	
       
  1354 	
       
  1355 	/**
       
  1356 	This panic is raised when an index value passed to
       
  1357 	Mem::CollationMethodByIndex() or Mem::CollationMethodId() is out of bounds.
       
  1358 
       
  1359     @see Mem
       
  1360 	*/
       
  1361 	EBadCollationRulesIndex=132,
       
  1362 	
       
  1363 	
       
  1364 	/**
       
  1365 	This panic is raised when an index value passed to TFixedArray::At()
       
  1366     or TFixedArray::operator[] is out of bounds.
       
  1367 
       
  1368     @see TFixedArray
       
  1369 	*/
       
  1370 	EBadFixedArrayIndex=133,
       
  1371 	
       
  1372 	
       
  1373 	/**
       
  1374 	Not used.
       
  1375 	*/
       
  1376 	ERawEventFlipTypeNotImplemented=134,
       
  1377 	
       
  1378 	
       
  1379 	/**
       
  1380 	Not used.
       
  1381 	*/
       
  1382 	ENumberOfParametersExceedsMaximum=136,
       
  1383 	
       
  1384 	
       
  1385 	/**
       
  1386 	This panic is raised internally by the descriptor formatting functions during the handling
       
  1387 	of the variable parameter lists when the parameter is too big.
       
  1388 	*/
       
  1389 	ESizeOfParameterTooBig=137,
       
  1390 	
       
  1391 	
       
  1392 	/**
       
  1393 	This panic is raised internally by the descriptor formatting functions
       
  1394 	during the handling of the variable parameter lists when an index value
       
  1395 	for the parameters is outside its permitted range.
       
  1396 	*/
       
  1397 	EParameterIndexOutOfRange1=138,
       
  1398 	
       
  1399 	
       
  1400 	/**
       
  1401 	This panic is raised internally by the descriptor formatting functions
       
  1402 	during the handling of the variable parameter lists when an index value
       
  1403 	for the parameters is outside its permitted range.
       
  1404 	
       
  1405 	This panic is raised in debug mode only.
       
  1406 	*/
       
  1407 	EParameterIndexOutOfRange2=139,
       
  1408 	
       
  1409 	
       
  1410 	/**
       
  1411 	This panic is raised internally by the descriptor formatting functions
       
  1412 	during the handling of the variable parameter lists.
       
  1413 	*/
       
  1414 	EFormatDirectiveAlreadySet1=140,
       
  1415 	
       
  1416 	
       
  1417 	/**
       
  1418 	This panic is raised internally by the descriptor formatting functions
       
  1419 	during the handling of the variable parameter lists.
       
  1420 	*/
       
  1421 	EFormatDirectiveAlreadySet2=141,
       
  1422 	
       
  1423 	
       
  1424 	/**
       
  1425 	This panic is raised internally by the descriptor formatting functions
       
  1426 	during the handling of the variable parameter lists.
       
  1427 	*/
       
  1428 	ENumberOfFormatDirectivesExceedsMaximum=142,
       
  1429 	
       
  1430 	
       
  1431 	/**
       
  1432 	This panic is raised internally by the descriptor formatting functions
       
  1433 	during the handling of the variable parameter lists.
       
  1434 	*/
       
  1435 	ENoParametersInFormatDirective=143,
       
  1436 	
       
  1437 	
       
  1438 	/**
       
  1439 	This panic is raised internally by the descriptor formatting functions
       
  1440 	during the handling of the variable parameter lists.
       
  1441 	*/
       
  1442 	EFormatDirectiveNotYetSet=144,
       
  1443 	
       
  1444 	
       
  1445 	/**
       
  1446 	This panic is raised internally by the descriptor formatting functions
       
  1447 	during the handling of the variable parameter lists.
       
  1448 	*/
       
  1449 	EBadFormatDirectiveDataPointer=145,
       
  1450 	
       
  1451 	
       
  1452 	/**
       
  1453 	This panic is raised internally by the descriptor formatting functions
       
  1454 	during the handling of the variable parameter lists.
       
  1455 	*/
       
  1456 	EFormatDirectiveIndexOutOfRange=146,
       
  1457 	
       
  1458 	
       
  1459 	/**
       
  1460 	This panic is raised internally by the descriptor formatting functions
       
  1461 	during the handling of the variable parameter lists.
       
  1462 	*/
       
  1463 	ENotOnFirstPassOfFormatDescriptor1=147,
       
  1464 	
       
  1465 	
       
  1466 	/**
       
  1467 	This panic is raised internally by the descriptor formatting functions
       
  1468 	during the handling of the variable parameter lists.
       
  1469 	*/
       
  1470 	ENotOnFirstPassOfFormatDescriptor2=148,
       
  1471 	
       
  1472 	
       
  1473 	/**
       
  1474 	This panic is raised internally by the descriptor formatting functions
       
  1475 	during the handling of the variable parameter lists.
       
  1476 	*/
       
  1477 	EInconsistentSizeOfParameter=149,
       
  1478 	
       
  1479 	
       
  1480 	/**
       
  1481 	This panic is raised internally by the descriptor formatting functions
       
  1482 	during the handling of the variable parameter lists.
       
  1483 	*/
       
  1484 	ENullTargetPointer=150,
       
  1485 	
       
  1486 	
       
  1487 	/**
       
  1488 	This panic is raised internally by the descriptor formatting functions
       
  1489 	during the handling of the variable parameter lists.
       
  1490 	*/
       
  1491 	ENegativeSizeOfParameter=151,
       
  1492 	
       
  1493 	
       
  1494 	/**
       
  1495 	This panic is raised internally by the descriptor formatting functions
       
  1496 	during the handling of the variable parameter lists.
       
  1497 	*/
       
  1498 	EErrorOnSecondPassOfFormatDescriptor=152,
       
  1499 	
       
  1500 	
       
  1501 	/**
       
  1502 	This panic is raised internally by the descriptor formatting functions
       
  1503 	during the handling of the variable parameter lists.
       
  1504 	*/
       
  1505 	EUnexpectedError1=153,
       
  1506 	
       
  1507 	
       
  1508 	/**
       
  1509 	This panic is raised internally by the descriptor formatting functions
       
  1510 	during the handling of the variable parameter lists.
       
  1511 	*/
       
  1512 	EUnexpectedError2=154,
       
  1513 	
       
  1514 	
       
  1515 	/**
       
  1516 	Not used.
       
  1517 	*/
       
  1518 	ECreateTransferBufferSizeNotPositive=155,
       
  1519 	
       
  1520 	
       
  1521 	/**
       
  1522 	This panic occurs in the construction of an RPointerArray object from
       
  1523 	an existing pointer array object, when the number defining the number
       
  1524 	of entries in the existing array is not positive.
       
  1525 	
       
  1526 	@see RPointerArray
       
  1527 	*/
       
  1528 	EBadArrayCount=156,
       
  1529 	
       
  1530 	
       
  1531 	/**
       
  1532 	This panic is raised by RChunk::Commit() when the value of the offset of
       
  1533 	the committed region is negative.
       
  1534 	
       
  1535 	@see RChunk
       
  1536 	*/
       
  1537 	EChkCommitOffsetNegative=157,
       
  1538 	
       
  1539 	
       
  1540 	/**
       
  1541 	This panic is raised by RChunk::Commit() when the size of the
       
  1542 	the committed region is negative.
       
  1543 	
       
  1544 	@see RChunk
       
  1545 	*/
       
  1546 	EChkCommitSizeNegative=158,
       
  1547 	
       
  1548 	
       
  1549 	/**
       
  1550 	This panic is raised by RChunk::Allocate() when the size of the
       
  1551 	the committed region is negative.
       
  1552 	
       
  1553 	@see RChunk
       
  1554 	*/
       
  1555 	EChkAllocateSizeNegative=159,
       
  1556 	
       
  1557 	
       
  1558 	/**
       
  1559 	This panic is raised by RChunk::Decommit() when the value of the offset of
       
  1560 	the committed region is negative.
       
  1561 	
       
  1562 	@see RChunk
       
  1563 	*/
       
  1564 	EChkDecommitOffsetNegative=160,
       
  1565 	
       
  1566 	
       
  1567 	/**
       
  1568 	This panic is raised by RChunk::Decommit() when the size of the
       
  1569 	the committed region is negative.
       
  1570 	
       
  1571 	@see RChunk
       
  1572 	*/
       
  1573 	EChkDecommitSizeNegative=161,
       
  1574 	
       
  1575 	
       
  1576 	/**
       
  1577 	This panic is raised when an invalid chunk type has been passed to
       
  1578 	the internal member RChunk::Create()
       
  1579 	
       
  1580 	@see RChunk
       
  1581 	*/
       
  1582 	EChkCreateInvalidType=162,
       
  1583 	
       
  1584 	
       
  1585 	/**
       
  1586 	This panic is raised when a global chunk is being created and
       
  1587 	no name has been specified.
       
  1588 	
       
  1589 	@see RChunk
       
  1590 	*/
       
  1591 	EChkCreateInvalidName=163,
       
  1592 	
       
  1593 	
       
  1594 	/**
       
  1595 	This panic is raised when creating a 'normal' chunk and the offset of the bottom of the new committed region 
       
  1596     from the base of the chunk's reserved region is not zero.
       
  1597 
       
  1598     @see RChunk
       
  1599 	*/
       
  1600 	EChkCreateInvalidBottom=164,
       
  1601 	
       
  1602 	
       
  1603 	/**
       
  1604 	This panic is raised by the internal function RLibrary::Init() when the function that 
       
  1605 	constructs static data following a DLL load, leaves.
       
  1606 	*/
       
  1607 	EDllStaticConstructorLeave=165,
       
  1608 	
       
  1609 	
       
  1610 	/**
       
  1611 	This panic is raised internally, if a call to the static data destructors
       
  1612 	following a library handle close, leaves.
       
  1613 	*/
       
  1614 	EDllStaticDestructorLeave=166,
       
  1615 	
       
  1616 	
       
  1617 	/**
       
  1618 	This panic is raised in a call to RAllocator::Close() when the number of
       
  1619 	handles is greater than	the maximum allowed, RAllocator::EMaxHandles.
       
  1620 	
       
  1621 	@see RAllocator
       
  1622 	*/
       
  1623 	EAllocatorBadHandleCount=167,
       
  1624 	
       
  1625 	
       
  1626 	/**
       
  1627 	This panic is raised by the internal RHeap constructor when the offset value is invalid.
       
  1628 	*/
       
  1629 	ETHeapNewBadOffset=168,
       
  1630 	
       
  1631 	
       
  1632 	/**
       
  1633 	This panic is raised by the Symbian internal function RHeap::Reduce() on failure.
       
  1634 	*/
       
  1635 	ETHeapReduceFailed=169,
       
  1636 	
       
  1637 	
       
  1638 	/**
       
  1639 	This panic is raised by the Symbian internal function RHeap::Reset() on failure.
       
  1640 	*/
       
  1641 	ETHeapResetFailed=170,
       
  1642 	
       
  1643 	
       
  1644 	/**
       
  1645     This panic is raised by the Symbian internal function RHeap::WalkCheckCell() on a 
       
  1646     bad free cell size.
       
  1647 	*/
       
  1648 	ETHeapBadFreeCellSize=171,
       
  1649 	
       
  1650 	
       
  1651 	/**
       
  1652     This panic is raised by the Symbian internal function RHeap::Initialise() on a
       
  1653     bad alignment value.
       
  1654 	*/
       
  1655 	ETHeapNewBadAlignment=172,
       
  1656 	
       
  1657 	
       
  1658 	/**
       
  1659 	Not used.
       
  1660 	*/
       
  1661 	ETHeapBadDebugOp=173,
       
  1662 	
       
  1663 	
       
  1664 	/**
       
  1665 	This panic is raised when an unimplemented pure virtual function is called.
       
  1666 	*/
       
  1667 	EPureVirtualCalled=174,
       
  1668 	
       
  1669 	
       
  1670 	/**
       
  1671 	This panic is raised when a User::Leave() is called and there
       
  1672 	is no TRAP frame.
       
  1673 	*/
       
  1674 	EUserLeaveWithoutTrap=175,
       
  1675 	
       
  1676 	
       
  1677 	/**
       
  1678 	This panic is raised when a mathematical function fails with an
       
  1679 	unrecognized exception, i.e. one that is none of: KErrArgument,
       
  1680 	KErrDivideByZero, KErrOverflow or KErrUnderflow.
       
  1681 	*/
       
  1682 	EMathUnknownError=176,
       
  1683 	
       
  1684 	
       
  1685 	/**
       
  1686 	This panic is raised by the Symbian internal function RHeap::WalkCheckCell() on a 
       
  1687     bad cell type.
       
  1688 	*/
       
  1689 	ETHeapWalkBadCellType=177,
       
  1690 	
       
  1691 	
       
  1692 	/**
       
  1693 	This panic is raised when descriptors convert integers into text, and
       
  1694 	an invalid radix is passed, i.e. a value that is not one 
       
  1695 	of the TRadix enum values.
       
  1696 	*/
       
  1697 	EInvalidRadix=178,
       
  1698 	
       
  1699 	
       
  1700 	/**
       
  1701 	This panic is raised when converting and appending numbers in descriptors,
       
  1702 	and buffers are not aligned on even addresses.
       
  1703 	
       
  1704     This panic is raised in debug builds only.	
       
  1705 	*/
       
  1706 	EDes16PadAppendBadAlign=179,
       
  1707 	
       
  1708 	
       
  1709 	/**
       
  1710 	Not used.
       
  1711 	*/
       
  1712 	EMsgQueueSizeInvalid=180,
       
  1713 	
       
  1714 	
       
  1715     /**
       
  1716 	@internalComponent
       
  1717 	*/
       
  1718 	EHuffmanTooManyCodes=181,
       
  1719 	
       
  1720 	
       
  1721 	/**
       
  1722 	@internalComponent
       
  1723 	*/
       
  1724 	EHuffmanInvalidCoding=182,
       
  1725 	
       
  1726 	
       
  1727 	/**
       
  1728 	@internalComponent
       
  1729 	*/
       
  1730 	EBadArrayFindMode=183,
       
  1731 	
       
  1732 	
       
  1733 	/**
       
  1734 	In a call to RNotifier::Notify(), the length of one or more of
       
  1735 	the descriptors containing the displayable text is bigger than
       
  1736 	the maximum TUint16 value.
       
  1737 	*/
       
  1738 	ENotifierTextTooLong=184,
       
  1739 	
       
  1740 	
       
  1741 	/**
       
  1742 	In a call to one of the functions:
       
  1743 	TMonthName::Set()
       
  1744 	TMonthNameAbb::Set()
       
  1745 	TDayName::Set()
       
  1746 	TDayNameAbb::Set()
       
  1747 	
       
  1748 	the month or day value is outside the permitted range of values.
       
  1749 
       
  1750     @see TMonthName
       
  1751     @see TMonthNameAbb
       
  1752     @see TDayName
       
  1753     @see TDayNameAbb
       
  1754 	*/
       
  1755 	EBadLocaleParameter=185,
       
  1756 	
       
  1757 	
       
  1758 	/**
       
  1759 	This panic is raised internally by the descriptor formatting functions
       
  1760 	during the handling of the variable parameter lists.
       
  1761 	*/
       
  1762 	EUnexpectedError3=186,
       
  1763 	
       
  1764 	
       
  1765 	/**
       
  1766 	In a call to TDes8::Expand(), either the length, or the maximum length,
       
  1767 	or the pointer to the data is not an even number.
       
  1768 	
       
  1769 	@see TDes8
       
  1770 	*/
       
  1771 	EDes8ExpandOdd=187,
       
  1772 	
       
  1773 	
       
  1774 	/**
       
  1775 	In a call to TDes8::Collapse(), either the length, or the maximum length,
       
  1776 	or the pointer to the data is not an even number.
       
  1777 	
       
  1778 	@see TDes8
       
  1779 	*/
       
  1780 	EDes8CollapseOdd=188,
       
  1781 
       
  1782 
       
  1783 	/**
       
  1784 	In a call to one of the TSecurityPolicy constructors, the specified
       
  1785 	capability was found to be inavlid.
       
  1786 
       
  1787 	@see TCapability
       
  1788 	*/
       
  1789 	ECapabilityInvalid=189,
       
  1790 
       
  1791 
       
  1792 	/**
       
  1793 	In a call to TSecurityPolicy::CheckPolicy, the security policy was found to
       
  1794 	be corrupt.
       
  1795 
       
  1796 	@see TSecurityPolicy
       
  1797 	*/
       
  1798 	ESecurityPolicyCorrupt=190,
       
  1799 
       
  1800 	
       
  1801 	/**
       
  1802 	In a call to TSecurityPolicy::TSecurityPolicy(TSecPolicyType aType), aType
       
  1803 	was not one of ETypePass or ETypeFail.
       
  1804 
       
  1805 	@see TSecurityPolicy
       
  1806 	*/
       
  1807 	ETSecPolicyTypeInvalid=191,
       
  1808 
       
  1809 	/**
       
  1810 	This panic is raised when constructing an RPointerArray or RArray if the
       
  1811 	specified minimum growth step is less than or equal to zero or is greater
       
  1812 	than 65535.
       
  1813     
       
  1814     @see RPointerArray
       
  1815     @see RArray
       
  1816 	*/
       
  1817 	EBadArrayMinGrowBy=192,
       
  1818 	
       
  1819 	
       
  1820 	/**
       
  1821 	This panic is raised when constructing an RPointerArray or RArray if the
       
  1822 	specified exponential growth factor is less than or equal to 1 or is
       
  1823 	greater than or equal to 128.
       
  1824     
       
  1825     @see RPointerArray
       
  1826     @see RArray
       
  1827 	*/
       
  1828 	EBadArrayFactor=193,
       
  1829 	
       
  1830 	
       
  1831 	/**
       
  1832 	This panic is raised if code inside an __ASSERT_*_NO_LEAVE harness leaves.
       
  1833     
       
  1834     @see RPointerArray
       
  1835     @see RArray
       
  1836 	*/
       
  1837 	EUnexpectedLeave=194,
       
  1838 	
       
  1839 	
       
  1840 	/**
       
  1841 	A function was used to grow a cell on the heap, but it did not grow as expected.
       
  1842 	*/		
       
  1843 	ETHeapCellDidntGrow=195,
       
  1844 	
       
  1845 	
       
  1846 	/**
       
  1847 	An attempt was made to install a Win32 SE handler not on the stack.
       
  1848 
       
  1849 	@see TWin32SEHTrap
       
  1850 	*/
       
  1851 	EWin32SEHandlerNotOnStack=196,
       
  1852 	
       
  1853 	/**
       
  1854 	This panic is raised when the caller of an API doesn't have the right capabilities to
       
  1855 	call the specific API that raises this panic. Please consult the documentation for the
       
  1856 	API in question to learn what capabilities you need to call it.
       
  1857 	*/
       
  1858 	EPlatformSecurityViolation=197,
       
  1859 
       
  1860 	/**
       
  1861 	This panic is raised if a NULL function pointer is passed in as the hash function
       
  1862 	when constructing a hash table class.
       
  1863 	*/
       
  1864 	EHashTableNoHashFunc=198,
       
  1865 
       
  1866 	/**
       
  1867 	This panic is raised if a NULL function pointer is passed in as the identity
       
  1868 	relation when constructing a hash table class.
       
  1869 	*/
       
  1870 	EHashTableNoIdentityRelation=199,
       
  1871 
       
  1872 	/**
       
  1873 	This panic is raised if a negative element size is specified when constructing
       
  1874 	a hash table class.
       
  1875 	*/
       
  1876 	EHashTableBadElementSize=200,
       
  1877 
       
  1878 	/**
       
  1879 	This panic is raised if, when constructing a hash table class, the specified
       
  1880 	key offset is inconsistent with the specified element size.
       
  1881 	*/
       
  1882 	EHashTableBadKeyOffset=201,
       
  1883 
       
  1884 	/**
       
  1885 	This panic is raised in debug builds only if a deleted entry still remains after
       
  1886 	a hash table reform. It should never occur, since it signifies an error in the
       
  1887 	hash table implementation.
       
  1888 	*/
       
  1889 	EHashTableDeletedEntryAfterReform=202,
       
  1890 
       
  1891 	/**
       
  1892 	This panic should never occur since it signifies an error in the hash table
       
  1893 	implementation.
       
  1894 	*/
       
  1895 	EHashTableBadGeneration=203,
       
  1896 
       
  1897 	/**
       
  1898 	This panic should never occur since it signifies an error in the hash table
       
  1899 	implementation.
       
  1900 	*/
       
  1901 	EHashTableBadHash=204,
       
  1902 
       
  1903 	/**
       
  1904 	This panic should never occur since it signifies an error in the hash table
       
  1905 	implementation.
       
  1906 	*/
       
  1907 	EHashTableEntryLost=205,
       
  1908 
       
  1909 	/**
       
  1910 	This panic should never occur since it signifies an error in the hash table
       
  1911 	implementation.
       
  1912 	*/
       
  1913 	EHashTableCountWrong=206,
       
  1914 
       
  1915 	/**
       
  1916 	This panic should never occur since it signifies an error in the hash table
       
  1917 	implementation.
       
  1918 	*/
       
  1919 	EHashTableEmptyCountWrong=207,
       
  1920 
       
  1921 	/**
       
  1922 	This panic is raised if, while attempting to step a hash table iterator to
       
  1923 	the next entry, the iterator is found to point to an invalid table entry.
       
  1924 	This will typically occur if elements have been removed from the hash table
       
  1925 	without resetting the iterator.
       
  1926 	*/
       
  1927 	EHashTableIterNextBadIndex=208,
       
  1928 
       
  1929 	/**
       
  1930 	This panic is raised if, while interrogating the current position of a
       
  1931 	hash table iterator, the iterator is found to point to an invalid table entry.
       
  1932 	This will typically occur if elements have been added to or removed from
       
  1933 	the hash table without resetting the iterator.
       
  1934 	*/
       
  1935 	EHashTableIterCurrentBadIndex=209,
       
  1936 
       
  1937 	/**
       
  1938 	This panic is raised if an invalid argument is passed to the Reserve() function
       
  1939 	on any of the hash table classes.
       
  1940 	*/
       
  1941 	EHashTableBadReserveCount=210,
       
  1942 
       
  1943 	/**
       
  1944 	The Win32 SE handler chain has been corrupted.
       
  1945 
       
  1946 	@see TWin32SEHTrap
       
  1947 	*/
       
  1948 	EWin32SEHChainCorrupt=211,
       
  1949 
       
  1950 	
       
  1951 	/**
       
  1952 	This panic is raised if an invalid argument is passed to the Reserve() function
       
  1953 	on the RArray<T> or RPointerArray<T> classes.
       
  1954 	*/
       
  1955 	EArrayBadReserveCount=212,
       
  1956 
       
  1957 	/**
       
  1958 	This panic is raised when attempting to set a new debug failure mode on 
       
  1959 	a heap with an invalid argument.  For example, if aBurst > KMaxTUint6
       
  1960 	when invoking __UHEAP_BURSTFAILNEXT when a RHeap object is used for
       
  1961 	the user heap.
       
  1962 
       
  1963 	On the user side this is associated with the USER category; on the kernel side
       
  1964 	this is associated with the KERN-HEAP category.
       
  1965 
       
  1966 	@see RAllocator::TAllocFail
       
  1967 	*/
       
  1968 	ETHeapBadDebugFailParameter = 213,
       
  1969 	
       
  1970 	
       
  1971 	/**
       
  1972 	This panic is raised when an invalid chunk attribute has been passed to
       
  1973 	the method RChunk::Create().
       
  1974 	
       
  1975 	@see RChunk
       
  1976 	*/
       
  1977 	EChkCreateInvalidAttribute = 214,
       
  1978 
       
  1979 	
       
  1980 	/**
       
  1981 	This panic is raised when a TChunkCreateInfo object with an invalid version 
       
  1982 	number has been passed to the method RChunk::Create().
       
  1983 
       
  1984 	@see RChunk
       
  1985 	@see TChunkCreateInfo
       
  1986 	*/
       
  1987 	EChkCreateInvalidVersion = 215,
       
  1988 
       
  1989 	
       
  1990 	/**
       
  1991 	This panic is raised when an invalid flag is set in the aMode parameter
       
  1992 	to UserHeap::ChunkHeap().
       
  1993 
       
  1994 	@see TChunkHeapCreateMode
       
  1995 	*/
       
  1996 	EHeapCreateInvalidMode = 216,
       
  1997 
       
  1998 
       
  1999 	/**
       
  2000 	This panic is raised when a RReadWriteLock is created with an invalid
       
  2001 	priority.
       
  2002 
       
  2003 	@see RReadWriteLock
       
  2004 	*/
       
  2005 	EReadWriteLockInvalidPriority = 217,
       
  2006 
       
  2007 
       
  2008 	/**
       
  2009 	This panic is raised when a RReadWriteLock is closed with readers/writers
       
  2010 	still pending.
       
  2011 
       
  2012 	@see RReadWriteLock
       
  2013 	*/
       
  2014 	EReadWriteLockStillPending = 218,
       
  2015 
       
  2016 
       
  2017 	/**
       
  2018 	This panic is raised when a RReadWriteLock is requested with too many
       
  2019 	readers or pending readers/writers.
       
  2020 
       
  2021 	@see RReadWriteLock
       
  2022 	*/
       
  2023 	EReadWriteLockTooManyClients = 219,
       
  2024 
       
  2025 
       
  2026 	/**
       
  2027 	This panic is raised when a RReadWriteLock is unlocked but the lock flags
       
  2028 	are inconsistent, eg read and write lock held or no lock held.
       
  2029 
       
  2030 	@see RReadWriteLock
       
  2031 	*/
       
  2032 	EReadWriteLockBadLockState = 220,
       
  2033 
       
  2034 
       
  2035 	/**
       
  2036 	This debug-only panic is raised if the lock has been given to a reader
       
  2037 	more than a thousand times in a row, while there is a pending writer.
       
  2038 	It is intended to give a debug indication that writer starvation might be
       
  2039 	happening.
       
  2040 
       
  2041 	@see RReadWriteLock
       
  2042 	*/
       
  2043 	EReadWriteLockWriterStarvation = 221,
       
  2044 
       
  2045 	/**
       
  2046     It is raised by TRawEvent::Repeats() when
       
  2047     the event is not a key repeat event.
       
  2048     
       
  2049    	This panic is raised in debug builds only.
       
  2050 	*/
       
  2051 	ETEventNotKeyRepeatType=222,
       
  2052 
       
  2053 	/**
       
  2054 	This panic is raised when a corrupt surrogate is found in a descriptor.
       
  2055 	*/
       
  2056 	ECorruptSurrogateFound = 223,
       
  2057 	};
       
  2058 
       
  2059 
       
  2060 
       
  2061 
       
  2062 /**
       
  2063 Defines a set of panic numbers associated with the E32USER-CBASE panic category.
       
  2064 
       
  2065 Panics with this category are raised in user side code by member functions of
       
  2066 CBase derived classes that reside in euser.dll. Typically, they are caused by
       
  2067 passing bad or contradictory values to class constructors or member functions.
       
  2068 */
       
  2069 enum TBasePanic
       
  2070     {
       
  2071     
       
  2072     /**
       
  2073     This panic is raised by the Set() member function of CAsyncCallBack,
       
  2074     if this active object is already active when the function is called.
       
  2075     
       
  2076     @see CAsyncCallBack
       
  2077     */
       
  2078 	ECAsyncCBIsActive=1,
       
  2079 	
       
  2080 	
       
  2081 	/**
       
  2082 	This panic is raised by the Call() member function of CAsyncOneShot,
       
  2083 	if the active object has not already been added to the active scheduler.
       
  2084 	
       
  2085 	This panic is raised in debug builds only.
       
  2086 	
       
  2087 	@see CAsyncOneShot
       
  2088 	*/
       
  2089 	ECAsyncOneShotNotAdded=2,
       
  2090 	
       
  2091 	
       
  2092 	/**
       
  2093 	This panic is raised during construction of a dynamic buffer,
       
  2094 	a CBufFlat or a CBufSeg object, when the value of the granularity passed
       
  2095 	to the constructors is negative.
       
  2096 	
       
  2097 	@see CBufFlat
       
  2098 	@see CBufSeg
       
  2099 	*/
       
  2100 	EBufExpandSizeNegative=3,
       
  2101 	
       
  2102 	
       
  2103 	/**
       
  2104 	This panic is raised when reading from a dynamic buffer,
       
  2105 	a CBufFlat or a CBufSeg, using the Read() member function.
       
  2106 	
       
  2107 	It is caused by attempting to read beyond the end of the buffer.
       
  2108 
       
  2109 	@see CBufFlat
       
  2110 	@see CBufSeg
       
  2111 	*/
       
  2112 	EBufReadBeyondEnd=4,
       
  2113 	
       
  2114 	
       
  2115 	/**
       
  2116 	This panic is raised when writing to a dynamic buffer,
       
  2117 	a CBufFlat or a CBufSeg, using the Write() member function.
       
  2118 	
       
  2119 	It is caused by attempting to write beyond the end of the buffer.
       
  2120 
       
  2121 	@see CBufFlat
       
  2122 	@see CBufSeg
       
  2123 	*/
       
  2124 	EBufWriteBeyondEnd=5,
       
  2125 	
       
  2126 	
       
  2127 	/** 
       
  2128 	This panic is raised when reading from a dynamic buffer,
       
  2129 	a CBufFlat or a CBufSeg, using the Read() member function.
       
  2130 	
       
  2131 	It is caused by specifying a negative length for the amount of data
       
  2132 	to be read.
       
  2133 
       
  2134 	@see CBufFlat
       
  2135 	@see CBufSeg
       
  2136 	*/
       
  2137 	EBufReadLengthNegative=6,
       
  2138 	
       
  2139 	
       
  2140 	/**
       
  2141 	This panic is raised when writing to a dynamic buffer,
       
  2142 	a CBufFlat or a CBufSeg, using the Write() member function.
       
  2143 	
       
  2144 	It is caused by specifying a negative length for the amount of data
       
  2145 	to be written.
       
  2146 
       
  2147 	@see CBufFlat
       
  2148 	@see CBufSeg
       
  2149 	*/
       
  2150 	EBufWriteLengthNegative=7,
       
  2151 
       
  2152 
       
  2153     /**
       
  2154     This panic is raised when inserting data into a dynamic buffer,
       
  2155     a CBufFlat or a CBufSeg, using the InsertL() member function or when
       
  2156     inserting an uninitialized region into the dynamic buffer using
       
  2157     the ExpandL() member function.
       
  2158     
       
  2159     It is caused by passing a negative length value to these functions.
       
  2160 
       
  2161 	@see CBufFlat
       
  2162 	@see CBufSeg
       
  2163     */
       
  2164 	EBufInsertLengthNegative=8,
       
  2165 	
       
  2166 	
       
  2167 	/**
       
  2168 	This panic is raised when inserting data into a dynamic buffer,
       
  2169 	a CBufFlat or a CBufSeg, using the InsertL() member function.
       
  2170 	
       
  2171 	It is caused when the variant of InsertL(), which takes a pointer to TAny
       
  2172 	is passed a NULL pointer value.
       
  2173 
       
  2174 	@see CBufFlat
       
  2175 	@see CBufSeg
       
  2176 	*/
       
  2177 	EBufInsertBadPtr=9,
       
  2178 	
       
  2179 	
       
  2180 	/**
       
  2181 	This panic is raised when specifying the minimum amount of space
       
  2182 	that a flat dynamic buffer, a CBufFlat, should occupy using
       
  2183 	the SetReserveL() member function.
       
  2184 	
       
  2185 	It is caused when the size value passed to the function is negative.
       
  2186 
       
  2187 	@see CBufFlat
       
  2188 	*/
       
  2189 	EBufFlatReserveNegative=10,
       
  2190 
       
  2191 
       
  2192 	/**
       
  2193 	This panic is raised when specifying the minimum amount of space
       
  2194 	that a flat dynamic buffer, a CBufFlat, should occupy using
       
  2195 	the SetReserveL() member function.
       
  2196 	
       
  2197 	It is caused when the size value passed to the function is less than
       
  2198 	the current size of the buffer.
       
  2199 
       
  2200 	@see CBufFlat
       
  2201 	*/
       
  2202 	EBufFlatReserveSetTooSmall=11,
       
  2203 	
       
  2204 	
       
  2205 	/**
       
  2206 	This panic is raised by the Delete(), Ptr(), BackPtr() member functions
       
  2207 	of a flat dynamic buffer, a CBufFlat; the panic can also be raised by
       
  2208 	InsertL() and ExpandL().
       
  2209 	
       
  2210 	It is caused when the position value passed to these functions is either
       
  2211 	negative or represents a position beyond the end of the current buffer.
       
  2212 	
       
  2213 	@see CBufFlat
       
  2214 	*/
       
  2215 	EBufFlatPosOutOfRange=12,
       
  2216 	
       
  2217 	
       
  2218 	/**
       
  2219 	This panic is raised by the Delete() member function of
       
  2220 	a flat dynamic buffer, a CBufFlat.
       
  2221 	
       
  2222 	It is caused when the combination of position and length values passed
       
  2223 	to the function implies an attempt to delete data beyond the end of
       
  2224 	the flat buffer.
       
  2225 
       
  2226    	@see CBufFlat
       
  2227 	*/
       
  2228 	EBufFlatDeleteBeyondEnd=13,
       
  2229 	
       
  2230 	
       
  2231 	/**
       
  2232 	This panic is raised by the Delete(), Ptr(), BackPtr() member functions
       
  2233 	of a segmented dynamic buffer, a CBufSeg); the panic can also be raised
       
  2234 	by InsertL() and ExpandL().
       
  2235 	
       
  2236 	It is caused when the position value passed to these functions is either
       
  2237 	negative or represents a position beyond the end of the current buffer.
       
  2238 
       
  2239    	@see CBufSeg
       
  2240 	*/
       
  2241 	EBufSegPosOutOfRange=14,
       
  2242 	
       
  2243 	
       
  2244 	/**
       
  2245 	This panic is raised by the Delete() member function of a segmented dynamic
       
  2246 	buffer, a CBufSeg.
       
  2247 	
       
  2248 	It is caused when the combination of position and length values passed to
       
  2249 	the function implies an attempt to delete data beyond the end of
       
  2250 	the segmented buffer.
       
  2251 
       
  2252    	@see CBufSeg
       
  2253 	*/
       
  2254 	EBufSegDeleteBeyondEnd=15,
       
  2255 	
       
  2256 	
       
  2257 	/**
       
  2258 	This panic is raised by the InsertL(), Delete(), Ptr() and BackPtr() member
       
  2259 	functions as implemented for segmented buffers, CBufSeg, when
       
  2260 	the offset within a segment, where data is to be inserted or removed,
       
  2261 	is greater than the buffer granularity.
       
  2262 
       
  2263     This panic is raised in debug builds only.
       
  2264     
       
  2265   	@see CBufSeg
       
  2266 	*/
       
  2267 	EBufSegSetSBO=16,
       
  2268 	
       
  2269 	
       
  2270 	/**
       
  2271 	This panic is raised by the constructors of arrays of fixed length objects
       
  2272 	as represented, for example, by the classes CArrayFixFlat, CArrayFixSeg,
       
  2273 	and CArrayFixFlat<TAny>.
       
  2274 	
       
  2275 	It is caused when the record length is either negative or zero. The record
       
  2276 	length is either explicitly specified, as in the case of
       
  2277 	the CArrayFixFlat<TAny> class, or is implied by the length of the template
       
  2278 	class as in the case of the CArrayFixFlat class.
       
  2279 	
       
  2280 	@see CArrayFixFlat
       
  2281 	@see CArrayFixSeg
       
  2282 	*/
       
  2283 	EArrayFixInvalidLength=17,
       
  2284 	
       
  2285 	
       
  2286 	/**
       
  2287 	This panic is raised by the constructors of arrays of fixed length objects
       
  2288 	as represented, for example, by the classes: CArrayFixFlat and CArrayFixSeg.
       
  2289 	
       
  2290 	It is caused when the granularity passed to the constructors is
       
  2291 	either negative or zero.
       
  2292 
       
  2293 	@see CArrayFixFlat
       
  2294 	@see CArrayFixSeg
       
  2295 	*/
       
  2296 	EArrayFixInvalidGranularity=18,
       
  2297 	
       
  2298 	
       
  2299 	/**
       
  2300 	This panic is raised by the constructors of arrays of variable length
       
  2301 	objects as represented, for example, by the classes: CArrayVarFlat
       
  2302 	and CArrayVarSeg.
       
  2303 	
       
  2304 	It is caused when the granularity passed to the constructors is either
       
  2305 	negative or zero.
       
  2306 
       
  2307 	@see CArrayFixFlat
       
  2308 	@see CArrayFixSeg
       
  2309 	*/
       
  2310 	EArrayVarInvalidGranularity=19,
       
  2311 	
       
  2312 	
       
  2313 	/**
       
  2314 	This panic is raised by the constructors of packed arrays as represented,
       
  2315 	for example, by the class CArrayPakFlat.
       
  2316 	
       
  2317 	It is caused when the granularity passed to the constructors is either
       
  2318 	negative or zero.
       
  2319 
       
  2320 	@see CArrayPakFlat
       
  2321 	*/
       
  2322 	EArrayPakInvalidGranularity=20,
       
  2323 	
       
  2324 	
       
  2325 	/**
       
  2326 	This panic is raised by any operation which accesses an element of an array
       
  2327 	by explicit reference to an index number, for example, the Delete(),
       
  2328 	InsertL() and At() member functions or the operator Operator[].
       
  2329 	
       
  2330 	It is caused by specifying an index value which is either negative,
       
  2331 	or is greater than or equal to the number of objects currently within the array.
       
  2332 	*/
       
  2333 	EArrayIndexOutOfRange=21,
       
  2334 	
       
  2335 	
       
  2336 	/**
       
  2337 	This panic is raised when deleting contiguous elements from an array of
       
  2338 	fixed length objects (derived from CArrayFixBase) using the Delete()
       
  2339 	member function.
       
  2340 	
       
  2341 	It is caused by specifying the number of contiguous elements as
       
  2342 	a zero or negative value.
       
  2343 	*/
       
  2344 	EArrayCountNegative=22,
       
  2345 	
       
  2346 	
       
  2347 	/**
       
  2348 	This panic is raised when inserting contiguous elements into an array
       
  2349 	of fixed length objects (derived from CArrayFixBase) using the
       
  2350 	InsertL() member function.
       
  2351 	
       
  2352 	It is caused by specifying the number of contiguous elements as
       
  2353 	a zero or negative value.
       
  2354 	*/
       
  2355 	EArrayCountNegative2=23,
       
  2356 	
       
  2357 	
       
  2358 	/**
       
  2359 	This panic is raised when resizing an array of fixed length objects
       
  2360 	(derived from CArrayFixBase) using the ResizeL() member function.
       
  2361 	
       
  2362 	It is caused by specifying the number of contiguous elements as a zero
       
  2363 	or negative value.
       
  2364 	*/
       
  2365 	EArrayCountNegative3=24,
       
  2366 	
       
  2367 	
       
  2368 	/**
       
  2369 	This panic is raised when deleting contiguous elements from an array of
       
  2370 	variable length objects (derived from CArrayVarBase) using the Delete()
       
  2371 	member function.
       
  2372 	
       
  2373 	It is caused by specifying the number of contiguous elements as a zero
       
  2374 	or negative value.
       
  2375 	*/
       
  2376 	EArrayCountNegative4=25,
       
  2377 	
       
  2378 	
       
  2379 	/**
       
  2380 	This panic is raised when deleting contiguous elements from
       
  2381 	a packed array (derived from CArrayPakBase) using the Delete()
       
  2382 	member function.
       
  2383 	
       
  2384 	It is caused by specifying the number of contiguous elements as
       
  2385 	a zero or negative value.
       
  2386 	*/
       
  2387 	EArrayCountNegative5=26,
       
  2388 	
       
  2389 	
       
  2390 	/**
       
  2391 	This panic is raised when reserving space in flat arrays of
       
  2392 	fixed length objects, the CArrayFixFlat,CArrayFixFlat<TAny>
       
  2393 	and CArrayPtrFlat classes, using the SetReserveL() member function.
       
  2394 	
       
  2395 	It is caused by specifying the number of elements, for which space is to be
       
  2396 	reserved, as less than the current number of elements in the array.
       
  2397 	*/
       
  2398     EArrayReserveTooSmall=27,
       
  2399     
       
  2400     
       
  2401 	/**
       
  2402 	This panic is raised when inserting or appending replicated 
       
  2403 	elements to the arrays of fixed length objects CArrayFixFlat and
       
  2404 	CArrayFixSeg using the InsertL() or AppendL() functions.
       
  2405 	
       
  2406 	It is caused by specifying the number of replicas as negative or zero.
       
  2407     */
       
  2408 	EArrayReplicasNegative=28,
       
  2409 	
       
  2410 	
       
  2411 	/**
       
  2412 	This panic is raised when deleting elements from a fixed length, variable
       
  2413 	length or packed array (derived from CArrayFixBase, CArrayVarBase
       
  2414 	and CArrayPakBase) using the Delete() function.
       
  2415 	
       
  2416 	It is caused when the specification of the position of the first element
       
  2417 	to be deleted and the number of contiguous elements to be deleted refers
       
  2418 	to elements which are outside the bounds of the array.
       
  2419 	*/
       
  2420 	EArrayCountTooBig=29,
       
  2421 	
       
  2422 	
       
  2423 	/**
       
  2424 	This panic is raised when inserting into, appending onto, expanding or
       
  2425 	extending a variable length array or a packed array (i.e. arrays derived
       
  2426 	from CArrayVar or CArrayPak) using the InsertL(), AppendL(), ExpandL()
       
  2427 	or ExtendL() functions respectively.
       
  2428 	
       
  2429 	It is caused by specifying the length of the element as a negative value.
       
  2430 	*/
       
  2431 	EArrayLengthNegative=30,
       
  2432 
       
  2433 
       
  2434 	/**
       
  2435 	Not used.
       
  2436 	*/
       
  2437 	EArrayReaderCountVirtual=31,
       
  2438 	
       
  2439 	
       
  2440 	/**
       
  2441 	Not used.
       
  2442 	*/
       
  2443 	EArrayReaderAtVirtual=32,
       
  2444 	
       
  2445 	
       
  2446 	/**
       
  2447 	This panic is raised by the destructor of a CObject.
       
  2448 	
       
  2449 	It is caused when an attempt is made to delete the CObject
       
  2450 	when the reference count is not zero.
       
  2451 
       
  2452     @see CObject
       
  2453 	*/
       
  2454 	EObjObjectStillReferenced=33,
       
  2455 
       
  2456 
       
  2457 	/**
       
  2458 	This panic is raised by the Close() member function of a CObject.
       
  2459 	
       
  2460 	It is caused when the reference count is negative.
       
  2461 	*/
       
  2462 	EObjNegativeAccessCount=34,
       
  2463 
       
  2464 
       
  2465 	/**
       
  2466 	This panic is raised by the Remove() member function of an object
       
  2467 	container, a CObjectCon.
       
  2468 	
       
  2469 	It is caused when the CObject to be removed from the container is
       
  2470 	not contained by the container.
       
  2471 	
       
  2472     @see CObject
       
  2473 	*/
       
  2474 	EObjRemoveObjectNotFound=35,
       
  2475 	
       
  2476 	
       
  2477 	/**
       
  2478 	This panic is raised by the Remove() member function of a container
       
  2479 	index, a CObjectConIx.
       
  2480 	
       
  2481 	It is caused when the object container, a CObjectCon, to be removed from
       
  2482 	the index is not contained by the index.
       
  2483 	*/
       
  2484 	EObjRemoveContainerNotFound=36,
       
  2485 	
       
  2486 	
       
  2487 	/**
       
  2488 	This panic is raised by the Remove() member function of an object index,
       
  2489 	a CObjectIx.
       
  2490 	
       
  2491 	It is caused when the handle passed to the Remove() function does not
       
  2492 	represent a CObject known to the object index.
       
  2493 	*/
       
  2494 	EObjRemoveBadHandle=37,
       
  2495 	
       
  2496 	
       
  2497 	/**
       
  2498 	This panic is raised by the At(), FindByName() and FindByFullName() member
       
  2499 	functions of an object container, a CObjectCon.
       
  2500 	
       
  2501 	It is caused when the unique ID as derived from the handle is not the same 
       
  2502 	as the unique ID held by the object container.
       
  2503 	*/
       
  2504 	EObjFindBadHandle=38,
       
  2505 	
       
  2506 	
       
  2507 	/**
       
  2508 	This panic is raised by the At() member function of an object container,
       
  2509 	a CObjectCon.
       
  2510 	
       
  2511 	It is caused when the index represented by the handle is outside
       
  2512 	the permitted range. In effect, the handle is bad.
       
  2513 	*/
       
  2514 	EObjFindIndexOutOfRange=39,
       
  2515 
       
  2516 
       
  2517 	/**
       
  2518 	This panic is raised by the destructor of an active object, a CActive.
       
  2519 	
       
  2520 	It is caused by an attempt to delete the active object while it still
       
  2521 	has a request outstanding.
       
  2522 	*/
       
  2523 	EReqStillActiveOnDestruct=40,
       
  2524 
       
  2525 
       
  2526 	/**
       
  2527 	This panic is raised by the Add() member function of an active scheduler,
       
  2528 	a CActiveScheduler.
       
  2529 	
       
  2530 	It is caused by an attempt to add an active object to the active scheduler
       
  2531 	when it has already been added to the active scheduler
       
  2532 	*/
       
  2533 	EReqAlreadyAdded=41,
       
  2534 	
       
  2535 	
       
  2536 	/**
       
  2537 	This panic is raised by the SetActive() member function of an active
       
  2538 	object, a CActive.
       
  2539 	
       
  2540 	It is caused by an attempt to flag the active object
       
  2541 	as active when it is already active, i.e. a request is still outstanding.
       
  2542 	*/
       
  2543 	EReqAlreadyActive=42,
       
  2544 	
       
  2545 	
       
  2546 	/**
       
  2547 	This panic is raised by the Install() member function of an active
       
  2548 	scheduler, a CActiveScheduler.
       
  2549 	
       
  2550 	It is caused by attempting to install this active scheduler as the current
       
  2551 	active scheduler when there is already a current active scheduler;
       
  2552 	i.e. an active scheduler has already been installed.
       
  2553 	*/
       
  2554 	EReqManagerAlreadyExists=43,
       
  2555 
       
  2556 
       
  2557 	/**
       
  2558 	This panic is raised by the Start(), Stop() and Add() member functions
       
  2559 	of an active scheduler, a CActiveScheduler.
       
  2560 	
       
  2561 	It is caused by attempting to start or stop an active scheduler or by
       
  2562 	attempting to add an active object, a CActive, to the active scheduler.
       
  2563 	*/
       
  2564 	EReqManagerDoesNotExist=44,
       
  2565 
       
  2566 
       
  2567 	/**
       
  2568 	This panic is raised by the Stop() member function of an active scheduler,
       
  2569 	a CActiveScheduler.
       
  2570 
       
  2571 	Calling Stop() terminates the wait loop started by the most recent
       
  2572 	call to Start(). The panic is caused by a call to Stop() which is not
       
  2573 	matched by a corresponding call to Start().
       
  2574 	*/
       
  2575 	EReqTooManyStops=45,
       
  2576 
       
  2577 
       
  2578 	/**
       
  2579 	This panic is raised by an active scheduler, a CActiveScheduler.
       
  2580 	
       
  2581 	It is caused by a stray signal.
       
  2582 	*/
       
  2583 	EReqStrayEvent=46,
       
  2584 	
       
  2585 	
       
  2586 	/**
       
  2587 	This panic is raised by the Error() virtual member function of an active
       
  2588 	scheduler, a CActiveScheduler.
       
  2589 	
       
  2590 	This function is called when an active object’s RunL() function leaves.
       
  2591 	Applications always replace the Error() function in a class derived from
       
  2592 	CActiveScheduler; the default behaviour provided by CActiveScheduler raises
       
  2593 	this panic.
       
  2594 	*/
       
  2595 	EReqActiveObjectLeave=47,
       
  2596 	
       
  2597 	
       
  2598 	/**
       
  2599 	This panic is raised by the Add() member function of an active scheduler,
       
  2600 	a CActiveScheduler, when a NULL pointer is passed to the function.
       
  2601 	*/
       
  2602 	EReqNull=48,
       
  2603 
       
  2604 
       
  2605 	/**
       
  2606 	This panic is raised by the SetActive() and Deque() member functions of
       
  2607 	an active object, a CActive.
       
  2608 	
       
  2609 	It is raised if the active object has not been added to the active scheduler.
       
  2610 	*/
       
  2611 	EActiveNotAdded=49,
       
  2612 
       
  2613 
       
  2614 	/**
       
  2615 	This panic is raised by the SetPriority() member function of an active
       
  2616 	object, a CActive.
       
  2617 	
       
  2618 	It is caused by an attempt to change the priority of the active object 
       
  2619 	while it is active, i.e. while a request is outstanding).
       
  2620 	*/
       
  2621 	ESetPriorityActive=50,
       
  2622 
       
  2623 
       
  2624 	/**
       
  2625 	This panic is raised by the At(), After() and Lock() member functions of
       
  2626 	the CTimer active object.
       
  2627 	
       
  2628 	It is caused by an attempt to request a timer event when the CTimer active
       
  2629 	object has not been added to the active scheduler.
       
  2630 	*/
       
  2631 	ETimNotAdded=51,
       
  2632 
       
  2633 
       
  2634 	/**
       
  2635 	This panic is raised by the Start() member function of the periodic timer
       
  2636     active object, a CPeriodic, when a negative time interval is passed to
       
  2637     the function.
       
  2638 	*/
       
  2639 	ETimIntervalNegativeOrZero=52,
       
  2640 	
       
  2641 	
       
  2642 	/**
       
  2643 	This panic is raised by the Start() member function of the periodic 
       
  2644 	timer active object, a CPeriodic, when a negative delay time interval
       
  2645 	is passed to the function.
       
  2646 	*/
       
  2647 	ETimDelayNegative=53,
       
  2648 	
       
  2649 	
       
  2650 	/**
       
  2651 	Not used.
       
  2652 	*/
       
  2653 	EUnusedBasePanic1=54,  // Unused
       
  2654 
       
  2655 
       
  2656 	/**
       
  2657 	Not used.
       
  2658 	*/
       
  2659 	ESvrNoServerName=55,
       
  2660 	
       
  2661 	
       
  2662 	/**
       
  2663 	This panic is raised by the New() and NewL() member functions of
       
  2664 	CBitMapAllocator when a negative or zero size is passed to them.
       
  2665 	*/
       
  2666 	EBmaSizeLessOrEqualToZero=56,
       
  2667 	
       
  2668 	
       
  2669 	/**
       
  2670 	This panic is raised by the Free(TInt aPos) member function of
       
  2671 	CBitMapAllocator when a position value is passed which is out of bounds.
       
  2672 	*/
       
  2673 	EBmaFreeOutOfRange=57,
       
  2674 
       
  2675 
       
  2676 	/**
       
  2677 	This panic is raised by the IsFree(TInt aPos) member function of
       
  2678 	CBitMapAllocator when a position value is passed which is out of bounds.
       
  2679 	*/
       
  2680 	EBmaAllocOutOfRange=58,
       
  2681 	
       
  2682 	
       
  2683 	/**
       
  2684 	This panic is raised by the AllocFromTopFrom(TInt aPos) member function 
       
  2685 	of CBitMapAllocator when a position value is passed which is out of bounds.
       
  2686 	*/
       
  2687 	EBmaAllocFromTopFromOutOfRange=59,
       
  2688 
       
  2689 
       
  2690 	/**
       
  2691 	Not used.
       
  2692 	*/
       
  2693 	EBmaFreeTooMany=60,
       
  2694 	
       
  2695 	
       
  2696 	/**
       
  2697 	Not used.
       
  2698 	*/
       
  2699 	EBmaFreeNotAllocated=61,
       
  2700 	
       
  2701 	
       
  2702 	/**
       
  2703 	This panic is raised by the AllocAt() member function of CBitMapAllocator
       
  2704 	when the implied position has already been allocated.
       
  2705 	*/
       
  2706 	EBmaAllocAtAlreadyAllocated=62,
       
  2707 	
       
  2708 	
       
  2709 	/**
       
  2710 	This panic is raised as a result of a call to the Pop() and PopAndDestroy()
       
  2711 	static member functions of the CleanupStack class.
       
  2712 	
       
  2713 	The panic occurs when TRAPs have been nested and an attempt is made to pop too
       
  2714 	many items from the cleanup stack for the current nest level.
       
  2715 	*/
       
  2716 	EClnPopAcrossLevels=63,
       
  2717 
       
  2718 
       
  2719 	/**
       
  2720 	This panic is raised as a result of a call to the Pop() and PopAndDestroy()
       
  2721 	static member functions of the CleanupStack class.
       
  2722 	
       
  2723 	The panic occurs when attempt is made to pop more items from the cleanup
       
  2724 	stack than are on the cleanup stack.
       
  2725 	*/
       
  2726 	EClnPopUnderflow=64,
       
  2727 	
       
  2728 	
       
  2729 	/**
       
  2730 	The panic is raised as a result of a call to the Pop() and PopAndDestroy()
       
  2731 	static member functions of the CleanupStack class.
       
  2732 	
       
  2733 	The panic occurs when an attempt is made to pop more items from the cleanup
       
  2734 	stack than are on the cleanup stack.
       
  2735 	*/
       
  2736 	EClnLevelUnderflow=65,
       
  2737 
       
  2738 
       
  2739 	/**
       
  2740 	This panic is raised if an attempt is being made to insert a cleanup item
       
  2741 	into a position on the cleanup stack reserved for marking the current TRAP
       
  2742 	nest level.
       
  2743 	
       
  2744 	In practice this error occurs if the call to CleanupStack::PushL() happens
       
  2745 	when there has been no call to TRAP().
       
  2746 	*/
       
  2747 	EClnPushAtLevelZero=66,
       
  2748 	
       
  2749 	
       
  2750 	/**
       
  2751 	This panic is raised when building a TCleanupStackItem which is to be added
       
  2752 	to the cleanup stack.
       
  2753 	
       
  2754 	The building of the TCleanupStackItem needs a TCleanupItem and this has
       
  2755 	been constructed with a NULL cleanup operation (a TCleanupOperation).
       
  2756 	*/
       
  2757 	EClnNoCleanupOperation=67,
       
  2758 
       
  2759 
       
  2760 	/**
       
  2761 	This panic is raised if there are no free slots available on the cleanup
       
  2762 	stack to insert a cleanup item.
       
  2763 	*/
       
  2764 	EClnNoFreeSlotItem=68,
       
  2765 	
       
  2766 	
       
  2767 	/**
       
  2768 	This panic is raised if no trap handler has been installed.
       
  2769 	
       
  2770 	In practice, this occurs if CTrapCleanup::New() has not been called
       
  2771 	before using the cleanup stack.
       
  2772 	*/
       
  2773 	EClnNoTrapHandlerInstalled=69,
       
  2774 	
       
  2775 	
       
  2776 	/**
       
  2777 	This panic is raised as a result of a call to the versions of the
       
  2778 	Pop() and PopAndDestroy() static member functions of the CleanupStack class
       
  2779 	which take an explicit count of the items to be popped.
       
  2780 	
       
  2781 	The panic is caused by passing a negative value for the number of items
       
  2782 	to be popped.
       
  2783 	*/
       
  2784 	EClnPopCountNegative=70,
       
  2785 	
       
  2786 	
       
  2787 	/**
       
  2788 	This panic is raised when TRAPs have been nested and an attempt is made to
       
  2789 	exit from a TRAP nest level before all the cleanup items belonging to that
       
  2790 	level have been popped off the cleanup stack.
       
  2791 	*/
       
  2792 	EClnLevelNotEmpty=71,
       
  2793 
       
  2794 
       
  2795 	/**
       
  2796 	This panic is raised by the constructor of the circular buffer base class,
       
  2797 	a CCirBufBase, when the size value passed is zero or negative.
       
  2798 	*/
       
  2799 	ECircItemSizeNegativeOrZero=72,
       
  2800 
       
  2801 
       
  2802 	/**
       
  2803 	This panic is raised by a call to the SetLengthL() member function of 
       
  2804 	the circular buffer base class, a CCirBufBase, by passing a length
       
  2805 	value which is zero or negative.
       
  2806 	*/
       
  2807 	ECircSetLengthNegativeOrZero=73,
       
  2808 	
       
  2809 	
       
  2810 	/**
       
  2811 	This panic is raised by a call to the Add() member function of a 
       
  2812 	circular buffer, a CCirBuf when the pointer to the item
       
  2813 	to be added is NULL.
       
  2814 	*/
       
  2815 	ECircNoBufferAllocated=74,
       
  2816 	
       
  2817 	
       
  2818 	/**
       
  2819 	This panic is raised by a call to the Add() member function of a
       
  2820 	circular buffer, a CCirBuf when the number of items to be added
       
  2821 	is zero or negative.
       
  2822 	*/
       
  2823 	ECircAddCountNegative=75,
       
  2824 
       
  2825 
       
  2826 	/**
       
  2827 	This panic is raised by a call to the Remove() member function of
       
  2828 	a circular buffer, a CCirBuf when the number of items to be removed is zero
       
  2829 	or negative.
       
  2830 	*/
       
  2831 	ECircRemoveCountNegative=76,
       
  2832 
       
  2833 
       
  2834 	/**
       
  2835 	This panic is raise by CConsoleBase::Getch() when the asynchronous request
       
  2836 	that fetches the character completes with a completion code that
       
  2837 	is not KErrNone.
       
  2838 	*/
       
  2839 	EConsGetchFailed=77,
       
  2840 	
       
  2841 	
       
  2842 	/**
       
  2843 	Not used.
       
  2844 	*/
       
  2845 	ESecurityData=78,
       
  2846 	
       
  2847 	
       
  2848 	/**
       
  2849 	This panic is raised by the Alloc() member function 
       
  2850 	of CBitMapAllocator if the object is in an inconsistnt state.
       
  2851 	*/
       
  2852 	EBmaInconsistentState=79,
       
  2853 
       
  2854 
       
  2855 	/**
       
  2856 	This panic is raised by the AllocFrom() member function 
       
  2857 	of CBitMapAllocator if the position passed into it is outside its valid
       
  2858 	range, i.e. is negative or is greater than or equal to the size.
       
  2859 	*/
       
  2860 	EBmaAllocFromOutOfRange=80,
       
  2861 
       
  2862 
       
  2863 	/**
       
  2864 	This panic is raised by the Alloc() member function 
       
  2865 	of CBitMapAllocator if the count value passed into it
       
  2866 	is not positive.
       
  2867 	*/
       
  2868 	EBmaAllocCountNegative=81,
       
  2869 	
       
  2870 	
       
  2871 	/**
       
  2872 	This panic is raised by the AllocAligned() member function 
       
  2873 	of CBitMapAllocator if the alignment value passed into it
       
  2874 	is negative or greater than or equal to 32.
       
  2875 	*/
       
  2876 	EBmaAllAlgnOutOfRange=82,
       
  2877 
       
  2878 
       
  2879 	/**
       
  2880 	This panic is raised by the AllocAlignedBlock() member function 
       
  2881 	of CBitMapAllocator if the alignment value passed into it
       
  2882 	is negative or greater than or equal to 32.
       
  2883 	*/
       
  2884 	EBmaAllAlgnBOutOfRange=83,
       
  2885 	
       
  2886 	
       
  2887 	/**
       
  2888 	This panic is raised by the AllocAt() member function 
       
  2889 	of CBitMapAllocator if the position value passed into it
       
  2890 	is outside the permitted range.
       
  2891 	*/
       
  2892 	EBmaAllocBlkOutOfRange=84,
       
  2893 
       
  2894 
       
  2895 	/**
       
  2896 	This panic is raised by the IsFree() member function 
       
  2897 	of CBitMapAllocator if the position value passed into it
       
  2898 	is outside the permitted range.
       
  2899 	*/
       
  2900 	EBmaChkBlkOutOfRange=85,
       
  2901 
       
  2902 
       
  2903 	/**
       
  2904 	This panic is raised by the Free() member function 
       
  2905 	of CBitMapAllocator if the position value passed into it
       
  2906 	is outside the permitted range.
       
  2907 	*/
       
  2908 	EBmaFreeBlkOutOfRange=86,
       
  2909 
       
  2910 
       
  2911 	/**
       
  2912 	This panic is raised by the Free() member function 
       
  2913 	of CBitMapAllocator if attempting to free a block that is not allocated.
       
  2914 	*/
       
  2915 	EBmaFreeBlkNotAllocated=87,
       
  2916 
       
  2917 
       
  2918 	/**
       
  2919 	This panic is raised by the Free() member function 
       
  2920 	of CBitMapAllocator if attempting to allocate a block that is not free.
       
  2921 	*/
       
  2922 	EBmaAllocBlkNotFree=88,
       
  2923 
       
  2924 
       
  2925 	/**
       
  2926 	This panic is raised by call to the Replace() member function of 
       
  2927 	CActiveScheduler when the replacement active scheduler is the same as
       
  2928 	the existing active scheduler.
       
  2929 	*/
       
  2930 	EActiveSchedulerReplacingSelf=89,
       
  2931 	
       
  2932 	
       
  2933 	/**
       
  2934 	The panic is raised as a result of a call to the Pop() and PopAndDestroy()
       
  2935 	static member functions of the CleanupStack class.
       
  2936 	
       
  2937 	The panic occurs when an the item to be popped is not the expected item.
       
  2938 	*/
       
  2939 	EClnCheckFailed=90,
       
  2940 	
       
  2941 	
       
  2942 	/**
       
  2943 	This panic is raised by CActiveSchedulerWait::Start()
       
  2944     when the CActiveSchedulerWait has already been started.
       
  2945     
       
  2946     @see CActiveSchedulerWait
       
  2947 	*/
       
  2948 	EActiveSchedulerWaitAlreadyStarted=91,
       
  2949 	
       
  2950 	
       
  2951 	/** 
       
  2952 	This panic is raised by CActiveSchedulerWait::AsyncStop() and
       
  2953 	CActiveSchedulerWait::CanStopNow()
       
  2954 	when the CActiveSchedulerWait has not been started.
       
  2955 	*/
       
  2956 	EActiveSchedulerWaitNotStarted=92,
       
  2957 
       
  2958 
       
  2959 	/**
       
  2960 	This panic is raised during construction of a CAsyncOneShot if the attempt
       
  2961 	to open a handle to the current thread fails.
       
  2962 	*/
       
  2963 	EAsyncOneShotSetupFailed=93,
       
  2964 	
       
  2965 	
       
  2966 	/**
       
  2967 	Not used.
       
  2968 	*/
       
  2969 	ESvrBadSecurityPolicy=94,
       
  2970 
       
  2971 
       
  2972 	/**
       
  2973 	This panic is raised if CPolicyServer::CustomSecurityCheckL(),
       
  2974 	or CPolicyServer::CustomFailureActionL() are called.
       
  2975 	
       
  2976 	Odds are that you forgot to implement one of these two functions in your
       
  2977 	CPolicyServer derived Server.
       
  2978 	*/
       
  2979 	EPolSvrCallingBaseImplementation=95,
       
  2980 
       
  2981 
       
  2982 	/**
       
  2983 	This panic is raised in debug builds by the CPolicyServer constructor if
       
  2984 	TPolicy::iRanges[0] does not have a value of 0.
       
  2985 	*/
       
  2986 	EPolSvr1stRangeNotZero=96,
       
  2987 
       
  2988 
       
  2989 	/**
       
  2990 	This panic is raised in debug builds by the CPolicyServer constructor if
       
  2991 	each element of TPolicy::iRanges is not greater than the previous.
       
  2992 	*/
       
  2993 	EPolSvrRangesNotIncreasing=97,
       
  2994 
       
  2995 
       
  2996 	/**
       
  2997 	This panic is raised in debug builds by the CPolicyServer constructor
       
  2998 	unless every element in TPolicy::iElementsIndex is valid.  Every element,
       
  2999 	x, must not be one of (ESpecialCaseHardLimit <= x <= ESpecialCaseLimit) in
       
  3000 	order to be valid.  See CPolicyServer::TSpecialCase for more information.
       
  3001 	*/
       
  3002 	EPolSvrElementsIndexValueInvalid=98,
       
  3003 
       
  3004 
       
  3005 	/**
       
  3006 	This panic is raised in debug builds by the CPolicyServer constructor if
       
  3007 	TPolicy::iOnConnect has an invalid value. iOnConnect must not be one of
       
  3008 	(ESpecialCaseHardLimit <= x <= ESpecialCaseLimit) in order to be valid.
       
  3009 	See CPolicyServer::TSpecialCase for more information.
       
  3010 	*/
       
  3011 	EPolSvrIOnConnectValueInvalid=99,
       
  3012 	
       
  3013 
       
  3014 	/**
       
  3015 	This panic is raised if CPolicyServer::iPolicy is found to be invalid for
       
  3016 	an unkown reason.  There is a good chance that your policy would cause the
       
  3017 	server to panic with one of the above specific policy panic codes if you
       
  3018 	run it in debug mode.  See the policy server documentation for a
       
  3019 	description of a valid policy.
       
  3020 	*/
       
  3021 	EPolSvrPolicyInvalid=100,
       
  3022 
       
  3023 
       
  3024 	/**
       
  3025 	The value returned from CustomSecurityCheckL or CustomFailureActionL was
       
  3026 	invalid.  See CPolicyServer::TCustomResult for a list of valid results.
       
  3027 	*/
       
  3028 	EPolSvrInvalidCustomResult=101,
       
  3029 
       
  3030 
       
  3031 	/**
       
  3032 	This panic is raised in debug builds by the CPolicyServer constructor if
       
  3033 	TPolicy.iRangeCount is not greater than 0.  All policies given to the
       
  3034 	policy server must contain at least 1 policy. 
       
  3035 	*/
       
  3036 	EPolSvrIRangeCountInvalid=102,
       
  3037 
       
  3038 
       
  3039 	/**
       
  3040 	This panic is raised by the policy server framework if a message fails a
       
  3041 	policy check (custom or not) and the associated action is EPanicClient.
       
  3042 	*/
       
  3043 	EPolSvrActionPanicClient=103,
       
  3044 
       
  3045 	/**
       
  3046 	This panic is raised by CObjectIx class methods if inconsistent data condition occurs
       
  3047 	It can appear in debug build only.
       
  3048 	*/
       
  3049 	EObjInconsistent=104,
       
  3050 	
       
  3051 	/**
       
  3052 	This panic is raised as a result of a call to the Pop() and PopAndDestroy()
       
  3053 	static member functions of the CleanupStack class.
       
  3054 	
       
  3055 	The panic occurs when the cleanup operation of a popped item modifies the 
       
  3056 	cleanup stack. In such a case, the function cannot guarantee that the correct 
       
  3057 	items will be popped.
       
  3058 	*/
       
  3059 	EClnStackModified=105,
       
  3060 
       
  3061 	/**
       
  3062 	This panic is raised as a result of a call to CServer2::SetPinClientDescriptors() after
       
  3063 	CServer2::Start() has been invoked on a CServer2 object.
       
  3064 	*/
       
  3065 	ECServer2InvalidSetPin = 106,
       
  3066     };
       
  3067 
       
  3068 #endif