|
1 // Copyright (c) 1994-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\e32cmn.h |
|
15 // |
|
16 // |
|
17 |
|
18 #ifndef __E32CMN_H__ |
|
19 #define __E32CMN_H__ |
|
20 #include <e32const.h> |
|
21 |
|
22 extern "C" { |
|
23 /** |
|
24 @publishedAll |
|
25 @released |
|
26 |
|
27 A Nanokernel utility function that compares two memory buffers for equality. |
|
28 |
|
29 The two buffers are considered equal only if: |
|
30 |
|
31 1. the buffers have the same length |
|
32 |
|
33 and |
|
34 |
|
35 2. the binary content of both buffers is the same. |
|
36 |
|
37 @param aLeft The start address of the first buffer in the comparison. |
|
38 @param aLeftLen The length of the first buffer in the comparison. |
|
39 @param aRight The start address of the second buffer in the comparison. |
|
40 @param aRightLen The length of the second buffer in the comparison. |
|
41 |
|
42 @return Zero if both buffers are equal; non-zero, otherwise. |
|
43 |
|
44 @panic USER 88 In debug mode only, if aLeftL is negative, |
|
45 and the function is called on the user side. |
|
46 @panic KERN-COMMON 88 In debug mode only, if aLeftL is negative, |
|
47 and the function is called on the kernel side. |
|
48 @panic USER 89 In debug mode only, if aRightL is negative, |
|
49 and the function is called on the user side. |
|
50 @panic KERN-COMMON 89 In debug mode only, if aRightL is negative, |
|
51 and the function is called on the kernel side. |
|
52 */ |
|
53 IMPORT_C TInt memcompare(const TUint8* aLeft, TInt aLeftLen, const TUint8* aRight, TInt aRightLen); |
|
54 |
|
55 |
|
56 |
|
57 |
|
58 /** |
|
59 @publishedAll |
|
60 @released |
|
61 |
|
62 A Nanokernel utility function that moves (copies) bytes in memory. |
|
63 |
|
64 The function assumes that the addresses are aligned on word boundaries, |
|
65 and that the length value is a multiple of 4. |
|
66 |
|
67 @param aTrg The target address. |
|
68 @param aSrc The source address. |
|
69 @param aLength The number of bytes to be moved. |
|
70 |
|
71 @return The target address. |
|
72 |
|
73 @panic USER 91 In debug mode only, if aLength is not a multiple of 4, |
|
74 and the function is called on the user side. |
|
75 @panic KERN-COMMON 91 In debug mode only, if aLength is not a multiple of 4, |
|
76 and the function is called on the kernel side. |
|
77 @panic USER 92 In debug mode only, if aSrc is not aligned on a word boundary, |
|
78 and the function is called on the user side. |
|
79 @panic KERN-COMMON 92 In debug mode only, if aSrc is not aligned on a word boundary, |
|
80 and the function is called on the kernel side. |
|
81 @panic USER 93 In debug mode only, if aTrg is not aligned on a word boundary, |
|
82 and the function is called on the user side. |
|
83 @panic KERN-COMMON 93 In debug mode only, if aTrg is not aligned on a word boundary, |
|
84 and the function is called on the kernel side. |
|
85 */ |
|
86 IMPORT_C TAny* wordmove(TAny* aTrg, const TAny* aSrc, unsigned int aLength); |
|
87 |
|
88 |
|
89 |
|
90 |
|
91 /** |
|
92 @publishedAll |
|
93 @released |
|
94 |
|
95 A Nanokernel utility function that sets the specified number of bytes |
|
96 to binary zero. |
|
97 |
|
98 @param aTrg The start address. |
|
99 @param aLength The number of bytes to be set. |
|
100 |
|
101 @return The target address. |
|
102 */ |
|
103 IMPORT_C TAny* memclr(TAny* aTrg, unsigned int aLength); |
|
104 } |
|
105 |
|
106 |
|
107 |
|
108 |
|
109 #ifndef __TOOLS__ |
|
110 extern "C" { |
|
111 /** |
|
112 @publishedAll |
|
113 @released |
|
114 |
|
115 A Nanokernel utility function that sets all of the specified number of bytes to |
|
116 the specified fill value. |
|
117 |
|
118 @param aTrg The start address. |
|
119 @param aValue The fill value (the first or junior byte). |
|
120 @param aLength The number of bytes to be set. |
|
121 |
|
122 @return The target address. |
|
123 */ |
|
124 IMPORT_C TAny* memset(TAny* aTrg, TInt aValue, unsigned int aLength); |
|
125 |
|
126 |
|
127 |
|
128 |
|
129 /** |
|
130 @publishedAll |
|
131 @released |
|
132 |
|
133 A Nanokernel utility function that copies bytes in memory. |
|
134 |
|
135 @param aTrg The target address. |
|
136 @param aSrc The source address. |
|
137 @param aLength The number of bytes to be moved. |
|
138 |
|
139 @return The target address. |
|
140 */ |
|
141 IMPORT_C TAny* memcpy(TAny* aTrg, const TAny* aSrc, unsigned int aLength); |
|
142 |
|
143 |
|
144 |
|
145 |
|
146 /** |
|
147 @publishedAll |
|
148 @released |
|
149 |
|
150 A Nanokernel utility function that moves (copies) bytes in memory. |
|
151 |
|
152 @param aTrg The target address. |
|
153 @param aSrc The source address. |
|
154 @param aLength The number of bytes to be moved. |
|
155 |
|
156 @return The target address. |
|
157 */ |
|
158 IMPORT_C TAny* memmove(TAny* aTrg, const TAny* aSrc, unsigned int aLength); |
|
159 } |
|
160 #else |
|
161 #include <string.h> |
|
162 #endif |
|
163 |
|
164 |
|
165 |
|
166 |
|
167 /** |
|
168 @publishedAll |
|
169 @released |
|
170 |
|
171 Tests whether the specified value is less than or equal to the |
|
172 specified upper limit. |
|
173 |
|
174 @param aVal The value to be tested. |
|
175 @param aLimit The upper limit. |
|
176 |
|
177 @return True, if the value is less than or equal to the specified upper limit; |
|
178 false, otherwise. |
|
179 */ |
|
180 inline TInt Lim(TInt aVal,TUint aLimit) |
|
181 {return(((TUint)aVal)<=aLimit);} |
|
182 |
|
183 |
|
184 |
|
185 |
|
186 /** |
|
187 @publishedAll |
|
188 @released |
|
189 |
|
190 Tests whether the specified value is strictly less than the |
|
191 specified upper limit. |
|
192 |
|
193 @param aVal The value to be tested. |
|
194 @param aLimit The upper limit. |
|
195 |
|
196 @return True, if the value is strictly less than the specified upper limit; |
|
197 false, otherwise. |
|
198 */ |
|
199 inline TInt LimX(TInt aVal,TUint aLimit) |
|
200 {return(((TUint)aVal)<aLimit);} |
|
201 |
|
202 |
|
203 |
|
204 |
|
205 /** |
|
206 @publishedAll |
|
207 @released |
|
208 |
|
209 Returns the smaller of two values. |
|
210 |
|
211 @param aLeft The first value to be compared. |
|
212 @param aRight The second value to be compared. |
|
213 |
|
214 @return The smaller value. |
|
215 */ |
|
216 template <class T> |
|
217 inline T Min(T aLeft,T aRight) |
|
218 {return(aLeft<aRight ? aLeft : aRight);} |
|
219 |
|
220 |
|
221 |
|
222 |
|
223 /** |
|
224 @publishedAll |
|
225 @released |
|
226 |
|
227 Returns the smaller of two objects, where the right hand object is a treated |
|
228 as a TInt for the purpose of comparison. |
|
229 |
|
230 @param aLeft The first value to be compared. |
|
231 @param aRight The second value to be compared. |
|
232 |
|
233 @return The smaller value. |
|
234 */ |
|
235 template <class T> |
|
236 inline T Min(T aLeft,TUint aRight) |
|
237 {return(aLeft<(TInt)aRight ? aLeft : (T)aRight);} |
|
238 |
|
239 |
|
240 |
|
241 |
|
242 /** |
|
243 @publishedAll |
|
244 @released |
|
245 |
|
246 Returns the larger of two values. |
|
247 |
|
248 @param aLeft The first value to be compared. |
|
249 @param aRight The second value to be compared. |
|
250 |
|
251 @return The larger value. |
|
252 */ |
|
253 template <class T> |
|
254 inline T Max(T aLeft,T aRight) |
|
255 {return(aLeft<aRight ? aRight : aLeft);} |
|
256 |
|
257 |
|
258 |
|
259 |
|
260 /** |
|
261 @publishedAll |
|
262 @released |
|
263 |
|
264 Returns the larger of two objects, where the right hand object is a treated |
|
265 as a TInt for the purpose of comparison. |
|
266 |
|
267 @param aLeft The first value to be compared. |
|
268 @param aRight The second value to be compared. |
|
269 |
|
270 @return The larger value. |
|
271 */ |
|
272 template <class T> |
|
273 inline T Max(T aLeft,TUint aRight) |
|
274 {return(aLeft<(TInt)aRight ? (TInt)aRight : aLeft);} |
|
275 |
|
276 |
|
277 |
|
278 |
|
279 /** |
|
280 @publishedAll |
|
281 @released |
|
282 |
|
283 Returns an absolute value. |
|
284 |
|
285 @param aVal The source value. |
|
286 |
|
287 @return The absolute value |
|
288 */ |
|
289 template <class T> |
|
290 inline T Abs(T aVal) |
|
291 {return(aVal<0 ? -aVal : aVal);} |
|
292 |
|
293 |
|
294 |
|
295 |
|
296 /** |
|
297 @publishedAll |
|
298 @released |
|
299 |
|
300 Determines whether a specified value lies within a defined range of values. |
|
301 |
|
302 @param aMin The lower value of the range. |
|
303 @param aVal The value to be compared. |
|
304 @param aMax The higher value of the range. |
|
305 |
|
306 @return True, if the specified value lies within the range; false, otherwise. |
|
307 */ |
|
308 template <class T> |
|
309 inline TBool Rng(T aMin,T aVal,T aMax) |
|
310 {return(aVal>=aMin && aVal<=aMax);} |
|
311 |
|
312 |
|
313 |
|
314 |
|
315 /** |
|
316 @publishedAll |
|
317 @released |
|
318 |
|
319 Adds a value to a pointer. |
|
320 |
|
321 @param aPtr Pointer to an object of type T. |
|
322 @param aVal The value to be added. |
|
323 |
|
324 @return The resulting pointer value, as a pointer to a type T. |
|
325 */ |
|
326 template <class T,class S> |
|
327 inline T* PtrAdd(T* aPtr,S aVal) |
|
328 {return((T*)(((TUint8*)aPtr)+aVal));} |
|
329 |
|
330 |
|
331 |
|
332 |
|
333 /** |
|
334 @publishedAll |
|
335 @released |
|
336 |
|
337 Subtracts a value from a pointer. |
|
338 |
|
339 @param aPtr Pointer to an object of type T. |
|
340 @param aVal The value to be added. |
|
341 |
|
342 @return The resulting pointer value, as a pointer to a type T. |
|
343 */ |
|
344 template <class T,class S> |
|
345 inline T* PtrSub(T* aPtr,S aVal) |
|
346 {return((T*)(((TUint8*)aPtr)-aVal));} |
|
347 |
|
348 |
|
349 |
|
350 |
|
351 /** |
|
352 @publishedAll |
|
353 @released |
|
354 |
|
355 Aligns the specified value onto a 2-byte boundary. |
|
356 |
|
357 @param aValue The value to be aligned. |
|
358 |
|
359 @return The aligned value. |
|
360 */ |
|
361 template <class T> |
|
362 inline T Align2(T aValue) |
|
363 {return((T)((((TUint)aValue)+sizeof(TUint16)-1)&~(sizeof(TUint16)-1)));} |
|
364 |
|
365 |
|
366 |
|
367 |
|
368 /** |
|
369 @publishedAll |
|
370 @released |
|
371 |
|
372 Aligns the specified value onto a 4-byte boundary. |
|
373 |
|
374 @param aValue The value to be aligned. |
|
375 |
|
376 @return The aligned value. |
|
377 */ |
|
378 template <class T> |
|
379 inline T Align4(T aValue) |
|
380 {return((T)((((TUint)aValue)+sizeof(TUint32)-1)&~(sizeof(TUint32)-1)));} |
|
381 |
|
382 |
|
383 |
|
384 |
|
385 /** |
|
386 @publishedAll |
|
387 @released |
|
388 |
|
389 A templated class which encapsulates a reference to an object within a wrapper. |
|
390 |
|
391 The wrapper object can be passed to a function as a value type. This allows |
|
392 a reference to be passed to a function as a value type. |
|
393 |
|
394 This wrapper object is commonly termed a value reference. |
|
395 */ |
|
396 template <class T> |
|
397 class TRefByValue |
|
398 { |
|
399 public: |
|
400 inline TRefByValue(T& aRef); |
|
401 inline operator T&(); |
|
402 private: |
|
403 TRefByValue& operator=(TRefByValue aRef); |
|
404 private: |
|
405 T &iRef; |
|
406 }; |
|
407 |
|
408 |
|
409 |
|
410 |
|
411 #if !defined (__KERNEL_MODE__) |
|
412 class TDesC16; // forward declaration for TChar member functions |
|
413 class TPtrC16; // forward declaration for TChar member functions |
|
414 #endif |
|
415 |
|
416 |
|
417 |
|
418 |
|
419 /** |
|
420 @publishedAll |
|
421 @released |
|
422 |
|
423 Holds a character value and provides a number of utility functions to |
|
424 manipulate it and test its properties. |
|
425 |
|
426 For example, there are functions to convert the character |
|
427 to uppercase and test whether or not it is a control character. |
|
428 |
|
429 The character value is stored as a 32-bit unsigned integer. The shorthand |
|
430 "TChar value" is used to describe the character value wrapped by a TChar |
|
431 object. |
|
432 |
|
433 TChar can be used to represent Unicode values outside plane 0 (that is, the |
|
434 extended Unicode range from 0x10000 to 0xFFFFF). This differentiates it from |
|
435 TText which can only be used for 16-bit Unicode character values. |
|
436 |
|
437 @see TText |
|
438 */ |
|
439 class TChar |
|
440 { |
|
441 public: |
|
442 |
|
443 |
|
444 /** |
|
445 General Unicode character category. |
|
446 |
|
447 The high nibble encodes the major category (Mark, Number, etc.) and a low |
|
448 nibble encodes the subdivisions of that category. |
|
449 |
|
450 The category codes can be used in three ways: |
|
451 |
|
452 (i) as unique constants: there is one for each Unicode category, with a |
|
453 name of the form |
|
454 @code |
|
455 E<XX>Category |
|
456 @endcode |
|
457 where |
|
458 @code |
|
459 <XX> |
|
460 @endcode |
|
461 is the category name given by |
|
462 the Unicode database (e.g., the constant ELuCategory is used for lowercase |
|
463 letters, category Lu); |
|
464 |
|
465 (ii) as numbers in certain ranges: letter categories are all <= EMaxLetterCategory; |
|
466 |
|
467 (iii) as codes in which the upper nibble gives the category group |
|
468 (e.g., punctuation categories all yield TRUE for |
|
469 the test (category & 0xF0) ==EPunctuationGroup). |
|
470 */ |
|
471 enum TCategory |
|
472 { |
|
473 /** |
|
474 Alphabetic letters. |
|
475 |
|
476 Includes ELuCategory, ELlCategory and ELtCategory. |
|
477 */ |
|
478 EAlphaGroup = 0x00, |
|
479 |
|
480 |
|
481 /** |
|
482 Other letters. |
|
483 |
|
484 Includes ELoCategory. |
|
485 */ |
|
486 ELetterOtherGroup = 0x10, |
|
487 |
|
488 |
|
489 /** |
|
490 Letter modifiers. |
|
491 |
|
492 Includes ELmCategory. |
|
493 */ |
|
494 ELetterModifierGroup = 0x20, |
|
495 |
|
496 |
|
497 /** |
|
498 Marks group. |
|
499 |
|
500 Includes EMnCategory, EMcCategory and EMeCategory. |
|
501 */ |
|
502 EMarkGroup = 0x30, |
|
503 |
|
504 |
|
505 /** |
|
506 Numbers group. |
|
507 |
|
508 Includes ENdCategory, ENlCategory and ENoCategory. |
|
509 */ |
|
510 ENumberGroup = 0x40, |
|
511 |
|
512 |
|
513 /** |
|
514 Punctuation group. |
|
515 |
|
516 IncludesEPcCategory, PdCategory, EpeCategory, EPsCategory and EPoCategory. |
|
517 */ |
|
518 EPunctuationGroup = 0x50, |
|
519 |
|
520 |
|
521 /** |
|
522 Symbols group. |
|
523 |
|
524 Includes ESmCategory, EScCategory, ESkCategory and ESoCategory. |
|
525 */ |
|
526 ESymbolGroup = 0x60, |
|
527 |
|
528 |
|
529 /** |
|
530 Separators group. |
|
531 |
|
532 Includes EZsCategory, EZlCategory and EZlpCategory. |
|
533 */ |
|
534 ESeparatorGroup = 0x70, |
|
535 |
|
536 |
|
537 /** |
|
538 Control, format, private use, unassigned. |
|
539 |
|
540 Includes ECcCategory, ECtCategory, ECsCategory, |
|
541 ECoCategory and ECnCategory. |
|
542 */ |
|
543 EControlGroup = 0x80, |
|
544 |
|
545 |
|
546 /** |
|
547 The highest possible groups category. |
|
548 */ |
|
549 EMaxAssignedGroup = 0xE0, |
|
550 |
|
551 |
|
552 /** |
|
553 Unassigned to any other group. |
|
554 */ |
|
555 EUnassignedGroup = 0xF0, |
|
556 |
|
557 |
|
558 /** |
|
559 Letter, Uppercase. |
|
560 */ |
|
561 ELuCategory = EAlphaGroup | 0, |
|
562 |
|
563 |
|
564 /** |
|
565 Letter, Lowercase. |
|
566 */ |
|
567 ELlCategory = EAlphaGroup | 1, |
|
568 |
|
569 |
|
570 /** |
|
571 Letter, Titlecase. |
|
572 */ |
|
573 ELtCategory = EAlphaGroup | 2, |
|
574 |
|
575 |
|
576 /** |
|
577 Letter, Other. |
|
578 */ |
|
579 ELoCategory = ELetterOtherGroup | 0, |
|
580 |
|
581 |
|
582 /** |
|
583 The highest possible (non-modifier) letter category. |
|
584 */ |
|
585 EMaxLetterCategory = ELetterOtherGroup | 0x0F, |
|
586 |
|
587 /** |
|
588 Letter, Modifier. |
|
589 */ |
|
590 ELmCategory = ELetterModifierGroup | 0, |
|
591 |
|
592 |
|
593 /** |
|
594 The highest possible letter category. |
|
595 */ |
|
596 EMaxLetterOrLetterModifierCategory = ELetterModifierGroup | 0x0F, |
|
597 |
|
598 /** |
|
599 Mark, Non-Spacing |
|
600 */ |
|
601 EMnCategory = EMarkGroup | 0, |
|
602 |
|
603 |
|
604 /** |
|
605 Mark, Combining. |
|
606 */ |
|
607 EMcCategory = EMarkGroup | 1, |
|
608 |
|
609 |
|
610 /** |
|
611 Mark, Enclosing. |
|
612 */ |
|
613 EMeCategory = EMarkGroup | 2, |
|
614 |
|
615 |
|
616 /** |
|
617 Number, Decimal Digit. |
|
618 */ |
|
619 ENdCategory = ENumberGroup | 0, |
|
620 |
|
621 |
|
622 /** |
|
623 Number, Letter. |
|
624 */ |
|
625 ENlCategory = ENumberGroup | 1, |
|
626 |
|
627 |
|
628 /** |
|
629 Number, Other. |
|
630 */ |
|
631 ENoCategory = ENumberGroup | 2, |
|
632 |
|
633 |
|
634 /** |
|
635 Punctuation, Connector. |
|
636 */ |
|
637 EPcCategory = EPunctuationGroup | 0, |
|
638 |
|
639 |
|
640 /** |
|
641 Punctuation, Dash. |
|
642 */ |
|
643 EPdCategory = EPunctuationGroup | 1, |
|
644 |
|
645 |
|
646 /** |
|
647 Punctuation, Open. |
|
648 */ |
|
649 EPsCategory = EPunctuationGroup | 2, |
|
650 |
|
651 |
|
652 /** |
|
653 Punctuation, Close. |
|
654 */ |
|
655 EPeCategory = EPunctuationGroup | 3, |
|
656 |
|
657 |
|
658 /** |
|
659 Punctuation, Initial Quote |
|
660 */ |
|
661 EPiCategory = EPunctuationGroup | 4, |
|
662 |
|
663 |
|
664 /** |
|
665 Punctuation, Final Quote |
|
666 */ |
|
667 EPfCategory = EPunctuationGroup | 5, |
|
668 |
|
669 |
|
670 /** |
|
671 Punctuation, Other. |
|
672 */ |
|
673 EPoCategory = EPunctuationGroup | 6, |
|
674 |
|
675 |
|
676 /** |
|
677 Symbol, Math. |
|
678 */ |
|
679 ESmCategory = ESymbolGroup | 0, |
|
680 |
|
681 |
|
682 /** |
|
683 Symbol, Currency. |
|
684 */ |
|
685 EScCategory = ESymbolGroup | 1, |
|
686 |
|
687 |
|
688 /** |
|
689 Symbol, Modifier. |
|
690 */ |
|
691 ESkCategory = ESymbolGroup | 2, |
|
692 |
|
693 |
|
694 /** |
|
695 Symbol, Other. |
|
696 */ |
|
697 ESoCategory = ESymbolGroup | 3, |
|
698 |
|
699 |
|
700 /** |
|
701 The highest possible graphic character category. |
|
702 */ |
|
703 EMaxGraphicCategory = ESymbolGroup | 0x0F, |
|
704 |
|
705 |
|
706 /** |
|
707 Separator, Space. |
|
708 */ |
|
709 EZsCategory = ESeparatorGroup | 0, |
|
710 |
|
711 |
|
712 /** |
|
713 The highest possible printable character category. |
|
714 */ |
|
715 EMaxPrintableCategory = EZsCategory, |
|
716 |
|
717 |
|
718 /** |
|
719 Separator, Line. |
|
720 */ |
|
721 EZlCategory = ESeparatorGroup | 1, |
|
722 |
|
723 |
|
724 /** |
|
725 Separator, Paragraph. |
|
726 */ |
|
727 EZpCategory = ESeparatorGroup | 2, |
|
728 |
|
729 |
|
730 /** |
|
731 Other, Control. |
|
732 */ |
|
733 ECcCategory = EControlGroup | 0, |
|
734 |
|
735 |
|
736 /** |
|
737 Other, Format. |
|
738 */ |
|
739 ECfCategory = EControlGroup | 1, |
|
740 |
|
741 |
|
742 /** |
|
743 The highest possible category for assigned 16-bit characters; does not |
|
744 include surrogates, which are interpreted as pairs and have no meaning |
|
745 on their own. |
|
746 */ |
|
747 EMaxAssignedCategory = EMaxAssignedGroup | 0x0F, |
|
748 |
|
749 |
|
750 /** |
|
751 Other, Surrogate. |
|
752 */ |
|
753 ECsCategory = EUnassignedGroup | 0, |
|
754 |
|
755 |
|
756 /** |
|
757 Other, Private Use. |
|
758 */ |
|
759 ECoCategory = EUnassignedGroup | 1, |
|
760 |
|
761 |
|
762 /** |
|
763 Other, Not Assigned. |
|
764 */ |
|
765 ECnCategory = EUnassignedGroup | 2 |
|
766 }; |
|
767 |
|
768 |
|
769 /** |
|
770 The bi-directional Unicode character category. |
|
771 |
|
772 For more information on the bi-directional algorithm, see Unicode Technical |
|
773 Report No. 9 available at: http://www.unicode.org/unicode/reports/tr9. |
|
774 */ |
|
775 enum TBdCategory |
|
776 { |
|
777 /** |
|
778 Left to right. |
|
779 */ |
|
780 ELeftToRight, // L Left-to-Right |
|
781 |
|
782 |
|
783 /** |
|
784 Left to right embedding. |
|
785 */ |
|
786 ELeftToRightEmbedding, // LRE Left-to-Right Embedding |
|
787 |
|
788 |
|
789 /** |
|
790 Left-to-Right Override. |
|
791 */ |
|
792 ELeftToRightOverride, // LRO Left-to-Right Override |
|
793 |
|
794 |
|
795 /** |
|
796 Right to left. |
|
797 */ |
|
798 ERightToLeft, // R Right-to-Left |
|
799 |
|
800 |
|
801 /** |
|
802 Right to left Arabic. |
|
803 */ |
|
804 ERightToLeftArabic, // AL Right-to-Left Arabic |
|
805 |
|
806 |
|
807 /** |
|
808 Right to left embedding. |
|
809 */ |
|
810 ERightToLeftEmbedding, // RLE Right-to-Left Embedding |
|
811 |
|
812 |
|
813 /** |
|
814 Right-to-Left Override. |
|
815 */ |
|
816 ERightToLeftOverride, // RLO Right-to-Left Override |
|
817 |
|
818 |
|
819 /** |
|
820 Pop Directional Format. |
|
821 */ |
|
822 EPopDirectionalFormat, // PDF Pop Directional Format |
|
823 |
|
824 |
|
825 /** |
|
826 European number. |
|
827 */ |
|
828 EEuropeanNumber, // EN European Number |
|
829 |
|
830 |
|
831 /** |
|
832 European number separator. |
|
833 */ |
|
834 EEuropeanNumberSeparator, // ES European Number Separator |
|
835 |
|
836 |
|
837 /** |
|
838 European number terminator. |
|
839 */ |
|
840 EEuropeanNumberTerminator, // ET European Number Terminator |
|
841 |
|
842 |
|
843 /** |
|
844 Arabic number. |
|
845 */ |
|
846 EArabicNumber, // AN Arabic Number |
|
847 |
|
848 |
|
849 /** |
|
850 Common number separator. |
|
851 */ |
|
852 ECommonNumberSeparator, // CS Common Number Separator |
|
853 |
|
854 |
|
855 /** |
|
856 Non Spacing Mark. |
|
857 */ |
|
858 ENonSpacingMark, // NSM Non-Spacing Mark |
|
859 |
|
860 |
|
861 /** |
|
862 Boundary Neutral. |
|
863 */ |
|
864 EBoundaryNeutral, // BN Boundary Neutral |
|
865 |
|
866 |
|
867 /** |
|
868 Paragraph Separator. |
|
869 */ |
|
870 EParagraphSeparator, // B Paragraph Separator |
|
871 |
|
872 |
|
873 /** |
|
874 Segment separator. |
|
875 */ |
|
876 ESegmentSeparator, // S Segment Separator |
|
877 |
|
878 |
|
879 /** |
|
880 Whitespace |
|
881 */ |
|
882 EWhitespace, // WS Whitespace |
|
883 |
|
884 |
|
885 /** |
|
886 Other neutrals; all other characters: punctuation, symbols. |
|
887 */ |
|
888 EOtherNeutral // ON Other Neutrals |
|
889 }; |
|
890 |
|
891 |
|
892 /** |
|
893 Notional character width as known to East Asian (Chinese, Japanese, |
|
894 Korean (CJK)) coding systems. |
|
895 */ |
|
896 enum TCjkWidth |
|
897 { |
|
898 /** |
|
899 Includes 'ambiguous width' defined in Unicode Technical Report 11: East Asian Width |
|
900 */ |
|
901 ENeutralWidth, |
|
902 |
|
903 |
|
904 /** |
|
905 Character which occupies a single cell. |
|
906 */ |
|
907 EHalfWidth, // other categories are as defined in the report |
|
908 |
|
909 |
|
910 /** |
|
911 Character which occupies 2 cells. |
|
912 */ |
|
913 EFullWidth, |
|
914 |
|
915 |
|
916 /** |
|
917 Characters that are always narrow and have explicit full-width |
|
918 counterparts. All of ASCII is an example of East Asian Narrow |
|
919 characters. |
|
920 */ |
|
921 ENarrow, |
|
922 |
|
923 /** |
|
924 Characters that are always wide. This category includes characters that |
|
925 have explicit half-width counterparts. |
|
926 */ |
|
927 EWide |
|
928 }; |
|
929 |
|
930 |
|
931 /** |
|
932 @deprecated |
|
933 |
|
934 Encoding systems used by the translation functions. |
|
935 */ |
|
936 enum TEncoding |
|
937 { |
|
938 /** |
|
939 The Unicode encoding. |
|
940 */ |
|
941 EUnicode, |
|
942 |
|
943 |
|
944 /** |
|
945 The shift-JIS encoding (used in Japan). |
|
946 */ |
|
947 EShiftJIS |
|
948 }; |
|
949 |
|
950 |
|
951 /** |
|
952 Flags defining operations to be performed using TChar::Fold(). |
|
953 |
|
954 The flag values are passed to the Fold() funtion. |
|
955 |
|
956 @see TChar::Fold |
|
957 */ |
|
958 enum |
|
959 { |
|
960 /** |
|
961 Convert characters to their lower case form if any. |
|
962 */ |
|
963 EFoldCase = 1, |
|
964 |
|
965 |
|
966 /** |
|
967 Strip accents |
|
968 */ |
|
969 EFoldAccents = 2, |
|
970 |
|
971 |
|
972 /** |
|
973 Convert digits representing values 0..9 to characters '0'..'9' |
|
974 */ |
|
975 EFoldDigits = 4, |
|
976 |
|
977 |
|
978 /** |
|
979 Convert all spaces (ordinary, fixed-width, ideographic, etc.) to ' ' |
|
980 */ |
|
981 EFoldSpaces = 8, |
|
982 |
|
983 |
|
984 /** |
|
985 Convert hiragana to katakana. |
|
986 */ |
|
987 EFoldKana = 16, |
|
988 |
|
989 |
|
990 /** |
|
991 Fold fullwidth and halfwidth variants to their standard forms |
|
992 */ |
|
993 EFoldWidth = 32, |
|
994 |
|
995 |
|
996 /** |
|
997 Perform standard folding operations, i.e.those done by Fold() with no argument |
|
998 */ |
|
999 EFoldStandard = EFoldCase | EFoldAccents | EFoldDigits | EFoldSpaces, |
|
1000 |
|
1001 |
|
1002 /** |
|
1003 Perform all possible folding operations |
|
1004 */ |
|
1005 EFoldAll = -1 |
|
1006 }; |
|
1007 |
|
1008 |
|
1009 struct TCharInfo |
|
1010 /** |
|
1011 A structure to hold information about a Unicode character. |
|
1012 |
|
1013 An object of this type is passed to TChar::GetInfo(). |
|
1014 |
|
1015 @see TChar::GetInfo |
|
1016 */ |
|
1017 { |
|
1018 /** |
|
1019 General category. |
|
1020 */ |
|
1021 TCategory iCategory; |
|
1022 |
|
1023 |
|
1024 /** |
|
1025 Bi-directional category. |
|
1026 */ |
|
1027 TBdCategory iBdCategory; |
|
1028 |
|
1029 |
|
1030 /** |
|
1031 Combining class: number (currently) in the range 0..234 |
|
1032 */ |
|
1033 TInt iCombiningClass; |
|
1034 |
|
1035 |
|
1036 /** |
|
1037 Lower case form. |
|
1038 */ |
|
1039 TUint iLowerCase; |
|
1040 |
|
1041 |
|
1042 /** |
|
1043 Upper case form. |
|
1044 */ |
|
1045 TUint iUpperCase; |
|
1046 |
|
1047 |
|
1048 /** |
|
1049 Title case form. |
|
1050 */ |
|
1051 TUint iTitleCase; |
|
1052 |
|
1053 |
|
1054 /** |
|
1055 True, if the character is mirrored. |
|
1056 */ |
|
1057 TBool iMirrored; |
|
1058 |
|
1059 |
|
1060 /** |
|
1061 Integer numeric value: -1 if none, -2 if a fraction. |
|
1062 */ |
|
1063 TInt iNumericValue; |
|
1064 }; |
|
1065 |
|
1066 inline TChar(); |
|
1067 inline TChar(TUint aChar); |
|
1068 inline TChar& operator-=(TUint aChar); |
|
1069 inline TChar& operator+=(TUint aChar); |
|
1070 inline TChar operator-(TUint aChar); |
|
1071 inline TChar operator+(TUint aChar); |
|
1072 inline operator TUint() const; |
|
1073 #ifndef __KERNEL_MODE__ |
|
1074 inline void Fold(); |
|
1075 inline void LowerCase(); |
|
1076 inline void UpperCase(); |
|
1077 inline TBool Eos() const; |
|
1078 IMPORT_C TUint GetUpperCase() const; |
|
1079 IMPORT_C TUint GetLowerCase() const; |
|
1080 IMPORT_C TBool IsLower() const; |
|
1081 IMPORT_C TBool IsUpper() const; |
|
1082 IMPORT_C TBool IsAlpha() const; |
|
1083 IMPORT_C TBool IsDigit() const; |
|
1084 IMPORT_C TBool IsAlphaDigit() const; |
|
1085 IMPORT_C TBool IsHexDigit() const; |
|
1086 IMPORT_C TBool IsSpace() const; |
|
1087 IMPORT_C TBool IsPunctuation() const; |
|
1088 IMPORT_C TBool IsGraph() const; |
|
1089 IMPORT_C TBool IsPrint() const; |
|
1090 IMPORT_C TBool IsControl() const; |
|
1091 inline void Fold(TInt aFlags); |
|
1092 inline void TitleCase(); |
|
1093 IMPORT_C TUint GetTitleCase() const; |
|
1094 IMPORT_C TBool IsTitle() const; |
|
1095 IMPORT_C TBool IsAssigned() const; |
|
1096 IMPORT_C void GetInfo(TCharInfo& aInfo) const; |
|
1097 IMPORT_C TCategory GetCategory() const; |
|
1098 IMPORT_C TBdCategory GetBdCategory() const; |
|
1099 IMPORT_C TInt GetCombiningClass() const; |
|
1100 IMPORT_C TBool IsMirrored() const; |
|
1101 IMPORT_C TInt GetNumericValue() const; |
|
1102 IMPORT_C TCjkWidth GetCjkWidth() const; |
|
1103 IMPORT_C static TBool Compose(TUint& aResult,const TDesC16& aSource); |
|
1104 IMPORT_C TBool Decompose(TPtrC16& aResult) const; |
|
1105 |
|
1106 protected: |
|
1107 inline void SetChar(TUint aChar); |
|
1108 #endif |
|
1109 private: |
|
1110 TUint iChar; |
|
1111 __DECLARE_TEST; |
|
1112 }; |
|
1113 |
|
1114 #include <e32des8.h> |
|
1115 #ifndef __KERNEL_MODE__ |
|
1116 #include <e32des16.h> |
|
1117 #endif |
|
1118 |
|
1119 |
|
1120 |
|
1121 |
|
1122 #if defined(_UNICODE) && !defined(__KERNEL_MODE__) |
|
1123 #define __Size (sizeof(TUint)/sizeof(TUint16)) |
|
1124 /** |
|
1125 @publishedAll |
|
1126 @released |
|
1127 |
|
1128 Defines a build-independent non-modifiable descriptor. |
|
1129 |
|
1130 A 16-bit build variant is generated for a Unicode, non-kernel |
|
1131 mode build. |
|
1132 |
|
1133 A build-independent type should always be used unless an explicit 8-bit |
|
1134 or 16-bit type is required. |
|
1135 |
|
1136 @see TDesC8 |
|
1137 @see TDesC16 |
|
1138 */ |
|
1139 typedef TDesC16 TDesC; |
|
1140 |
|
1141 |
|
1142 |
|
1143 |
|
1144 /** |
|
1145 @publishedAll |
|
1146 @released |
|
1147 |
|
1148 Defines a build-independent non-modifiable pointer descriptor. |
|
1149 |
|
1150 A 16-bit build variant is generated for a Unicode, non-kernel |
|
1151 mode build. |
|
1152 |
|
1153 A build-independent type should always be used unless an explicit 8-bit |
|
1154 or 16-bit type is required. |
|
1155 |
|
1156 @see TPtrC8 |
|
1157 @see TPtrC16 |
|
1158 */ |
|
1159 typedef TPtrC16 TPtrC; |
|
1160 |
|
1161 |
|
1162 |
|
1163 |
|
1164 /** |
|
1165 @publishedAll |
|
1166 @released |
|
1167 |
|
1168 Defines a build-independent modifiable descriptor. |
|
1169 |
|
1170 A 16-bit build variant is generated for a Unicode, non-kernel |
|
1171 mode build. |
|
1172 |
|
1173 A build-independent type should always be used unless an explicit 8-bit |
|
1174 or 16-bit type is required. |
|
1175 |
|
1176 @see TDes8 |
|
1177 @see TDes16 |
|
1178 */ |
|
1179 typedef TDes16 TDes; |
|
1180 |
|
1181 |
|
1182 |
|
1183 |
|
1184 /** |
|
1185 @publishedAll |
|
1186 @released |
|
1187 |
|
1188 Defines a build-independent modifiable pointer descriptor. |
|
1189 |
|
1190 A 16-bit build variant is generated for a Unicode, non-kernel |
|
1191 mode build. |
|
1192 |
|
1193 A build-independent type should always be used unless an explicit 8-bit |
|
1194 or 16-bit type is required. |
|
1195 |
|
1196 @see TPtr8 |
|
1197 @see TPtr16 |
|
1198 */ |
|
1199 typedef TPtr16 TPtr; |
|
1200 |
|
1201 |
|
1202 |
|
1203 |
|
1204 #ifndef __KERNEL_MODE__ |
|
1205 /** |
|
1206 @publishedAll |
|
1207 @released |
|
1208 |
|
1209 Defines a build-independent heap descriptor. |
|
1210 |
|
1211 A 16-bit build variant is generated for a Unicode, non-kernel |
|
1212 mode build. |
|
1213 |
|
1214 A build-independent type should always be used unless an explicit 8-bit |
|
1215 or 16-bit type is required. |
|
1216 |
|
1217 @see HBufC8 |
|
1218 @see HBufC16 |
|
1219 */ |
|
1220 typedef HBufC16 HBufC; |
|
1221 |
|
1222 |
|
1223 |
|
1224 |
|
1225 /** |
|
1226 @publishedAll |
|
1227 @released |
|
1228 |
|
1229 Defines a build-independent descriptor overflow handler. |
|
1230 |
|
1231 A 16-bit build variant is generated for a Unicode, non-kernel |
|
1232 mode build. |
|
1233 |
|
1234 A build-independent type should always be used unless an explicit 8-bit |
|
1235 or 16-bit type is required. |
|
1236 |
|
1237 @see TDes8Overflow |
|
1238 @see TDes16Overflow |
|
1239 */ |
|
1240 typedef TDes16Overflow TDesOverflow; |
|
1241 |
|
1242 |
|
1243 /** |
|
1244 @publishedAll |
|
1245 @released |
|
1246 |
|
1247 Defines a build-independent resizable buffer descriptor. |
|
1248 |
|
1249 A 16-bit build variant is generated for a Unicode, non-kernel mode build. |
|
1250 |
|
1251 A build-independent type should always be used unless an explicit 8-bit |
|
1252 or 16-bit type is required. |
|
1253 |
|
1254 @see RBuf8 |
|
1255 @see RBuf16 |
|
1256 */ |
|
1257 typedef RBuf16 RBuf; |
|
1258 |
|
1259 #endif |
|
1260 #else |
|
1261 #define __Size (sizeof(TUint)/sizeof(TUint8)) |
|
1262 |
|
1263 |
|
1264 |
|
1265 |
|
1266 /** |
|
1267 @publishedAll |
|
1268 @released |
|
1269 |
|
1270 Defines a build-independent non-modifiable descriptor. |
|
1271 |
|
1272 An 8-bit build variant is generated for a non-Unicode build. |
|
1273 |
|
1274 This build-independent type should always be used unless an explicit 8-bit |
|
1275 or 16-bit build variant is required. |
|
1276 |
|
1277 @see TDesC8 |
|
1278 @see TDesC16 |
|
1279 */ |
|
1280 typedef TDesC8 TDesC; |
|
1281 |
|
1282 |
|
1283 |
|
1284 |
|
1285 /** |
|
1286 @publishedAll |
|
1287 @released |
|
1288 |
|
1289 Defines a build-independent non-modifiable pointer descriptor. |
|
1290 |
|
1291 An 8-bit build variant is generated for a non-Unicode build. |
|
1292 |
|
1293 This build-independent type should always be used unless an explicit 8-bit |
|
1294 or 16-bit build variant is required. |
|
1295 |
|
1296 @see TPtrC8 |
|
1297 @see TPtrC16 |
|
1298 */ |
|
1299 typedef TPtrC8 TPtrC; |
|
1300 |
|
1301 |
|
1302 |
|
1303 |
|
1304 /** |
|
1305 @publishedAll |
|
1306 @released |
|
1307 |
|
1308 Defines a build-independent modifiable descriptor. |
|
1309 |
|
1310 An 8-bit build variant is generated for a non-Unicode build. |
|
1311 |
|
1312 This build-independent type should always be used unless an explicit 8-bit |
|
1313 or 16-bit build variant is required. |
|
1314 |
|
1315 @see TDes8 |
|
1316 @see TDes16 |
|
1317 */ |
|
1318 typedef TDes8 TDes; |
|
1319 |
|
1320 |
|
1321 |
|
1322 |
|
1323 /** |
|
1324 @publishedAll |
|
1325 @released |
|
1326 |
|
1327 Defines a build-independent modifiable pointer descriptor. |
|
1328 |
|
1329 An 8-bit build variant is generated for a non-Unicode build. |
|
1330 |
|
1331 This build-independent type should always be used unless an explicit 8-bit |
|
1332 or 16-bit build variant is required. |
|
1333 |
|
1334 @see TPtr8 |
|
1335 @see TPtr16 |
|
1336 */ |
|
1337 typedef TPtr8 TPtr; |
|
1338 #ifndef __KERNEL_MODE__ |
|
1339 |
|
1340 |
|
1341 |
|
1342 |
|
1343 /** |
|
1344 @publishedAll |
|
1345 @released |
|
1346 |
|
1347 Defines a build-independent heap descriptor. |
|
1348 |
|
1349 An 8-bit build variant is generated for a non-Unicode, non-kernel |
|
1350 mode build. |
|
1351 |
|
1352 This build-independent type should always be used unless an explicit 8-bit |
|
1353 or 16-bit build variant is required. |
|
1354 |
|
1355 @see HBufC8 |
|
1356 @see HBufC16 |
|
1357 */ |
|
1358 typedef HBufC8 HBufC; |
|
1359 |
|
1360 |
|
1361 |
|
1362 |
|
1363 /** |
|
1364 @publishedAll |
|
1365 @released |
|
1366 |
|
1367 Defines a build-independent descriptor overflow handler. |
|
1368 |
|
1369 An 8-bit build variant is generated for a non-Unicode, non-kernel |
|
1370 mode build. |
|
1371 |
|
1372 This build-independent type should always be used unless an explicit 8-bit |
|
1373 or 16-bit build variant is required. |
|
1374 |
|
1375 @see TDes8Overflow |
|
1376 @see TDes16Overflow |
|
1377 */ |
|
1378 typedef TDes8Overflow TDesOverflow; |
|
1379 |
|
1380 |
|
1381 /** |
|
1382 @publishedAll |
|
1383 @released |
|
1384 |
|
1385 Defines a build-independent resizable buffer descriptor. |
|
1386 |
|
1387 An 8-bit build variant is generated for a non-Unicode, non-kernel mode build. |
|
1388 |
|
1389 This build-independent type should always be used unless an explicit 8-bit |
|
1390 or 16-bit build variant is required. |
|
1391 |
|
1392 @see RBuf8 |
|
1393 @see RBuf16 |
|
1394 */ |
|
1395 typedef RBuf8 RBuf; |
|
1396 |
|
1397 #endif |
|
1398 #endif |
|
1399 |
|
1400 |
|
1401 #if defined(_UNICODE) && !defined(__KERNEL_MODE__) |
|
1402 typedef TBufCBase16 TBufCBase; |
|
1403 #else |
|
1404 typedef TBufCBase8 TBufCBase; |
|
1405 #endif |
|
1406 |
|
1407 /** |
|
1408 @publishedAll |
|
1409 @released |
|
1410 |
|
1411 A build-independent non-modifiable buffer descriptor. |
|
1412 |
|
1413 This is a descriptor class which provides a buffer of fixed length for |
|
1414 containing and accessing TUint16 or TUint8 data, depending on the build. |
|
1415 |
|
1416 The class intended for instantiation. The data that the descriptor represents |
|
1417 is part of the descriptor object itself. |
|
1418 |
|
1419 The class is templated, based on an integer value which defines the size of |
|
1420 the descriptor's data area. |
|
1421 |
|
1422 The data is intended to be accessed, but not modified; however, it can be |
|
1423 completely replaced using the assignment operators of this class. The base |
|
1424 class provides the functions through which the data is accessed. |
|
1425 |
|
1426 This class derives from TBufCBase16 for a Unicode, non-kernel build, but |
|
1427 derives from TBufCBase8 for a non-Unicode build. |
|
1428 |
|
1429 @see TDesC |
|
1430 @see TDesC8 |
|
1431 @see TDesC16 |
|
1432 @see TPtr |
|
1433 @see TPtr8 |
|
1434 @see TPtr16 |
|
1435 @see TBufC8 |
|
1436 @see TBufC16 |
|
1437 */ |
|
1438 template <TInt S> |
|
1439 #if defined(_UNICODE) && !defined(__KERNEL_MODE__) |
|
1440 class TBufC : public TBufCBase16 |
|
1441 #else |
|
1442 class TBufC : public TBufCBase8 |
|
1443 #endif |
|
1444 { |
|
1445 public: |
|
1446 inline TBufC(); |
|
1447 inline TBufC(const TText* aString); |
|
1448 inline TBufC(const TDesC& aDes); |
|
1449 inline TBufC<S>& operator=(const TText* aString); |
|
1450 inline TBufC<S>& operator=(const TDesC& aDes); |
|
1451 inline TPtr Des(); |
|
1452 private: |
|
1453 TText iBuf[__Align(S)]; |
|
1454 }; |
|
1455 |
|
1456 |
|
1457 |
|
1458 /** |
|
1459 @publishedAll |
|
1460 @released |
|
1461 |
|
1462 A build-independent modifiable buffer descriptor. |
|
1463 |
|
1464 This is a descriptor class which provides a buffer of fixed length for |
|
1465 containing, accessing and manipulating TUint16 or TUint8 data, depending |
|
1466 on the build. |
|
1467 |
|
1468 The class is intended for instantiation. The data that the descriptor represents |
|
1469 is part of the descriptor object itself. |
|
1470 |
|
1471 The class is templated, based on an integer value which determines the size |
|
1472 of the data area created as part of the buffer descriptor object; this is |
|
1473 also the maximum length of the descriptor. |
|
1474 |
|
1475 The data is intended to be both accessed and modified. The base classes provide |
|
1476 the functions through which the data is accessed. |
|
1477 |
|
1478 This class derives from TBufCBase16 for a Unicode, non-kernel build, but |
|
1479 derives from TBufCBase8 for a non-Unicode build. |
|
1480 |
|
1481 @see TDesC |
|
1482 @see TDesC8 |
|
1483 @see TDesC16 |
|
1484 @see TDes |
|
1485 @see TDes8 |
|
1486 @see TDes16 |
|
1487 @see TPtr |
|
1488 @see TPtr8 |
|
1489 @see TPtr16 |
|
1490 */ |
|
1491 template <TInt S> |
|
1492 #if defined(_UNICODE) && !defined(__KERNEL_MODE__) |
|
1493 class TBuf : public TBufBase16 |
|
1494 #else |
|
1495 class TBuf : public TBufBase8 |
|
1496 #endif |
|
1497 { |
|
1498 public: |
|
1499 inline TBuf(); |
|
1500 inline explicit TBuf(TInt aLength); |
|
1501 inline TBuf(const TText* aString); |
|
1502 inline TBuf(const TDesC& aDes); |
|
1503 inline TBuf<S>& operator=(const TText* aString); |
|
1504 inline TBuf<S>& operator=(const TDesC& aDes); |
|
1505 inline TBuf<S>& operator=(const TBuf<S>& aBuf); |
|
1506 private: |
|
1507 TText iBuf[__Align(S)]; |
|
1508 }; |
|
1509 |
|
1510 |
|
1511 |
|
1512 |
|
1513 /** |
|
1514 @publishedAll |
|
1515 @released |
|
1516 |
|
1517 Value reference used in operator TLitC::__TRefDesC(). |
|
1518 |
|
1519 @see TRefByValue |
|
1520 */ |
|
1521 typedef TRefByValue<const TDesC> __TRefDesC; |
|
1522 |
|
1523 |
|
1524 |
|
1525 |
|
1526 /** |
|
1527 @publishedAll |
|
1528 @released |
|
1529 |
|
1530 Encapsulates literal text. |
|
1531 |
|
1532 This is always constructed using an _LIT macro. |
|
1533 |
|
1534 This class is build independent; i.e. for a non-Unicode build, an 8-bit build |
|
1535 variant is generated; for a Unicode build, a 16 bit build variant is generated. |
|
1536 |
|
1537 The class has no explicit constructors. See the _LIT macro definition. |
|
1538 */ |
|
1539 template <TInt S> |
|
1540 class TLitC |
|
1541 { |
|
1542 public: |
|
1543 /** |
|
1544 @internalComponent |
|
1545 */ |
|
1546 enum {BufferSize=S-1}; |
|
1547 inline const TDesC* operator&() const; |
|
1548 inline operator const TDesC&() const; |
|
1549 inline const TDesC& operator()() const; |
|
1550 inline operator const __TRefDesC() const; |
|
1551 public: |
|
1552 #if !defined(_UNICODE) || defined(__KERNEL_MODE__) |
|
1553 |
|
1554 /** |
|
1555 @internalComponent |
|
1556 */ |
|
1557 typedef TUint8 __TText; |
|
1558 #elif defined(__GCC32__) |
|
1559 |
|
1560 /** |
|
1561 @internalComponent |
|
1562 */ |
|
1563 typedef wchar_t __TText; |
|
1564 #elif defined(__VC32__) |
|
1565 |
|
1566 /** |
|
1567 @internalComponent |
|
1568 */ |
|
1569 typedef TUint16 __TText; |
|
1570 |
|
1571 #elif defined(__CW32__) |
|
1572 |
|
1573 /** |
|
1574 @internalComponent |
|
1575 */ |
|
1576 typedef TUint16 __TText; |
|
1577 #elif !defined(__TText_defined) |
|
1578 #error no typedef for __TText |
|
1579 #endif |
|
1580 public: |
|
1581 /** |
|
1582 @internalComponent |
|
1583 */ |
|
1584 TUint iTypeLength; |
|
1585 |
|
1586 /** |
|
1587 @internalComponent |
|
1588 */ |
|
1589 __TText iBuf[__Align(S)]; |
|
1590 }; |
|
1591 |
|
1592 |
|
1593 /** |
|
1594 @publishedAll |
|
1595 @released |
|
1596 |
|
1597 Defines an empty or null literal descriptor. |
|
1598 |
|
1599 This is the build independent form. |
|
1600 An 8 bit build variant is generated for a non-Unicode build; |
|
1601 a 16 bit build variant is generated for a Unicode build. |
|
1602 */ |
|
1603 _LIT(KNullDesC,""); |
|
1604 |
|
1605 |
|
1606 |
|
1607 /** |
|
1608 @publishedAll |
|
1609 @released |
|
1610 |
|
1611 Defines an empty or null literal descriptor for use with 8-bit descriptors. |
|
1612 */ |
|
1613 _LIT8(KNullDesC8,""); |
|
1614 #ifndef __KERNEL_MODE__ |
|
1615 |
|
1616 |
|
1617 |
|
1618 /** |
|
1619 @publishedAll |
|
1620 @released |
|
1621 |
|
1622 Defines an empty or null literal descriptor for use with 16-bit descriptors |
|
1623 */ |
|
1624 _LIT16(KNullDesC16,""); |
|
1625 #endif |
|
1626 |
|
1627 |
|
1628 |
|
1629 |
|
1630 /** |
|
1631 @publishedAll |
|
1632 @released |
|
1633 |
|
1634 Packages a non-modifiable pointer descriptor which represents an object of |
|
1635 specific type. |
|
1636 |
|
1637 The template parameter defines the type of object. |
|
1638 |
|
1639 The object represented by the packaged pointer descriptor is accessible through |
|
1640 the package but cannot be changed. */ |
|
1641 template <class T> |
|
1642 class TPckgC : public TPtrC8 |
|
1643 { |
|
1644 public: |
|
1645 inline TPckgC(const T& aRef); |
|
1646 inline const T& operator()() const; |
|
1647 private: |
|
1648 TPckgC<T>& operator=(const TPckgC<T>& aRef); |
|
1649 }; |
|
1650 |
|
1651 |
|
1652 |
|
1653 |
|
1654 /** |
|
1655 @publishedAll |
|
1656 @released |
|
1657 |
|
1658 Packages a modifiable pointer descriptor which represents an object of specific |
|
1659 type. |
|
1660 |
|
1661 The template parameter defines the type of object. |
|
1662 |
|
1663 The object represented by the packaged pointer descriptor is accessible through |
|
1664 the package. |
|
1665 */ |
|
1666 template <class T> |
|
1667 class TPckg : public TPtr8 |
|
1668 { |
|
1669 public: |
|
1670 inline TPckg(const T& aRef); |
|
1671 inline T& operator()(); |
|
1672 private: |
|
1673 TPckg<T>& operator=(const TPckg<T>& aRef); |
|
1674 }; |
|
1675 |
|
1676 |
|
1677 |
|
1678 |
|
1679 /** |
|
1680 @publishedAll |
|
1681 @released |
|
1682 |
|
1683 Packages an object into a modifiable buffer descriptor. |
|
1684 |
|
1685 The template parameter defines the type of object to be packaged. |
|
1686 |
|
1687 The package provides a type safe way of transferring an object or data structure |
|
1688 which is contained within a modifiable buffer descriptor. Typically, a package |
|
1689 is used for passing data via inter thread communication. |
|
1690 |
|
1691 The contained object is accessible through the package. |
|
1692 */ |
|
1693 template <class T> |
|
1694 class TPckgBuf : public TAlignedBuf8<sizeof(T)> |
|
1695 { |
|
1696 public: |
|
1697 inline TPckgBuf(); |
|
1698 inline TPckgBuf(const T& aRef); |
|
1699 inline TPckgBuf& operator=(const TPckgBuf<T>& aRef); |
|
1700 inline T& operator=(const T& aRef); |
|
1701 inline T& operator()(); |
|
1702 inline const T& operator()() const; |
|
1703 }; |
|
1704 |
|
1705 |
|
1706 |
|
1707 |
|
1708 /** |
|
1709 @publishedAll |
|
1710 @released |
|
1711 |
|
1712 Defines a modifiable buffer descriptor that can contain the name of a reference |
|
1713 counting object. |
|
1714 |
|
1715 @see TBuf |
|
1716 @see CObject |
|
1717 */ |
|
1718 typedef TBuf<KMaxName> TName; |
|
1719 |
|
1720 |
|
1721 /** |
|
1722 @publishedAll |
|
1723 @released |
|
1724 |
|
1725 Defines a modifiable buffer descriptor that can contain the full name of a |
|
1726 reference counting object. |
|
1727 |
|
1728 @see TBuf |
|
1729 @see CObject |
|
1730 */ |
|
1731 typedef TBuf<KMaxFullName> TFullName; |
|
1732 |
|
1733 |
|
1734 |
|
1735 /** |
|
1736 @publishedAll |
|
1737 @released |
|
1738 |
|
1739 Defines a modifiable buffer descriptor to contain the category name identifying |
|
1740 the cause of thread or process termination. The buffer takes a maximum length |
|
1741 of KMaxExitCategoryName. |
|
1742 |
|
1743 @see RThread::ExitCategory |
|
1744 @see RThread::ExitCategory |
|
1745 */ |
|
1746 typedef TBuf<KMaxExitCategoryName> TExitCategoryName; |
|
1747 |
|
1748 |
|
1749 |
|
1750 /** |
|
1751 @publishedAll |
|
1752 @released |
|
1753 |
|
1754 A buffer that can contain the name of a file. |
|
1755 The name can have a maximum length of KMaxFileName |
|
1756 (currently 256 but check the definition of KMaxFileName). |
|
1757 |
|
1758 @see KMaxFileName |
|
1759 */ |
|
1760 typedef TBuf<KMaxFileName> TFileName; |
|
1761 |
|
1762 |
|
1763 |
|
1764 /** |
|
1765 @publishedAll |
|
1766 @released |
|
1767 |
|
1768 A buffer that can contain the name of a path. |
|
1769 The name can have a maximum length of KMaxPath |
|
1770 (currently 256 but check the definition of KMaxPath). |
|
1771 |
|
1772 @see KMaxPath |
|
1773 */ |
|
1774 typedef TBuf<KMaxPath> TPath; |
|
1775 |
|
1776 |
|
1777 |
|
1778 |
|
1779 /** |
|
1780 @publishedAll |
|
1781 @released |
|
1782 |
|
1783 Version name type. |
|
1784 |
|
1785 This is a buffer descriptor with a maximum length of KMaxVersionName. |
|
1786 A TVersion object returns the formatted character representation of its version |
|
1787 information in a descriptor of this type. |
|
1788 |
|
1789 @see TVersion |
|
1790 */ |
|
1791 typedef TBuf<KMaxVersionName> TVersionName; |
|
1792 |
|
1793 |
|
1794 |
|
1795 |
|
1796 /** |
|
1797 @publishedAll |
|
1798 @released |
|
1799 |
|
1800 Defines a modifiable buffer descriptor for the text form of the UID. |
|
1801 The descriptor has a maximum length of KMaxUidName and is used to contain |
|
1802 the standard text format returned by the function TUid::Name(). |
|
1803 |
|
1804 @see TUid::Name |
|
1805 */ |
|
1806 typedef TBuf<KMaxUidName> TUidName; |
|
1807 |
|
1808 |
|
1809 |
|
1810 |
|
1811 /** |
|
1812 @publishedAll |
|
1813 @released |
|
1814 |
|
1815 Defines a null UID |
|
1816 */ |
|
1817 #define KNullUid TUid::Null() |
|
1818 |
|
1819 |
|
1820 |
|
1821 |
|
1822 /** |
|
1823 @publishedAll |
|
1824 @released |
|
1825 |
|
1826 A globally unique 32-bit number. |
|
1827 */ |
|
1828 class TUid |
|
1829 { |
|
1830 public: |
|
1831 #ifndef __KERNEL_MODE__ |
|
1832 IMPORT_C TBool operator==(const TUid& aUid) const; |
|
1833 IMPORT_C TBool operator!=(const TUid& aUid) const; |
|
1834 IMPORT_C TUidName Name() const; |
|
1835 #endif |
|
1836 static inline TUid Uid(TInt aUid); |
|
1837 static inline TUid Null(); |
|
1838 public: |
|
1839 /** |
|
1840 The 32-bit integer UID value. |
|
1841 */ |
|
1842 TInt32 iUid; |
|
1843 }; |
|
1844 |
|
1845 |
|
1846 |
|
1847 |
|
1848 /** |
|
1849 @publishedAll |
|
1850 @released |
|
1851 |
|
1852 Encapsulates a set of three unique identifiers (UIDs) which, in combination, |
|
1853 identify a system object such as a GUI application or a DLL. The three |
|
1854 component UIDs are referred to as UID1, UID2 and UID3. |
|
1855 |
|
1856 An object of this type is referred to as a compound identifier or a UID type. |
|
1857 */ |
|
1858 class TUidType |
|
1859 { |
|
1860 public: |
|
1861 #ifndef __KERNEL_MODE__ |
|
1862 IMPORT_C TUidType(); |
|
1863 IMPORT_C TUidType(TUid aUid1); |
|
1864 IMPORT_C TUidType(TUid aUid1,TUid aUid2); |
|
1865 IMPORT_C TUidType(TUid aUid1,TUid aUid2,TUid aUid3); |
|
1866 IMPORT_C TBool operator==(const TUidType& aUidType) const; |
|
1867 IMPORT_C TBool operator!=(const TUidType& aUidType) const; |
|
1868 IMPORT_C const TUid& operator[](TInt anIndex) const; |
|
1869 IMPORT_C TUid MostDerived() const; |
|
1870 IMPORT_C TBool IsPresent(TUid aUid) const; |
|
1871 IMPORT_C TBool IsValid() const; |
|
1872 private: |
|
1873 #endif |
|
1874 TUid iUid[KMaxCheckedUid]; |
|
1875 }; |
|
1876 |
|
1877 |
|
1878 |
|
1879 |
|
1880 /** |
|
1881 A class used to represent the Secure ID of a process or executable image. |
|
1882 |
|
1883 Constructors and conversion operators are provided to enable conversion |
|
1884 of this class to and from both TUint32 and TUid objects. |
|
1885 |
|
1886 Because this class has non-default constructors, compilers will not initialise |
|
1887 this objects at compile time, instead code will be generated to construct the object |
|
1888 at run-time. This is wastefull, and Symbian OS DLLs are not permitted to have |
|
1889 such uninitialised data. To overcome these problems a macro is provided to construct |
|
1890 a const object which behaves like a TSecureId. This is _LIT_SECURE_ID. |
|
1891 This macro should be used where it is desirable to define const TSecureId objects, |
|
1892 like in header files. E.g. Instead of writing: |
|
1893 @code |
|
1894 const TSecureId MyId=0x1234567 |
|
1895 @endcode |
|
1896 use |
|
1897 @code |
|
1898 _LIT_SECURE_ID(MyId,0x1234567) |
|
1899 @endcode |
|
1900 |
|
1901 @publishedAll |
|
1902 @released |
|
1903 |
|
1904 @see _LIT_SECURE_ID |
|
1905 */ |
|
1906 class TSecureId |
|
1907 { |
|
1908 public: |
|
1909 inline TSecureId(); |
|
1910 inline TSecureId(TUint32 aId); |
|
1911 inline operator TUint32() const; |
|
1912 inline TSecureId(TUid aId); |
|
1913 inline operator TUid() const; |
|
1914 public: |
|
1915 TUint32 iId; |
|
1916 }; |
|
1917 |
|
1918 |
|
1919 |
|
1920 |
|
1921 /** |
|
1922 A class used to represent the Vendor ID of a process or executable image |
|
1923 |
|
1924 Constructors and conversion operators are provided to enable conversion |
|
1925 of this class to and from both TUint32 and TUid objects. |
|
1926 |
|
1927 Because this class has non-default constructors, compilers will not initialise |
|
1928 this objects at compile time, instead code will be generated to construct the object |
|
1929 at run-time. This is wastefull, and Symbian OS DLLs are not permitted to have |
|
1930 such uninitialised data. To overcome these problems a macro is provided to construct |
|
1931 a const object which behaves like a TSecureId. This is _LIT_VENDOR_ID. |
|
1932 This macro should be used where it is desirable to define const TSecureId objects, |
|
1933 like in header files. E.g. Instead of writing: |
|
1934 @code |
|
1935 const TVendorId MyId=0x1234567 |
|
1936 @endcode |
|
1937 use |
|
1938 @code |
|
1939 _LIT_VENDOR_ID(MyId,0x1234567) |
|
1940 @endcode |
|
1941 |
|
1942 @publishedAll |
|
1943 @released |
|
1944 |
|
1945 @see _LIT_VENDOR_ID |
|
1946 */ |
|
1947 class TVendorId |
|
1948 { |
|
1949 public: |
|
1950 inline TVendorId(); |
|
1951 inline TVendorId(TUint32 aId); |
|
1952 inline operator TUint32() const; |
|
1953 inline TVendorId(TUid aId); |
|
1954 inline operator TUid() const; |
|
1955 public: |
|
1956 TUint32 iId; |
|
1957 }; |
|
1958 |
|
1959 |
|
1960 |
|
1961 /** |
|
1962 Structure for compile-time definition of a secure ID |
|
1963 @internalComponent |
|
1964 */ |
|
1965 class SSecureId |
|
1966 { |
|
1967 public: |
|
1968 inline const TSecureId* operator&() const; |
|
1969 inline operator const TSecureId&() const; |
|
1970 inline operator TUint32() const; |
|
1971 inline operator TUid() const; |
|
1972 public: |
|
1973 TUint32 iId; |
|
1974 }; |
|
1975 |
|
1976 |
|
1977 |
|
1978 |
|
1979 /** |
|
1980 Structure for compile-time definition of a vendor ID |
|
1981 @internalComponent |
|
1982 */ |
|
1983 class SVendorId |
|
1984 { |
|
1985 public: |
|
1986 inline const TVendorId* operator&() const; |
|
1987 inline operator const TVendorId&() const; |
|
1988 inline operator TUint32() const; |
|
1989 inline operator TUid() const; |
|
1990 public: |
|
1991 TUint32 iId; |
|
1992 }; |
|
1993 |
|
1994 |
|
1995 |
|
1996 |
|
1997 /** |
|
1998 Macro for compile-time definition of a secure ID |
|
1999 @param name Name to use for secure ID |
|
2000 @param value Value of secure ID |
|
2001 @publishedAll |
|
2002 @released |
|
2003 */ |
|
2004 #define _LIT_SECURE_ID(name,value) const SSecureId name={value} |
|
2005 |
|
2006 |
|
2007 |
|
2008 |
|
2009 /** |
|
2010 Macro for compile-time definition of a vendor ID |
|
2011 @param name Name to use for vendor ID |
|
2012 @param value Value of vendor ID |
|
2013 @publishedAll |
|
2014 @released |
|
2015 */ |
|
2016 #define _LIT_VENDOR_ID(name,value) const SVendorId name={value} |
|
2017 |
|
2018 |
|
2019 |
|
2020 |
|
2021 /** |
|
2022 @publishedAll |
|
2023 @released |
|
2024 |
|
2025 Contains version information. |
|
2026 |
|
2027 A version is defined by a set of three numbers: |
|
2028 |
|
2029 1. the major version number, ranging from 0 to 127, inclusive |
|
2030 |
|
2031 2. the minor version number, ranging from 0 to 99 inclusive |
|
2032 |
|
2033 3. the build number, ranging from 0 to 32767 inclusive. |
|
2034 |
|
2035 The class provides a constructor for setting all three numbers. |
|
2036 It also provides a member function to build a character representation of |
|
2037 this information in a TVersionName descriptor. |
|
2038 |
|
2039 @see TVersionName |
|
2040 */ |
|
2041 class TVersion |
|
2042 { |
|
2043 public: |
|
2044 IMPORT_C TVersion(); |
|
2045 IMPORT_C TVersion(TInt aMajor,TInt aMinor,TInt aBuild); |
|
2046 IMPORT_C TVersionName Name() const; |
|
2047 public: |
|
2048 /** |
|
2049 The major version number. |
|
2050 */ |
|
2051 TInt8 iMajor; |
|
2052 |
|
2053 |
|
2054 /** |
|
2055 The minor version number. |
|
2056 */ |
|
2057 TInt8 iMinor; |
|
2058 |
|
2059 |
|
2060 /** |
|
2061 The build number. |
|
2062 */ |
|
2063 TInt16 iBuild; |
|
2064 }; |
|
2065 |
|
2066 |
|
2067 |
|
2068 |
|
2069 /** |
|
2070 @publishedAll |
|
2071 @released |
|
2072 |
|
2073 Indicates the completion status of a request made to a service provider. |
|
2074 |
|
2075 When a thread makes a request, it passes a request status as a parameter. |
|
2076 On completion, the provider signals the requesting thread's request semaphore |
|
2077 and stores a completion code in the request status. Typically, this is KErrNone |
|
2078 or one of the other system-wide error codes. |
|
2079 |
|
2080 This class is not intended for user derivation. |
|
2081 */ |
|
2082 class TRequestStatus |
|
2083 { |
|
2084 public: |
|
2085 inline TRequestStatus(); |
|
2086 inline TRequestStatus(TInt aVal); |
|
2087 inline TInt operator=(TInt aVal); |
|
2088 inline TBool operator==(TInt aVal) const; |
|
2089 inline TBool operator!=(TInt aVal) const; |
|
2090 inline TBool operator>=(TInt aVal) const; |
|
2091 inline TBool operator<=(TInt aVal) const; |
|
2092 inline TBool operator>(TInt aVal) const; |
|
2093 inline TBool operator<(TInt aVal) const; |
|
2094 inline TInt Int() const; |
|
2095 private: |
|
2096 enum |
|
2097 { |
|
2098 EActive = 1, //bit0 |
|
2099 ERequestPending = 2, //bit1 |
|
2100 }; |
|
2101 TInt iStatus; |
|
2102 TUint iFlags; |
|
2103 friend class CActive; |
|
2104 friend class CActiveScheduler; |
|
2105 friend class CServer2; |
|
2106 }; |
|
2107 |
|
2108 |
|
2109 |
|
2110 |
|
2111 class TSize; |
|
2112 /** |
|
2113 @publishedAll |
|
2114 @released |
|
2115 |
|
2116 Stores a two-dimensional point in Cartesian co-ordinates. |
|
2117 |
|
2118 Its data members (iX and iY) are public and can be manipulated directly, or |
|
2119 by means of the functions provided. Functions are provided to set and manipulate |
|
2120 the point, and to compare points for equality. |
|
2121 */ |
|
2122 class TPoint |
|
2123 { |
|
2124 public: |
|
2125 #ifndef __KERNEL_MODE__ |
|
2126 enum TUninitialized { EUninitialized }; |
|
2127 /** |
|
2128 Constructs default point, initialising its iX and iY members to zero. |
|
2129 */ |
|
2130 TPoint(TUninitialized) {} |
|
2131 inline TPoint(); |
|
2132 inline TPoint(TInt aX,TInt aY); |
|
2133 IMPORT_C TBool operator==(const TPoint& aPoint) const; |
|
2134 IMPORT_C TBool operator!=(const TPoint& aPoint) const; |
|
2135 IMPORT_C TPoint& operator-=(const TPoint& aPoint); |
|
2136 IMPORT_C TPoint& operator+=(const TPoint& aPoint); |
|
2137 IMPORT_C TPoint& operator-=(const TSize& aSize); |
|
2138 IMPORT_C TPoint& operator+=(const TSize& aSize); |
|
2139 IMPORT_C TPoint operator-(const TPoint& aPoint) const; |
|
2140 IMPORT_C TPoint operator+(const TPoint& aPoint) const; |
|
2141 IMPORT_C TPoint operator-(const TSize& aSize) const; |
|
2142 IMPORT_C TPoint operator+(const TSize& aSize) const; |
|
2143 IMPORT_C TPoint operator-() const; |
|
2144 IMPORT_C void SetXY(TInt aX,TInt aY); |
|
2145 IMPORT_C TSize AsSize() const; |
|
2146 #endif |
|
2147 public: |
|
2148 /** |
|
2149 The x co-ordinate. |
|
2150 */ |
|
2151 TInt iX; |
|
2152 /** |
|
2153 The y co-ordinate. |
|
2154 */ |
|
2155 TInt iY; |
|
2156 }; |
|
2157 |
|
2158 |
|
2159 |
|
2160 |
|
2161 /** |
|
2162 @publishedAll |
|
2163 @prototype |
|
2164 |
|
2165 Stores a three-dimensional point in Cartesian or polar co-ordinates. |
|
2166 Its data members (iX, iY and iZ) are public and can be manipulated directly. |
|
2167 |
|
2168 */ |
|
2169 class TPoint3D |
|
2170 { |
|
2171 public: |
|
2172 #ifndef __KERNEL_MODE__ |
|
2173 enum TUninitialized { EUninitialized }; |
|
2174 |
|
2175 /** |
|
2176 TUninitialized Constructor |
|
2177 */ |
|
2178 TPoint3D(TUninitialized) {} |
|
2179 /** |
|
2180 Constructs default TPoint3D, initialising its iX , iY and iZ members to zero. |
|
2181 */ |
|
2182 inline TPoint3D(); |
|
2183 /** |
|
2184 Constructs TPoint3D with the specified x,y and z co-ordinates. |
|
2185 */ |
|
2186 inline TPoint3D(TInt aX,TInt aY,TInt aZ); |
|
2187 /** |
|
2188 Copy Construct from TPoint , initialises Z co-ordinate to Zero |
|
2189 */ |
|
2190 inline TPoint3D(const TPoint& aPoint); |
|
2191 |
|
2192 IMPORT_C TBool operator==(const TPoint3D& aPoint3D) const; |
|
2193 IMPORT_C TBool operator!=(const TPoint3D& aPoint3D) const; |
|
2194 |
|
2195 IMPORT_C TPoint3D& operator-=(const TPoint3D& aPoint3D); |
|
2196 IMPORT_C TPoint3D& operator-=(const TPoint& aPoint); |
|
2197 |
|
2198 IMPORT_C TPoint3D& operator+=(const TPoint3D& aPoint3D); |
|
2199 IMPORT_C TPoint3D& operator+=(const TPoint& aPoint); |
|
2200 |
|
2201 IMPORT_C TPoint3D operator-(const TPoint3D& aPoint3D) const; |
|
2202 IMPORT_C TPoint3D operator-(const TPoint& aPoint) const; |
|
2203 |
|
2204 IMPORT_C TPoint3D operator+(const TPoint3D& aPoint3D) const; |
|
2205 IMPORT_C TPoint3D operator+(const TPoint& aPoint) const; |
|
2206 /** |
|
2207 Unary minus operator. The operator returns the negation of this Point3D |
|
2208 */ |
|
2209 IMPORT_C TPoint3D operator-() const; |
|
2210 |
|
2211 /** |
|
2212 Set Method to set the xyz co-ordinates of TPoint3D |
|
2213 */ |
|
2214 IMPORT_C void SetXYZ(TInt aX,TInt aY,TInt aZ); |
|
2215 |
|
2216 /** |
|
2217 TPoint3D from TPoint, sets the Z co-ordinate to Zero |
|
2218 */ |
|
2219 IMPORT_C void SetPoint(const TPoint& aPoint); |
|
2220 |
|
2221 /** |
|
2222 Returns TPoint from TPoint3D |
|
2223 */ |
|
2224 IMPORT_C TPoint AsPoint() const; |
|
2225 #endif |
|
2226 public: |
|
2227 /** |
|
2228 The x co-ordinate. |
|
2229 */ |
|
2230 TInt iX; |
|
2231 /** |
|
2232 The y co-ordinate. |
|
2233 */ |
|
2234 TInt iY; |
|
2235 /** |
|
2236 The z co-ordinate. |
|
2237 */ |
|
2238 TInt iZ; |
|
2239 }; |
|
2240 |
|
2241 |
|
2242 |
|
2243 /** |
|
2244 @internalTechnology |
|
2245 @prototype For now, only intended to be used by TRwEvent and the Windows Server |
|
2246 |
|
2247 Stores the angular spherical coordinates (Phi,Theta) of a three-dimensional point. |
|
2248 |
|
2249 Its data members (iPhi, iTheta) are public and can be manipulated directly. |
|
2250 */ |
|
2251 class TAngle3D |
|
2252 { |
|
2253 public: |
|
2254 /** |
|
2255 The Phi co-ordinate (angle between X-axis and the line that links the projection of the point on the X-Y plane and the origin). |
|
2256 */ |
|
2257 TInt iPhi; |
|
2258 /** |
|
2259 The Theta co-ordinate (angle between the Z-axis and the line that links the point and the origin). |
|
2260 */ |
|
2261 TInt iTheta; |
|
2262 }; |
|
2263 |
|
2264 |
|
2265 /** |
|
2266 @publishedAll |
|
2267 @released |
|
2268 |
|
2269 Stores a two-dimensional size as a width and a height value. |
|
2270 |
|
2271 Its data members are public and can be manipulated directly, or by means of |
|
2272 the functions provided. |
|
2273 */ |
|
2274 class TSize |
|
2275 { |
|
2276 public: |
|
2277 #ifndef __KERNEL_MODE__ |
|
2278 enum TUninitialized { EUninitialized }; |
|
2279 /** |
|
2280 Constructs the size object with its iWidth and iHeight members set to zero. |
|
2281 */ |
|
2282 TSize(TUninitialized) {} |
|
2283 inline TSize(); |
|
2284 inline TSize(TInt aWidth,TInt aHeight); |
|
2285 IMPORT_C TBool operator==(const TSize& aSize) const; |
|
2286 IMPORT_C TBool operator!=(const TSize& aSize) const; |
|
2287 IMPORT_C TSize& operator-=(const TSize& aSize); |
|
2288 IMPORT_C TSize& operator-=(const TPoint& aPoint); |
|
2289 IMPORT_C TSize& operator+=(const TSize& aSize); |
|
2290 IMPORT_C TSize& operator+=(const TPoint& aPoint); |
|
2291 IMPORT_C TSize operator-(const TSize& aSize) const; |
|
2292 IMPORT_C TSize operator-(const TPoint& aPoint) const; |
|
2293 IMPORT_C TSize operator+(const TSize& aSize) const; |
|
2294 IMPORT_C TSize operator+(const TPoint& aPoint) const; |
|
2295 IMPORT_C TSize operator-() const; |
|
2296 IMPORT_C void SetSize(TInt aWidth,TInt aHeight); |
|
2297 IMPORT_C TPoint AsPoint() const; |
|
2298 #endif |
|
2299 public: |
|
2300 /** |
|
2301 The width of this TSize object. |
|
2302 */ |
|
2303 TInt iWidth; |
|
2304 /** |
|
2305 The height of this TSize object. |
|
2306 */ |
|
2307 TInt iHeight; |
|
2308 }; |
|
2309 |
|
2310 |
|
2311 |
|
2312 |
|
2313 /** |
|
2314 @publishedAll |
|
2315 @released |
|
2316 |
|
2317 Information about a kernel object. |
|
2318 |
|
2319 This type of object is passed to RHandleBase::HandleInfo(). The function |
|
2320 fetches information on the usage of the kernel object associated with that |
|
2321 handle and stores the information in the THandleInfo object. |
|
2322 |
|
2323 The class contains four data members and no explicitly defined function |
|
2324 members. |
|
2325 */ |
|
2326 class THandleInfo |
|
2327 { |
|
2328 public: |
|
2329 /** |
|
2330 The number of times that the kernel object is open in the current process. |
|
2331 */ |
|
2332 TInt iNumOpenInProcess; |
|
2333 |
|
2334 /** |
|
2335 The number of times that the kernel object is open in the current thread. |
|
2336 */ |
|
2337 TInt iNumOpenInThread; |
|
2338 |
|
2339 /** |
|
2340 The number of processes which have a handle on the kernel object. |
|
2341 */ |
|
2342 TInt iNumProcesses; |
|
2343 |
|
2344 /** |
|
2345 The number of threads which have a handle on the kernel object. |
|
2346 */ |
|
2347 TInt iNumThreads; |
|
2348 }; |
|
2349 |
|
2350 |
|
2351 |
|
2352 |
|
2353 /** |
|
2354 @internalComponent |
|
2355 */ |
|
2356 class TFindHandle |
|
2357 { |
|
2358 public: |
|
2359 inline TFindHandle(); |
|
2360 inline TInt Handle() const; |
|
2361 #ifdef __KERNEL_MODE__ |
|
2362 inline TInt Index() const; |
|
2363 inline TInt UniqueID() const; |
|
2364 inline TUint64 ObjectID() const; |
|
2365 inline void Set(TInt aIndex, TInt aUniqueId, TUint64 aObjectId); |
|
2366 #else |
|
2367 protected: |
|
2368 inline void Reset(); |
|
2369 #endif |
|
2370 private: |
|
2371 TInt iHandle; |
|
2372 TInt iSpare1; |
|
2373 TInt iObjectIdLow; |
|
2374 TInt iObjectIdHigh; |
|
2375 }; |
|
2376 |
|
2377 |
|
2378 |
|
2379 class RThread; |
|
2380 class TFindHandleBase; |
|
2381 class TFindSemaphore; |
|
2382 /** |
|
2383 @publishedAll |
|
2384 @released |
|
2385 |
|
2386 A handle to an object. |
|
2387 |
|
2388 The class encapsulates the basic behaviour of a handle, hiding the |
|
2389 handle-number which identifies the object which the handle represents. |
|
2390 |
|
2391 The class is abstract in the sense that a RHandleBase object is never |
|
2392 explicitly instantiated. It is always a base class to a concrete handle class; |
|
2393 for example, RSemaphore, RThread, RProcess, RCriticalSection etc. |
|
2394 */ |
|
2395 class RHandleBase |
|
2396 { |
|
2397 public: |
|
2398 /** |
|
2399 @publishedAll |
|
2400 @released |
|
2401 |
|
2402 Read/Write attributes for the handle. |
|
2403 */ |
|
2404 enum TAttributes |
|
2405 { |
|
2406 EReadAccess=0x1, |
|
2407 EWriteAccess=0x2, |
|
2408 EDirectReadAccess=0x4, |
|
2409 EDirectWriteAccess=0x8, |
|
2410 }; |
|
2411 public: |
|
2412 inline RHandleBase(); |
|
2413 inline TInt Handle() const; |
|
2414 inline void SetHandle(TInt aHandle); |
|
2415 inline TInt SetReturnedHandle(TInt aHandleOrError); |
|
2416 static void DoExtendedClose(); |
|
2417 #ifndef __KERNEL_MODE__ |
|
2418 IMPORT_C void Close(); |
|
2419 IMPORT_C TName Name() const; |
|
2420 IMPORT_C TFullName FullName() const; |
|
2421 IMPORT_C void FullName(TDes& aName) const; |
|
2422 IMPORT_C void SetHandleNC(TInt aHandle); |
|
2423 IMPORT_C TInt Duplicate(const RThread& aSrc,TOwnerType aType=EOwnerProcess); |
|
2424 IMPORT_C void HandleInfo(THandleInfo* anInfo); |
|
2425 IMPORT_C TUint Attributes() const; |
|
2426 IMPORT_C TInt BTraceId() const; |
|
2427 IMPORT_C void NotifyDestruction(TRequestStatus& aStatus); /**< @internalTechnology */ |
|
2428 protected: |
|
2429 inline RHandleBase(TInt aHandle); |
|
2430 IMPORT_C TInt Open(const TFindHandleBase& aHandle,TOwnerType aType); |
|
2431 static TInt SetReturnedHandle(TInt aHandleOrError,RHandleBase& aHandle); |
|
2432 TInt OpenByName(const TDesC &aName,TOwnerType aOwnerType,TInt aObjectType); |
|
2433 #endif |
|
2434 private: |
|
2435 static void DoExtendedCloseL(); |
|
2436 protected: |
|
2437 TInt iHandle; |
|
2438 }; |
|
2439 |
|
2440 |
|
2441 |
|
2442 |
|
2443 class RMessagePtr2; |
|
2444 /** |
|
2445 @publishedAll |
|
2446 @released |
|
2447 |
|
2448 A handle to a semaphore. |
|
2449 |
|
2450 The semaphore itself is a Kernel side object. |
|
2451 |
|
2452 As with all handles, they should be closed after use. RHandleBase provides |
|
2453 the necessary Close() function, which should be called when the handle is |
|
2454 no longer required. |
|
2455 |
|
2456 @see RHandleBase::Close |
|
2457 */ |
|
2458 class RSemaphore : public RHandleBase |
|
2459 { |
|
2460 public: |
|
2461 #ifndef __KERNEL_MODE__ |
|
2462 inline TInt Open(const TFindSemaphore& aFind,TOwnerType aType=EOwnerProcess); |
|
2463 IMPORT_C TInt CreateLocal(TInt aCount,TOwnerType aType=EOwnerProcess); |
|
2464 IMPORT_C TInt CreateGlobal(const TDesC& aName,TInt aCount,TOwnerType aType=EOwnerProcess); |
|
2465 IMPORT_C TInt OpenGlobal(const TDesC& aName,TOwnerType aType=EOwnerProcess); |
|
2466 IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess); |
|
2467 IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess); |
|
2468 IMPORT_C void Wait(); |
|
2469 IMPORT_C TInt Wait(TInt aTimeout); // timeout in microseconds |
|
2470 IMPORT_C void Signal(); |
|
2471 IMPORT_C void Signal(TInt aCount); |
|
2472 #endif |
|
2473 }; |
|
2474 |
|
2475 |
|
2476 |
|
2477 |
|
2478 /** |
|
2479 @publishedAll |
|
2480 @released |
|
2481 |
|
2482 A fast semaphore. |
|
2483 |
|
2484 This is a layer over a standard semaphore, and only calls into the kernel side |
|
2485 if there is contention. |
|
2486 */ |
|
2487 class RFastLock : public RSemaphore |
|
2488 { |
|
2489 public: |
|
2490 inline RFastLock(); |
|
2491 IMPORT_C TInt CreateLocal(TOwnerType aType=EOwnerProcess); |
|
2492 IMPORT_C void Wait(); |
|
2493 IMPORT_C void Signal(); |
|
2494 private: |
|
2495 TInt iCount; |
|
2496 }; |
|
2497 |
|
2498 |
|
2499 |
|
2500 |
|
2501 /** |
|
2502 @publishedAll |
|
2503 @released |
|
2504 |
|
2505 A read-write lock. |
|
2506 |
|
2507 This is a lock for co-ordinating readers and writers to shared resources. |
|
2508 It is designed to allow multiple concurrent readers. |
|
2509 It is not a kernel side object and so does not inherit from RHandleBase. |
|
2510 */ |
|
2511 class RReadWriteLock |
|
2512 { |
|
2513 public: |
|
2514 enum TReadWriteLockPriority |
|
2515 { |
|
2516 /** Pending writers always get the lock before pending readers */ |
|
2517 EWriterPriority, |
|
2518 /** Lock is given alternately to pending readers and writers */ |
|
2519 EAlternatePriority, |
|
2520 /** Pending readers always get the lock before pending writers - beware writer starvation! */ |
|
2521 EReaderPriority, |
|
2522 }; |
|
2523 enum TReadWriteLockClientCategoryLimit |
|
2524 { |
|
2525 /** Maximum number of clients in each category: read locked, read lock pending, write lock pending */ |
|
2526 EReadWriteLockClientCategoryLimit = KMaxTUint16 |
|
2527 }; |
|
2528 |
|
2529 public: |
|
2530 inline RReadWriteLock(); |
|
2531 IMPORT_C TInt CreateLocal(TReadWriteLockPriority aPriority = EWriterPriority); |
|
2532 IMPORT_C void Close(); |
|
2533 |
|
2534 IMPORT_C void ReadLock(); |
|
2535 IMPORT_C void WriteLock(); |
|
2536 IMPORT_C TBool TryReadLock(); |
|
2537 IMPORT_C TBool TryWriteLock(); |
|
2538 IMPORT_C TBool TryUpgradeReadLock(); |
|
2539 IMPORT_C void DowngradeWriteLock(); |
|
2540 IMPORT_C void Unlock(); |
|
2541 |
|
2542 private: |
|
2543 RReadWriteLock(const RReadWriteLock& aLock); |
|
2544 RReadWriteLock& operator=(const RReadWriteLock& aLock); |
|
2545 |
|
2546 TInt UnlockWriter(); |
|
2547 TInt UnlockAlternate(); |
|
2548 TInt UnlockReader(); |
|
2549 |
|
2550 private: |
|
2551 volatile TUint64 iValues; // Bits 0-15: readers; bit 16: writer; bits 32-47: readersPending; bits 48-63: writersPending |
|
2552 TReadWriteLockPriority iPriority; |
|
2553 RSemaphore iReaderSem; |
|
2554 RSemaphore iWriterSem; |
|
2555 TUint32 iSpare[4]; // Reserved for future development |
|
2556 }; |
|
2557 |
|
2558 |
|
2559 |
|
2560 |
|
2561 /** |
|
2562 @publishedAll |
|
2563 @released |
|
2564 |
|
2565 The user-side handle to a logical channel. |
|
2566 |
|
2567 The class provides functions that are used to open a channel |
|
2568 to a device driver, and to make requests. A device driver provides |
|
2569 a derived class to give the user-side a tailored interface to the driver. |
|
2570 */ |
|
2571 class RBusLogicalChannel : public RHandleBase |
|
2572 { |
|
2573 public: |
|
2574 IMPORT_C TInt Open(RMessagePtr2 aMessage,TInt aParam,TOwnerType aType=EOwnerProcess); |
|
2575 IMPORT_C TInt Open(TInt aArgumentIndex, TOwnerType aType=EOwnerProcess); |
|
2576 protected: |
|
2577 inline TInt DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* anInfo, TOwnerType aType=EOwnerProcess, TBool aProtected=EFalse); |
|
2578 IMPORT_C void DoCancel(TUint aReqMask); |
|
2579 IMPORT_C void DoRequest(TInt aReqNo,TRequestStatus& aStatus); |
|
2580 IMPORT_C void DoRequest(TInt aReqNo,TRequestStatus& aStatus,TAny* a1); |
|
2581 IMPORT_C void DoRequest(TInt aReqNo,TRequestStatus& aStatus,TAny* a1,TAny* a2); |
|
2582 IMPORT_C TInt DoControl(TInt aFunction); |
|
2583 IMPORT_C TInt DoControl(TInt aFunction,TAny* a1); |
|
2584 IMPORT_C TInt DoControl(TInt aFunction,TAny* a1,TAny* a2); |
|
2585 inline TInt DoSvControl(TInt aFunction) { return DoControl(aFunction); } |
|
2586 inline TInt DoSvControl(TInt aFunction,TAny* a1) { return DoControl(aFunction, a1); } |
|
2587 inline TInt DoSvControl(TInt aFunction,TAny* a1,TAny* a2) { return DoControl(aFunction, a1, a2); } |
|
2588 private: |
|
2589 IMPORT_C TInt DoCreate(const TDesC& aDevice, const TVersion& aVer, TInt aUnit, const TDesC* aDriver, const TDesC8* aInfo, TInt aType); |
|
2590 private: |
|
2591 // Padding for Binary Compatibility purposes |
|
2592 TInt iPadding1; |
|
2593 TInt iPadding2; |
|
2594 }; |
|
2595 |
|
2596 |
|
2597 |
|
2598 |
|
2599 /** |
|
2600 @internalComponent |
|
2601 |
|
2602 Base class for memory allocators. |
|
2603 */ |
|
2604 // Put pure virtual functions into a separate base class so that vptr is at same |
|
2605 // place in both GCC98r2 and EABI builds. |
|
2606 class MAllocator |
|
2607 { |
|
2608 public: |
|
2609 virtual TAny* Alloc(TInt aSize)=0; |
|
2610 virtual void Free(TAny* aPtr)=0; |
|
2611 virtual TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0)=0; |
|
2612 virtual TInt AllocLen(const TAny* aCell) const =0; |
|
2613 virtual TInt Compress()=0; |
|
2614 virtual void Reset()=0; |
|
2615 virtual TInt AllocSize(TInt& aTotalAllocSize) const =0; |
|
2616 virtual TInt Available(TInt& aBiggestBlock) const =0; |
|
2617 virtual TInt DebugFunction(TInt aFunc, TAny* a1=NULL, TAny* a2=NULL)=0; |
|
2618 virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)=0; |
|
2619 }; |
|
2620 |
|
2621 |
|
2622 |
|
2623 |
|
2624 /** |
|
2625 @publishedAll |
|
2626 @released |
|
2627 |
|
2628 Base class for heaps. |
|
2629 */ |
|
2630 class RAllocator : public MAllocator |
|
2631 { |
|
2632 public: |
|
2633 |
|
2634 |
|
2635 /** |
|
2636 A set of heap allocation failure flags. |
|
2637 |
|
2638 This enumeration indicates how to simulate heap allocation failure. |
|
2639 |
|
2640 @see RAllocator::__DbgSetAllocFail() |
|
2641 */ |
|
2642 enum TAllocFail { |
|
2643 /** |
|
2644 Attempts to allocate from this heap fail at a random rate; |
|
2645 however, the interval pattern between failures is the same |
|
2646 every time simulation is started. |
|
2647 */ |
|
2648 ERandom, |
|
2649 |
|
2650 |
|
2651 /** |
|
2652 Attempts to allocate from this heap fail at a random rate. |
|
2653 The interval pattern between failures may be different every |
|
2654 time the simulation is started. |
|
2655 */ |
|
2656 ETrueRandom, |
|
2657 |
|
2658 |
|
2659 /** |
|
2660 Attempts to allocate from this heap fail at a rate aRate; |
|
2661 for example, if aRate is 3, allocation fails at every |
|
2662 third attempt. |
|
2663 */ |
|
2664 EDeterministic, |
|
2665 |
|
2666 |
|
2667 /** |
|
2668 Cancels simulated heap allocation failure. |
|
2669 */ |
|
2670 ENone, |
|
2671 |
|
2672 |
|
2673 /** |
|
2674 An allocation from this heap will fail after the next aRate - 1 |
|
2675 allocation attempts. For example, if aRate = 1 then the next |
|
2676 attempt to allocate from this heap will fail. |
|
2677 */ |
|
2678 EFailNext, |
|
2679 |
|
2680 /** |
|
2681 Cancels simulated heap allocation failure, and sets |
|
2682 the nesting level for all allocated cells to zero. |
|
2683 */ |
|
2684 EReset, |
|
2685 |
|
2686 /** |
|
2687 aBurst allocations from this heap fail at a random rate; |
|
2688 however, the interval pattern between failures is the same |
|
2689 every time the simulation is started. |
|
2690 */ |
|
2691 EBurstRandom, |
|
2692 |
|
2693 |
|
2694 /** |
|
2695 aBurst allocations from this heap fail at a random rate. |
|
2696 The interval pattern between failures may be different every |
|
2697 time the simulation is started. |
|
2698 */ |
|
2699 EBurstTrueRandom, |
|
2700 |
|
2701 |
|
2702 /** |
|
2703 aBurst allocations from this heap fail at a rate aRate. |
|
2704 For example, if aRate is 10 and aBurst is 2, then 2 allocations |
|
2705 will fail at every tenth attempt. |
|
2706 */ |
|
2707 EBurstDeterministic, |
|
2708 |
|
2709 /** |
|
2710 aBurst allocations from this heap will fail after the next aRate - 1 |
|
2711 allocation attempts have occurred. For example, if aRate = 1 and |
|
2712 aBurst = 3 then the next 3 attempts to allocate from this heap will fail. |
|
2713 */ |
|
2714 EBurstFailNext, |
|
2715 |
|
2716 /** |
|
2717 Use this to determine how many times the current debug |
|
2718 failure mode has failed so far. |
|
2719 @see RAllocator::__DbgCheckFailure() |
|
2720 */ |
|
2721 ECheckFailure, |
|
2722 }; |
|
2723 |
|
2724 |
|
2725 /** |
|
2726 Heap debug checking type flag. |
|
2727 */ |
|
2728 enum TDbgHeapType { |
|
2729 /** |
|
2730 The heap is a user heap. |
|
2731 */ |
|
2732 EUser, |
|
2733 |
|
2734 /** |
|
2735 The heap is the Kernel heap. |
|
2736 */ |
|
2737 EKernel |
|
2738 }; |
|
2739 |
|
2740 |
|
2741 enum TAllocDebugOp {ECount, EMarkStart, EMarkEnd, ECheck, ESetFail, ECopyDebugInfo, ESetBurstFail}; |
|
2742 |
|
2743 |
|
2744 /** |
|
2745 Flags controlling reallocation. |
|
2746 */ |
|
2747 enum TReAllocMode { |
|
2748 /** |
|
2749 A reallocation of a cell must not change |
|
2750 the start address of the cell. |
|
2751 */ |
|
2752 ENeverMove=1, |
|
2753 |
|
2754 /** |
|
2755 Allows the start address of the cell to change |
|
2756 if the cell shrinks in size. |
|
2757 */ |
|
2758 EAllowMoveOnShrink=2 |
|
2759 }; |
|
2760 |
|
2761 |
|
2762 enum TFlags {ESingleThreaded=1, EFixedSize=2, ETraceAllocs=4, EMonitorMemory=8,}; |
|
2763 struct SCheckInfo {TBool iAll; TInt iCount; const TDesC8* iFileName; TInt iLineNum;}; |
|
2764 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS |
|
2765 struct SRAllocatorBurstFail {TInt iBurst; TInt iRate; TInt iUnused[2];}; |
|
2766 #endif |
|
2767 enum {EMaxHandles=32}; |
|
2768 |
|
2769 public: |
|
2770 inline RAllocator(); |
|
2771 #ifndef __KERNEL_MODE__ |
|
2772 IMPORT_C TInt Open(); |
|
2773 IMPORT_C void Close(); |
|
2774 IMPORT_C TAny* AllocZ(TInt aSize); |
|
2775 IMPORT_C TAny* AllocZL(TInt aSize); |
|
2776 IMPORT_C TAny* AllocL(TInt aSize); |
|
2777 IMPORT_C TAny* AllocLC(TInt aSize); |
|
2778 IMPORT_C void FreeZ(TAny*& aCell); |
|
2779 IMPORT_C TAny* ReAllocL(TAny* aCell, TInt aSize, TInt aMode=0); |
|
2780 IMPORT_C TInt Count() const; |
|
2781 IMPORT_C TInt Count(TInt& aFreeCount) const; |
|
2782 #endif |
|
2783 UIMPORT_C void Check() const; |
|
2784 UIMPORT_C void __DbgMarkStart(); |
|
2785 UIMPORT_C TUint32 __DbgMarkEnd(TInt aCount); |
|
2786 UIMPORT_C TInt __DbgMarkCheck(TBool aCountAll, TInt aCount, const TDesC8& aFileName, TInt aLineNum); |
|
2787 inline void __DbgMarkCheck(TBool aCountAll, TInt aCount, const TUint8* aFileName, TInt aLineNum); |
|
2788 UIMPORT_C void __DbgSetAllocFail(TAllocFail aType, TInt aRate); |
|
2789 UIMPORT_C void __DbgSetBurstAllocFail(TAllocFail aType, TUint aRate, TUint aBurst); |
|
2790 UIMPORT_C TUint __DbgCheckFailure(); |
|
2791 protected: |
|
2792 UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1); |
|
2793 #ifndef __KERNEL_MODE__ |
|
2794 IMPORT_C virtual void DoClose(); |
|
2795 #endif |
|
2796 protected: |
|
2797 TInt iAccessCount; |
|
2798 TInt iHandleCount; |
|
2799 TInt* iHandles; |
|
2800 TUint32 iFlags; |
|
2801 TInt iCellCount; |
|
2802 TInt iTotalAllocSize; |
|
2803 }; |
|
2804 |
|
2805 |
|
2806 |
|
2807 |
|
2808 class UserHeap; |
|
2809 /** |
|
2810 @publishedAll |
|
2811 @released |
|
2812 |
|
2813 Represents the default implementation for a heap. |
|
2814 |
|
2815 The default implementation uses an address-ordered first fit type algorithm. |
|
2816 |
|
2817 The heap itself is contained in a chunk and may be the only occupant of the |
|
2818 chunk or may share the chunk with the program stack. |
|
2819 |
|
2820 The class contains member functions for allocating, adjusting, freeing individual |
|
2821 cells and generally managing the heap. |
|
2822 |
|
2823 The class is not a handle in the same sense that RChunk is a handle; i.e. |
|
2824 there is no Kernel object which corresponds to the heap. |
|
2825 */ |
|
2826 class RHeap : public RAllocator |
|
2827 { |
|
2828 public: |
|
2829 /** |
|
2830 The structure of a heap cell header for a heap cell on the free list. |
|
2831 */ |
|
2832 struct SCell { |
|
2833 /** |
|
2834 The length of the cell, which includes the length of |
|
2835 this header. |
|
2836 */ |
|
2837 TInt len; |
|
2838 |
|
2839 |
|
2840 /** |
|
2841 A pointer to the next cell in the free list. |
|
2842 */ |
|
2843 SCell* next; |
|
2844 }; |
|
2845 |
|
2846 |
|
2847 /** |
|
2848 The structure of a heap cell header for an allocated heap cell in a debug build. |
|
2849 */ |
|
2850 struct SDebugCell { |
|
2851 /** |
|
2852 The length of the cell, which includes the length of |
|
2853 this header. |
|
2854 */ |
|
2855 TInt len; |
|
2856 |
|
2857 |
|
2858 /** |
|
2859 The nested level. |
|
2860 */ |
|
2861 TInt nestingLevel; |
|
2862 |
|
2863 |
|
2864 /** |
|
2865 The cumulative number of allocated cells |
|
2866 */ |
|
2867 TInt allocCount; |
|
2868 }; |
|
2869 |
|
2870 /** |
|
2871 @internalComponent |
|
2872 */ |
|
2873 struct SHeapCellInfo { RHeap* iHeap; TInt iTotalAlloc; TInt iTotalAllocSize; TInt iTotalFree; TInt iLevelAlloc; SDebugCell* iStranded; }; |
|
2874 |
|
2875 /** |
|
2876 @internalComponent |
|
2877 */ |
|
2878 struct _s_align {char c; double d;}; |
|
2879 |
|
2880 /** |
|
2881 The default cell alignment. |
|
2882 */ |
|
2883 enum {ECellAlignment = sizeof(_s_align)-sizeof(double)}; |
|
2884 |
|
2885 /** |
|
2886 Size of a free cell header. |
|
2887 */ |
|
2888 enum {EFreeCellSize = sizeof(SCell)}; |
|
2889 |
|
2890 |
|
2891 #ifdef _DEBUG |
|
2892 /** |
|
2893 Size of an allocated cell header in a debug build. |
|
2894 */ |
|
2895 enum {EAllocCellSize = sizeof(SDebugCell)}; |
|
2896 #else |
|
2897 /** |
|
2898 Size of an allocated cell header in a release build. |
|
2899 */ |
|
2900 enum {EAllocCellSize = sizeof(SCell*)}; |
|
2901 #endif |
|
2902 |
|
2903 |
|
2904 /** |
|
2905 @internalComponent |
|
2906 */ |
|
2907 enum TDebugOp {EWalk=128}; |
|
2908 |
|
2909 |
|
2910 /** |
|
2911 @internalComponent |
|
2912 */ |
|
2913 enum TCellType |
|
2914 {EGoodAllocatedCell, EGoodFreeCell, EBadAllocatedCellSize, EBadAllocatedCellAddress, |
|
2915 EBadFreeCellAddress, EBadFreeCellSize}; |
|
2916 |
|
2917 |
|
2918 /** |
|
2919 @internalComponent |
|
2920 */ |
|
2921 enum TDebugHeapId {EUser=0, EKernel=1}; |
|
2922 |
|
2923 /** |
|
2924 @internalComponent |
|
2925 */ |
|
2926 enum TDefaultShrinkRatios {EShrinkRatio1=256, EShrinkRatioDflt=512}; |
|
2927 |
|
2928 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS |
|
2929 /** |
|
2930 @internalComponent |
|
2931 */ |
|
2932 #else |
|
2933 private: |
|
2934 #endif |
|
2935 typedef void (*TWalkFunc)(TAny*, TCellType, TAny*, TInt); |
|
2936 |
|
2937 public: |
|
2938 UIMPORT_C virtual TAny* Alloc(TInt aSize); |
|
2939 UIMPORT_C virtual void Free(TAny* aPtr); |
|
2940 UIMPORT_C virtual TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0); |
|
2941 UIMPORT_C virtual TInt AllocLen(const TAny* aCell) const; |
|
2942 #ifndef __KERNEL_MODE__ |
|
2943 UIMPORT_C virtual TInt Compress(); |
|
2944 UIMPORT_C virtual void Reset(); |
|
2945 UIMPORT_C virtual TInt AllocSize(TInt& aTotalAllocSize) const; |
|
2946 UIMPORT_C virtual TInt Available(TInt& aBiggestBlock) const; |
|
2947 #endif |
|
2948 UIMPORT_C virtual TInt DebugFunction(TInt aFunc, TAny* a1=NULL, TAny* a2=NULL); |
|
2949 protected: |
|
2950 UIMPORT_C virtual TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1); |
|
2951 public: |
|
2952 UIMPORT_C RHeap(TInt aMaxLength, TInt aAlign=0, TBool aSingleThread=ETrue); |
|
2953 UIMPORT_C RHeap(TInt aChunkHandle, TInt aOffset, TInt aMinLength, TInt aMaxLength, TInt aGrowBy, TInt aAlign=0, TBool aSingleThread=EFalse); |
|
2954 UIMPORT_C TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW; |
|
2955 inline void operator delete(TAny* aPtr, TAny* aBase); |
|
2956 inline TUint8* Base() const; |
|
2957 inline TInt Size() const; |
|
2958 inline TInt MaxLength() const; |
|
2959 inline TInt Align(TInt a) const; |
|
2960 inline const TAny* Align(const TAny* a) const; |
|
2961 inline TBool IsLastCell(const SCell* aCell) const; |
|
2962 inline void Lock() const; |
|
2963 inline void Unlock() const; |
|
2964 inline TInt ChunkHandle() const; |
|
2965 protected: |
|
2966 inline RHeap(); |
|
2967 void Initialise(); |
|
2968 SCell* DoAlloc(TInt aSize, SCell*& aLastFree); |
|
2969 void DoFree(SCell* pC); |
|
2970 TInt TryToGrowHeap(TInt aSize, SCell* aLastFree); |
|
2971 inline void FindFollowingFreeCell(SCell* aCell, SCell*& pPrev, SCell*& aNext); |
|
2972 TInt TryToGrowCell(SCell* pC, SCell* pP, SCell* pE, TInt aSize); |
|
2973 TInt Reduce(SCell* aCell); |
|
2974 UIMPORT_C SCell* GetAddress(const TAny* aCell) const; |
|
2975 void CheckCell(const SCell* aCell) const; |
|
2976 void Walk(TWalkFunc aFunc, TAny* aPtr); |
|
2977 static void WalkCheckCell(TAny* aPtr, TCellType aType, TAny* aCell, TInt aLen); |
|
2978 TInt DoCountAllocFree(TInt& aFree); |
|
2979 TInt DoCheckHeap(SCheckInfo* aInfo); |
|
2980 void DoMarkStart(); |
|
2981 TUint32 DoMarkEnd(TInt aExpected); |
|
2982 void DoSetAllocFail(TAllocFail aType, TInt aRate); |
|
2983 TBool CheckForSimulatedAllocFail(); |
|
2984 inline TInt SetBrk(TInt aBrk); |
|
2985 inline TAny* ReAllocImpl(TAny* aPtr, TInt aSize, TInt aMode); |
|
2986 void DoSetAllocFail(TAllocFail aType, TInt aRate, TUint aBurst); |
|
2987 protected: |
|
2988 TInt iMinLength; |
|
2989 TInt iMaxLength; |
|
2990 TInt iOffset; |
|
2991 TInt iGrowBy; |
|
2992 TInt iChunkHandle; |
|
2993 RFastLock iLock; |
|
2994 TUint8* iBase; |
|
2995 TUint8* iTop; |
|
2996 TInt iAlign; |
|
2997 TInt iMinCell; |
|
2998 TInt iPageSize; |
|
2999 SCell iFree; |
|
3000 protected: |
|
3001 TInt iNestingLevel; |
|
3002 TInt iAllocCount; |
|
3003 TAllocFail iFailType; |
|
3004 TInt iFailRate; |
|
3005 TBool iFailed; |
|
3006 TInt iFailAllocCount; |
|
3007 TInt iRand; |
|
3008 TAny* iTestData; |
|
3009 |
|
3010 friend class UserHeap; |
|
3011 }; |
|
3012 |
|
3013 |
|
3014 |
|
3015 |
|
3016 |
|
3017 class OnlyCreateWithNull; |
|
3018 |
|
3019 /** @internalTechnology */ |
|
3020 typedef void (OnlyCreateWithNull::* __NullPMF)(); |
|
3021 |
|
3022 /** @internalTechnology */ |
|
3023 class OnlyCreateWithNull |
|
3024 { |
|
3025 public: |
|
3026 inline OnlyCreateWithNull(__NullPMF /*aPointerToNull*/) {} |
|
3027 }; |
|
3028 |
|
3029 /** |
|
3030 @publishedAll |
|
3031 @released |
|
3032 |
|
3033 A handle to a message sent by the client to the server. |
|
3034 |
|
3035 A server's interaction with its clients is channelled through an RMessagePtr2 |
|
3036 object, which acts as a handle to a message sent by the client. |
|
3037 The details of the original message are kept by the kernel allowing it enforce |
|
3038 correct usage of the member functions of this class. |
|
3039 |
|
3040 @see RMessage2 |
|
3041 */ |
|
3042 class RMessagePtr2 |
|
3043 { |
|
3044 public: |
|
3045 inline RMessagePtr2(); |
|
3046 inline TBool IsNull() const; |
|
3047 inline TInt Handle() const; |
|
3048 #ifndef __KERNEL_MODE__ |
|
3049 IMPORT_C void Complete(TInt aReason) const; |
|
3050 IMPORT_C void Complete(RHandleBase aHandle) const; |
|
3051 IMPORT_C TInt GetDesLength(TInt aParam) const; |
|
3052 IMPORT_C TInt GetDesLengthL(TInt aParam) const; |
|
3053 IMPORT_C TInt GetDesMaxLength(TInt aParam) const; |
|
3054 IMPORT_C TInt GetDesMaxLengthL(TInt aParam) const; |
|
3055 IMPORT_C void ReadL(TInt aParam,TDes8& aDes,TInt aOffset=0) const; |
|
3056 IMPORT_C void ReadL(TInt aParam,TDes16 &aDes,TInt aOffset=0) const; |
|
3057 IMPORT_C void WriteL(TInt aParam,const TDesC8& aDes,TInt aOffset=0) const; |
|
3058 IMPORT_C void WriteL(TInt aParam,const TDesC16& aDes,TInt aOffset=0) const; |
|
3059 IMPORT_C TInt Read(TInt aParam,TDes8& aDes,TInt aOffset=0) const; |
|
3060 IMPORT_C TInt Read(TInt aParam,TDes16 &aDes,TInt aOffset=0) const; |
|
3061 IMPORT_C TInt Write(TInt aParam,const TDesC8& aDes,TInt aOffset=0) const; |
|
3062 IMPORT_C TInt Write(TInt aParam,const TDesC16& aDes,TInt aOffset=0) const; |
|
3063 IMPORT_C void Panic(const TDesC& aCategory,TInt aReason) const; |
|
3064 IMPORT_C void Kill(TInt aReason) const; |
|
3065 IMPORT_C void Terminate(TInt aReason) const; |
|
3066 IMPORT_C TInt SetProcessPriority(TProcessPriority aPriority) const; |
|
3067 inline void SetProcessPriorityL(TProcessPriority aPriority) const; |
|
3068 IMPORT_C TInt Client(RThread& aClient, TOwnerType aOwnerType=EOwnerProcess) const; |
|
3069 inline void ClientL(RThread& aClient, TOwnerType aOwnerType=EOwnerProcess) const; |
|
3070 IMPORT_C TUint ClientProcessFlags() const; |
|
3071 IMPORT_C const TRequestStatus* ClientStatus() const; |
|
3072 IMPORT_C TBool ClientIsRealtime() const; |
|
3073 |
|
3074 /** |
|
3075 Return the Secure ID of the process which sent this message. |
|
3076 |
|
3077 If an intended use of this method is to check that the Secure ID is |
|
3078 a given value, then the use of a TSecurityPolicy object should be |
|
3079 considered. E.g. Instead of something like: |
|
3080 |
|
3081 @code |
|
3082 RMessagePtr2& message; |
|
3083 TInt error = message.SecureId()==KRequiredSecureId ? KErrNone : KErrPermissionDenied; |
|
3084 @endcode |
|
3085 |
|
3086 this could be used; |
|
3087 |
|
3088 @code |
|
3089 RMessagePtr2& message; |
|
3090 static _LIT_SECURITY_POLICY_S0(mySidPolicy, KRequiredSecureId); |
|
3091 TBool pass = mySidPolicy().CheckPolicy(message); |
|
3092 @endcode |
|
3093 |
|
3094 This has the benefit that the TSecurityPolicy::CheckPolicy methods are |
|
3095 configured by the system wide Platform Security configuration. I.e. are |
|
3096 capable of emitting diagnostic messages when a check fails and/or the |
|
3097 check can be forced to always pass. |
|
3098 |
|
3099 @see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const |
|
3100 @see _LIT_SECURITY_POLICY_S0 |
|
3101 |
|
3102 @return The Secure ID. |
|
3103 |
|
3104 @publishedAll |
|
3105 @released |
|
3106 */ |
|
3107 IMPORT_C TSecureId SecureId() const; |
|
3108 |
|
3109 /** |
|
3110 Return the Vendor ID of the process which sent this message. |
|
3111 |
|
3112 If an intended use of this method is to check that the Vendor ID is |
|
3113 a given value, then the use of a TSecurityPolicy object should be |
|
3114 considered. E.g. Instead of something like: |
|
3115 |
|
3116 @code |
|
3117 RMessagePtr2& message; |
|
3118 TInt error = message.VendorId()==KRequiredVendorId ? KErrNone : KErrPermissionDenied; |
|
3119 @endcode |
|
3120 |
|
3121 this could be used; |
|
3122 |
|
3123 @code |
|
3124 RMessagePtr2& message; |
|
3125 static _LIT_SECURITY_POLICY_V0(myVidPolicy, KRequiredVendorId); |
|
3126 TBool pass = myVidPolicy().CheckPolicy(message); |
|
3127 @endcode |
|
3128 |
|
3129 This has the benefit that the TSecurityPolicy::CheckPolicy methods are |
|
3130 configured by the system wide Platform Security configuration. I.e. are |
|
3131 capable of emitting diagnostic messages when a check fails and/or the |
|
3132 check can be forced to always pass. |
|
3133 |
|
3134 @see TSecurityPolicy::CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const |
|
3135 @see _LIT_SECURITY_POLICY_V0 |
|
3136 |
|
3137 @return The Vendor ID. |
|
3138 @publishedAll |
|
3139 @released |
|
3140 */ |
|
3141 IMPORT_C TVendorId VendorId() const; |
|
3142 |
|
3143 /** |
|
3144 Check if the process which sent this message has a given capability. |
|
3145 |
|
3146 When a check fails the action taken is determined by the system wide Platform Security |
|
3147 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. |
|
3148 If PlatSecEnforcement is OFF, then this function will return ETrue even though the |
|
3149 check failed. |
|
3150 |
|
3151 @param aCapability The capability to test. |
|
3152 @param aDiagnostic A string that will be emitted along with any diagnostic message |
|
3153 that may be issued if the test finds the capability is not present. |
|
3154 This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro |
|
3155 which enables it to be easily removed from the system. |
|
3156 @return ETrue if process which sent this message has the capability, EFalse otherwise. |
|
3157 @publishedAll |
|
3158 @released |
|
3159 */ |
|
3160 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3161 inline TBool HasCapability(TCapability aCapability, const char* aDiagnostic=0) const; |
|
3162 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3163 // Only available to NULL arguments |
|
3164 inline TBool HasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3165 #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3166 // For things using KSuppressPlatSecDiagnostic |
|
3167 inline TBool HasCapability(TCapability aCapability, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3168 #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3169 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3170 |
|
3171 /** |
|
3172 Check if the process which sent this message has a given capability. |
|
3173 |
|
3174 When a check fails the action taken is determined by the system wide Platform Security |
|
3175 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. |
|
3176 If PlatSecEnforcement is OFF, then this function will not leave even though the |
|
3177 check failed. |
|
3178 |
|
3179 @param aCapability The capability to test. |
|
3180 @param aDiagnosticMessage A string that will be emitted along with any diagnostic message |
|
3181 that may be issued if the test finds the capability is not present. |
|
3182 This string must be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro |
|
3183 which enables it to be easily removed from the system. |
|
3184 @leave KErrPermissionDenied, if the process does not have the capability. |
|
3185 @publishedAll |
|
3186 @released |
|
3187 */ |
|
3188 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3189 inline void HasCapabilityL(TCapability aCapability, const char* aDiagnosticMessage=0) const; |
|
3190 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3191 // Only available to NULL arguments |
|
3192 inline void HasCapabilityL(TCapability aCapability, OnlyCreateWithNull aDiagnosticMessage=NULL) const; |
|
3193 #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3194 // For things using KSuppressPlatSecDiagnostic |
|
3195 inline void HasCapabilityL(TCapability aCapability, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3196 #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3197 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3198 |
|
3199 /** |
|
3200 Check if the process which sent this message has both of the given capabilities. |
|
3201 |
|
3202 When a check fails the action taken is determined by the system wide Platform Security |
|
3203 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. |
|
3204 If PlatSecEnforcement is OFF, then this function will return ETrue even though the |
|
3205 check failed. |
|
3206 |
|
3207 @param aCapability1 The first capability to test. |
|
3208 @param aCapability2 The second capability to test. |
|
3209 @param aDiagnostic A string that will be emitted along with any diagnostic message |
|
3210 that may be issued if the test finds a capability is not present. |
|
3211 This string should be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro |
|
3212 which enables it to be easily removed from the system. |
|
3213 @return ETrue if the process which sent this message has both the capabilities, EFalse otherwise. |
|
3214 @publishedAll |
|
3215 @released |
|
3216 */ |
|
3217 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3218 inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, const char* aDiagnostic=0) const; |
|
3219 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3220 // Only available to NULL arguments |
|
3221 inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3222 #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3223 // For things using KSuppressPlatSecDiagnostic |
|
3224 inline TBool HasCapability(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3225 #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3226 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3227 |
|
3228 /** |
|
3229 Check if the process which sent this message has both of the given capabilities. |
|
3230 |
|
3231 When a check fails the action taken is determined by the system wide Platform Security |
|
3232 configuration. If PlatSecDiagnostics is ON, then a diagnostic message is emitted. |
|
3233 If PlatSecEnforcement is OFF, then this function will not leave even though the |
|
3234 check failed. |
|
3235 |
|
3236 @param aCapability1 The first capability to test. |
|
3237 @param aCapability2 The second capability to test. |
|
3238 @param aDiagnosticMessage A string that will be emitted along with any diagnostic message |
|
3239 that may be issued if the test finds a capability is not present. |
|
3240 This string should be enclosed in the __PLATSEC_DIAGNOSTIC_STRING macro |
|
3241 which enables it to be easily removed from the system. |
|
3242 @leave KErrPermissionDenied, if the process does not have the capabilities. |
|
3243 @publishedAll |
|
3244 @released |
|
3245 */ |
|
3246 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3247 inline void HasCapabilityL(TCapability aCapability1, TCapability aCapability2, const char* aDiagnosticMessage=0) const; |
|
3248 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3249 // Only available to NULL arguments |
|
3250 inline void HasCapabilityL(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnosticMessage=NULL) const; |
|
3251 #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3252 // For things using KSuppressPlatSecDiagnostic |
|
3253 inline void HasCapabilityL(TCapability aCapability1, TCapability aCapability2, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3254 #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3255 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3256 |
|
3257 /** |
|
3258 @deprecated Use SecureId() |
|
3259 */ |
|
3260 inline TUid Identity() const { return SecureId(); } |
|
3261 #endif |
|
3262 |
|
3263 private: |
|
3264 // Implementations of functions with diagnostics |
|
3265 IMPORT_C TBool DoHasCapability(TCapability aCapability, const char* aDiagnostic) const; |
|
3266 IMPORT_C TBool DoHasCapability(TCapability aCapability) const; |
|
3267 IMPORT_C TBool DoHasCapability(TCapability aCapability, TCapability aCapability2, const char* aDiagnostic) const; |
|
3268 IMPORT_C TBool DoHasCapability(TCapability aCapability, TCapability aCapability2) const; |
|
3269 |
|
3270 protected: |
|
3271 TInt iHandle; |
|
3272 }; |
|
3273 inline TBool operator==(RMessagePtr2 aLeft,RMessagePtr2 aRight); |
|
3274 inline TBool operator!=(RMessagePtr2 aLeft,RMessagePtr2 aRight); |
|
3275 |
|
3276 class CSession2; |
|
3277 |
|
3278 #define __IPC_V2_PRESENT__ |
|
3279 |
|
3280 /** |
|
3281 @publishedAll |
|
3282 @released |
|
3283 |
|
3284 An object that encapsulates the details of a client request. |
|
3285 */ |
|
3286 class RMessage2 : public RMessagePtr2 |
|
3287 { |
|
3288 friend class CServer2; |
|
3289 public: |
|
3290 |
|
3291 /** |
|
3292 Defines internal message types. |
|
3293 */ |
|
3294 enum TSessionMessages { |
|
3295 /** |
|
3296 A message type used internally that means connect. |
|
3297 */ |
|
3298 EConnect=-1, |
|
3299 |
|
3300 /** |
|
3301 A message type used internally that means disconnect. |
|
3302 */ |
|
3303 EDisConnect=-2 |
|
3304 }; |
|
3305 public: |
|
3306 inline RMessage2(); |
|
3307 #ifndef __KERNEL_MODE__ |
|
3308 IMPORT_C explicit RMessage2(const RMessagePtr2& aPtr); |
|
3309 void SetAuthorised() const; |
|
3310 void ClearAuthorised() const; |
|
3311 TBool Authorised() const; |
|
3312 #endif |
|
3313 inline TInt Function() const; |
|
3314 inline TInt Int0() const; |
|
3315 inline TInt Int1() const; |
|
3316 inline TInt Int2() const; |
|
3317 inline TInt Int3() const; |
|
3318 inline const TAny* Ptr0() const; |
|
3319 inline const TAny* Ptr1() const; |
|
3320 inline const TAny* Ptr2() const; |
|
3321 inline const TAny* Ptr3() const; |
|
3322 inline CSession2* Session() const; |
|
3323 protected: |
|
3324 |
|
3325 /** |
|
3326 The request type. |
|
3327 */ |
|
3328 TInt iFunction; |
|
3329 |
|
3330 /** |
|
3331 A copy of the message arguments. |
|
3332 */ |
|
3333 TInt iArgs[KMaxMessageArguments]; |
|
3334 private: |
|
3335 TInt iSpare1; |
|
3336 protected: |
|
3337 /** |
|
3338 @internalComponent |
|
3339 */ |
|
3340 const TAny* iSessionPtr; |
|
3341 private: |
|
3342 mutable TInt iFlags;// Currently only used for *Authorised above |
|
3343 TInt iSpare3; // Reserved for future use |
|
3344 |
|
3345 friend class RMessage; |
|
3346 }; |
|
3347 |
|
3348 |
|
3349 |
|
3350 |
|
3351 /** |
|
3352 @publishedAll |
|
3353 @released |
|
3354 |
|
3355 Defines an 8-bit modifiable buffer descriptor to contain passwords when dealing |
|
3356 with password security support in a file server session. |
|
3357 |
|
3358 The descriptor takes a maximum length of KMaxMediaPassword. |
|
3359 |
|
3360 @see KMaxMediaPassword |
|
3361 */ |
|
3362 typedef TBuf8<KMaxMediaPassword> TMediaPassword; // 128 bit |
|
3363 |
|
3364 |
|
3365 |
|
3366 /** |
|
3367 @publishedPartner |
|
3368 @prototype |
|
3369 A configuration flag for the shared chunk buffer configuration class (used by the multimedia device drivers). This being |
|
3370 set signifies that a buffer offset list follows the buffer configuration class. This list holds the offset of each buffer. |
|
3371 */ |
|
3372 const TUint KScFlagBufOffsetListInUse=0x00000001; |
|
3373 |
|
3374 /** |
|
3375 @publishedPartner |
|
3376 @prototype |
|
3377 A configuration flag for the shared chunk buffer configuration class (used by the multimedia device drivers). This being |
|
3378 set is a suggestion that the shared chunk should be configured leaving guard pages around each buffers. |
|
3379 */ |
|
3380 const TUint KScFlagUseGuardPages=0x00000002; |
|
3381 |
|
3382 /** |
|
3383 @publishedPartner |
|
3384 @prototype |
|
3385 The shared chunk buffer configuration class (used by the multimedia device drivers). This is used to hold information |
|
3386 on the current buffer configuration within a shared chunk. |
|
3387 */ |
|
3388 class TSharedChunkBufConfigBase |
|
3389 { |
|
3390 public: |
|
3391 inline TSharedChunkBufConfigBase(); |
|
3392 public: |
|
3393 /** The number of buffers. */ |
|
3394 TInt iNumBuffers; |
|
3395 /** The size of each buffer in bytes. */ |
|
3396 TInt iBufferSizeInBytes; |
|
3397 /** Reserved field. */ |
|
3398 TInt iReserved1; |
|
3399 /** Shared chunk buffer flag settings. */ |
|
3400 TUint iFlags; |
|
3401 }; |
|
3402 |
|
3403 |
|
3404 /** Maximum size of capability set |
|
3405 |
|
3406 @internalTechnology |
|
3407 */ |
|
3408 const TInt KCapabilitySetMaxSize = (((TInt)ECapability_HardLimit + 7)>>3); |
|
3409 |
|
3410 /** Maximum size of any future extension to TSecurityPolicy |
|
3411 |
|
3412 @internalTechnology |
|
3413 */ |
|
3414 const TInt KMaxSecurityPolicySize = KCapabilitySetMaxSize + 3*sizeof(TUint32); |
|
3415 |
|
3416 |
|
3417 /** Class representing an arbitrary set of capabilities. |
|
3418 |
|
3419 This class can only contain capabilities supported by the current OS version. |
|
3420 |
|
3421 @publishedAll |
|
3422 @released |
|
3423 */ |
|
3424 class TCapabilitySet |
|
3425 { |
|
3426 public: |
|
3427 inline TCapabilitySet(); |
|
3428 inline TCapabilitySet(TCapability aCapability); |
|
3429 IMPORT_C TCapabilitySet(TCapability aCapability1, TCapability aCapability2); |
|
3430 IMPORT_C void SetEmpty(); |
|
3431 inline void Set(TCapability aCapability); |
|
3432 inline void Set(TCapability aCapability1, TCapability aCapability2); |
|
3433 IMPORT_C void SetAllSupported(); |
|
3434 IMPORT_C void AddCapability(TCapability aCapability); |
|
3435 IMPORT_C void RemoveCapability(TCapability aCapability); |
|
3436 IMPORT_C void Union(const TCapabilitySet& aCapabilities); |
|
3437 IMPORT_C void Intersection(const TCapabilitySet& aCapabilities); |
|
3438 IMPORT_C void Remove(const TCapabilitySet& aCapabilities); |
|
3439 IMPORT_C TBool HasCapability(TCapability aCapability) const; |
|
3440 IMPORT_C TBool HasCapabilities(const TCapabilitySet& aCapabilities) const; |
|
3441 |
|
3442 /** |
|
3443 Make this set consist of the capabilities which are disabled on this platform. |
|
3444 @internalTechnology |
|
3445 */ |
|
3446 IMPORT_C void SetDisabled(); |
|
3447 /** |
|
3448 @internalComponent |
|
3449 */ |
|
3450 TBool NotEmpty() const; |
|
3451 |
|
3452 private: |
|
3453 TUint32 iCaps[KCapabilitySetMaxSize / sizeof(TUint32)]; |
|
3454 }; |
|
3455 |
|
3456 #ifndef __SECURITY_INFO_DEFINED__ |
|
3457 #define __SECURITY_INFO_DEFINED__ |
|
3458 /** |
|
3459 @internalTechnology |
|
3460 */ |
|
3461 struct SCapabilitySet |
|
3462 { |
|
3463 enum {ENCapW=2}; |
|
3464 |
|
3465 inline void AddCapability(TCapability aCap1) {((TCapabilitySet*)this)->AddCapability(aCap1);} |
|
3466 inline void Remove(const SCapabilitySet& aCaps) {((TCapabilitySet*)this)->Remove(*((TCapabilitySet*)&aCaps));} |
|
3467 inline TBool NotEmpty() const {return ((TCapabilitySet*)this)->NotEmpty();} |
|
3468 |
|
3469 inline const TUint32& operator[] (TInt aIndex) const { return iCaps[aIndex]; } |
|
3470 inline TUint32& operator[] (TInt aIndex) { return iCaps[aIndex]; } |
|
3471 |
|
3472 TUint32 iCaps[ENCapW]; |
|
3473 }; |
|
3474 |
|
3475 /** |
|
3476 @internalTechnology |
|
3477 */ |
|
3478 struct SSecurityInfo |
|
3479 { |
|
3480 TUint32 iSecureId; |
|
3481 TUint32 iVendorId; |
|
3482 SCapabilitySet iCaps; // Capabilities re. platform security |
|
3483 }; |
|
3484 |
|
3485 #endif |
|
3486 |
|
3487 /** Define this macro to reference the set of all capabilities. |
|
3488 @internalTechnology |
|
3489 */ |
|
3490 #ifdef __REFERENCE_ALL_SUPPORTED_CAPABILITIES__ |
|
3491 |
|
3492 extern const SCapabilitySet AllSupportedCapabilities; |
|
3493 |
|
3494 #endif //__REFERENCE_ALL_SUPPORTED_CAPABILITIES__ |
|
3495 |
|
3496 /** Define this macro to include the set of all capabilities. |
|
3497 @internalTechnology |
|
3498 */ |
|
3499 #ifdef __INCLUDE_ALL_SUPPORTED_CAPABILITIES__ |
|
3500 |
|
3501 /** The set of all capabilities. |
|
3502 @internalTechnology |
|
3503 */ |
|
3504 const SCapabilitySet AllSupportedCapabilities = { |
|
3505 { |
|
3506 ECapability_Limit<32 ? (TUint32)((1u<<(ECapability_Limit&31))-1u) : 0xffffffffu |
|
3507 , |
|
3508 ECapability_Limit>=32 ? (TUint32)((1u<<(ECapability_Limit&31))-1u) : 0u |
|
3509 } |
|
3510 }; |
|
3511 |
|
3512 #endif // __INCLUDE_ALL_SUPPORTED_CAPABILITIES__ |
|
3513 |
|
3514 #ifndef __KERNEL_MODE__ |
|
3515 class RProcess; |
|
3516 class RThread; |
|
3517 class RMessagePtr2; |
|
3518 class RSessionBase; |
|
3519 #else |
|
3520 class DProcess; |
|
3521 class DThread; |
|
3522 #endif |
|
3523 |
|
3524 /** Class representing all security attributes of a process or DLL. |
|
3525 These comprise a set of capabilities, a Secure ID and a Vendor ID. |
|
3526 |
|
3527 @publishedAll |
|
3528 @released |
|
3529 */ |
|
3530 class TSecurityInfo |
|
3531 { |
|
3532 public: |
|
3533 inline TSecurityInfo(); |
|
3534 #ifdef __KERNEL_MODE__ |
|
3535 IMPORT_C TSecurityInfo(DProcess* aProcess); |
|
3536 IMPORT_C TSecurityInfo(DThread* aThread); |
|
3537 #else |
|
3538 IMPORT_C TSecurityInfo(RProcess aProcess); |
|
3539 IMPORT_C TSecurityInfo(RThread aThread); |
|
3540 IMPORT_C TSecurityInfo(RMessagePtr2 aMesPtr); |
|
3541 inline void Set(RProcess aProcess); |
|
3542 inline void Set(RThread aThread); |
|
3543 inline void Set(RMessagePtr2 aMsgPtr); |
|
3544 TInt Set(RSessionBase aSession); /**< @internalComponent */ |
|
3545 inline void SetToCurrentInfo(); |
|
3546 IMPORT_C void SetToCreatorInfo(); |
|
3547 #endif //__KERNEL_MODE__ |
|
3548 public: |
|
3549 TSecureId iSecureId; /**< Secure ID */ |
|
3550 TVendorId iVendorId; /**< Vendor ID */ |
|
3551 TCapabilitySet iCaps; /**< Capability Set */ |
|
3552 }; |
|
3553 |
|
3554 |
|
3555 /** Class representing a generic security policy |
|
3556 |
|
3557 This class can specify a security policy consisting of either: |
|
3558 |
|
3559 -# A check for between 0 and 7 capabilities |
|
3560 -# A check for a given Secure ID along with 0-3 capabilities |
|
3561 -# A check for a given Vendor ID along with 0-3 capabilities |
|
3562 |
|
3563 If multiple capabilities are specified, all of them must be present for the |
|
3564 security check to succeed ('AND' relation). |
|
3565 |
|
3566 The envisaged use case for this class is to specify access rights to an object |
|
3567 managed either by the kernel or by a server but in principle owned by a client |
|
3568 and usable in a limited way by other clients. For example |
|
3569 - Publish and Subscribe properties |
|
3570 - DBMS databases |
|
3571 |
|
3572 In these cases the owning client would pass one (or more) of these objects to |
|
3573 the server to specify which security checks should be done on other clients |
|
3574 before allowing access to the object. |
|
3575 |
|
3576 To pass a TSecurityPolicy object via IPC, a client should obtain a descriptor |
|
3577 for the object using Package() and send this. When a server receives this descriptor |
|
3578 it should read the descriptor contents into a TSecurityPolicyBuf and then |
|
3579 Set() should be used to create a policy object from this. |
|
3580 |
|
3581 Because this class has non-default constructors, compilers will not initialise |
|
3582 this object at compile time, instead code will be generated to construct the object |
|
3583 at run-time. This is wasteful - and Symbian OS DLLs are not permitted to have |
|
3584 such uninitialised data. To overcome these problems a set of macros are provided to |
|
3585 construct a const object which behaves like a TSecurityPolicy. These are: |
|
3586 |
|
3587 _LIT_SECURITY_POLICY_C1 through _LIT_SECURITY_POLICY_C7, |
|
3588 _LIT_SECURITY_POLICY_S0 through _LIT_SECURITY_POLICY_S3 and |
|
3589 _LIT_SECURITY_POLICY_V0 through _LIT_SECURITY_POLICY_V3. |
|
3590 |
|
3591 Also, the macros _LIT_SECURITY_POLICY_PASS and _LIT_SECURITY_POLICY_FAIL are provided |
|
3592 in order to allow easy construction of a const object which can be used as a |
|
3593 TSecuityPolicy which always passes or always fails, respectively. |
|
3594 |
|
3595 If a security policy object is needed to be embedded in another class then the |
|
3596 TStaticSecurityPolicy structure can be used. This behaves in the same way as a |
|
3597 TSecurityPolicy object but may be initialised at compile time. |
|
3598 |
|
3599 @see TStaticSecurityPolicy |
|
3600 @see TSecurityPolicyBuf |
|
3601 @see _LIT_SECURITY_POLICY_PASS |
|
3602 @see _LIT_SECURITY_POLICY_FAIL |
|
3603 @see _LIT_SECURITY_POLICY_C1 |
|
3604 @see _LIT_SECURITY_POLICY_C2 |
|
3605 @see _LIT_SECURITY_POLICY_C3 |
|
3606 @see _LIT_SECURITY_POLICY_C4 |
|
3607 @see _LIT_SECURITY_POLICY_C5 |
|
3608 @see _LIT_SECURITY_POLICY_C6 |
|
3609 @see _LIT_SECURITY_POLICY_C7 |
|
3610 @see _LIT_SECURITY_POLICY_S0 |
|
3611 @see _LIT_SECURITY_POLICY_S1 |
|
3612 @see _LIT_SECURITY_POLICY_S2 |
|
3613 @see _LIT_SECURITY_POLICY_S3 |
|
3614 @see _LIT_SECURITY_POLICY_V0 |
|
3615 @see _LIT_SECURITY_POLICY_V1 |
|
3616 @see _LIT_SECURITY_POLICY_V2 |
|
3617 @see _LIT_SECURITY_POLICY_V3 |
|
3618 |
|
3619 @publishedAll |
|
3620 @released |
|
3621 */ |
|
3622 class TSecurityPolicy |
|
3623 { |
|
3624 public: |
|
3625 enum TSecPolicyType |
|
3626 { |
|
3627 EAlwaysFail=0, |
|
3628 EAlwaysPass=1, |
|
3629 }; |
|
3630 |
|
3631 public: |
|
3632 inline TSecurityPolicy(); |
|
3633 IMPORT_C TSecurityPolicy(TSecPolicyType aType); |
|
3634 IMPORT_C TSecurityPolicy(TCapability aCap1, TCapability aCap2 = ECapability_None, TCapability aCap3 = ECapability_None); |
|
3635 IMPORT_C TSecurityPolicy(TCapability aCap1, TCapability aCap2, TCapability aCap3, TCapability aCap4, TCapability aCap5 = ECapability_None, TCapability aCap6 = ECapability_None, TCapability aCap7 = ECapability_None); |
|
3636 IMPORT_C TSecurityPolicy(TSecureId aSecureId, TCapability aCap1 = ECapability_None, TCapability aCap2 = ECapability_None, TCapability aCap3 = ECapability_None); |
|
3637 IMPORT_C TSecurityPolicy(TVendorId aVendorId, TCapability aCap1 = ECapability_None, TCapability aCap2 = ECapability_None, TCapability aCap3 = ECapability_None); |
|
3638 IMPORT_C TInt Set(const TDesC8& aDes); |
|
3639 IMPORT_C TPtrC8 Package() const; |
|
3640 |
|
3641 #ifdef __KERNEL_MODE__ |
|
3642 |
|
3643 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3644 inline TBool CheckPolicy(DProcess* aProcess, const char* aDiagnostic=0) const; |
|
3645 inline TBool CheckPolicy(DThread* aThread, const char* aDiagnostic=0) const; |
|
3646 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3647 // Only available to NULL arguments |
|
3648 inline TBool CheckPolicy(DProcess* aProcess, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3649 inline TBool CheckPolicy(DThread* aThread, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3650 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3651 |
|
3652 #else // !__KERNEL_MODE__ |
|
3653 |
|
3654 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3655 inline TBool CheckPolicy(RProcess aProcess, const char* aDiagnostic=0) const; |
|
3656 inline TBool CheckPolicy(RThread aThread, const char* aDiagnostic=0) const; |
|
3657 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic=0) const; |
|
3658 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic=0) const; |
|
3659 inline TBool CheckPolicyCreator(const char* aDiagnostic=0) const; |
|
3660 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3661 // Only available to NULL arguments |
|
3662 inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3663 inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3664 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3665 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3666 inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3667 #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3668 // For things using KSuppressPlatSecDiagnostic |
|
3669 inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3670 inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3671 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3672 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3673 inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3674 #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3675 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3676 TInt CheckPolicy(RSessionBase aSession) const; /**< @internalComponent */ |
|
3677 |
|
3678 #endif //__KERNEL_MODE__ |
|
3679 |
|
3680 TBool Validate() const; |
|
3681 |
|
3682 private: |
|
3683 #ifdef __KERNEL_MODE__ |
|
3684 IMPORT_C TBool DoCheckPolicy(DProcess* aProcess, const char* aDiagnostic) const; |
|
3685 IMPORT_C TBool DoCheckPolicy(DProcess* aProcess) const; |
|
3686 IMPORT_C TBool DoCheckPolicy(DThread* aThread, const char* aDiagnostic) const; |
|
3687 IMPORT_C TBool DoCheckPolicy(DThread* aThread) const; |
|
3688 #else // !__KERNEL_MODE__ |
|
3689 IMPORT_C TBool DoCheckPolicy(RProcess aProcess, const char* aDiagnostic) const; |
|
3690 IMPORT_C TBool DoCheckPolicy(RProcess aProcess) const; |
|
3691 IMPORT_C TBool DoCheckPolicy(RThread aThread, const char* aDiagnostic) const; |
|
3692 IMPORT_C TBool DoCheckPolicy(RThread aThread) const; |
|
3693 IMPORT_C TBool DoCheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic) const; |
|
3694 IMPORT_C TBool DoCheckPolicy(RMessagePtr2 aMsgPtr) const; |
|
3695 IMPORT_C TBool DoCheckPolicyCreator(const char* aDiagnostic) const; |
|
3696 IMPORT_C TBool DoCheckPolicyCreator() const; |
|
3697 #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3698 TBool DoCheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic) const; |
|
3699 #endif //__REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3700 TBool DoCheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing) const; |
|
3701 #endif //__KERNEL_MODE__ |
|
3702 |
|
3703 public: |
|
3704 /** Constants to specify the type of TSecurityPolicy objects. |
|
3705 */ |
|
3706 enum TType |
|
3707 { |
|
3708 ETypeFail=0, /**< Always fail*/ |
|
3709 ETypePass=1, /**< Always pass*/ |
|
3710 ETypeC3=2, /**< Up to 3 capabilities*/ |
|
3711 ETypeC7=3, /**< Up to 7 capabilities*/ |
|
3712 ETypeS3=4, /**< Secure ID and up to 3 capabilities*/ |
|
3713 ETypeV3=5, /**< Vendor ID and up to 3 capabilities*/ |
|
3714 |
|
3715 /** The number of possible TSecurityPolicy types |
|
3716 This is intended for internal Symbian use only. |
|
3717 @internalTechnology |
|
3718 */ |
|
3719 ETypeLimit |
|
3720 |
|
3721 // other values may be added to indicate expanded policy objects (future extensions) |
|
3722 }; |
|
3723 protected: |
|
3724 TBool CheckPolicy(const SSecurityInfo& aSecInfo, SSecurityInfo& aMissing) const; |
|
3725 private: |
|
3726 void ConstructAndCheck3(TCapability aCap1, TCapability aCap2, TCapability aCap3); |
|
3727 private: |
|
3728 TUint8 iType; |
|
3729 TUint8 iCaps[3]; // missing capabilities are set to 0xff |
|
3730 union |
|
3731 { |
|
3732 TUint32 iSecureId; |
|
3733 TUint32 iVendorId; |
|
3734 TUint8 iExtraCaps[4]; // missing capabilities are set to 0xff |
|
3735 }; |
|
3736 friend class TCompiledSecurityPolicy; |
|
3737 }; |
|
3738 |
|
3739 /** Provides a TPkcgBuf wrapper for a descriptorised TSecurityPolicy. This a |
|
3740 suitable container for passing a security policy across IPC. |
|
3741 @publishedAll |
|
3742 @released |
|
3743 */ |
|
3744 typedef TPckgBuf<TSecurityPolicy> TSecurityPolicyBuf; |
|
3745 |
|
3746 |
|
3747 /** Structure for compile-time initialisation of a security policy. |
|
3748 |
|
3749 This structure behaves in the same way as a TSecurityPolicy object but has |
|
3750 the advantage that it may be initialised at compile time. E.g. |
|
3751 the following line defines a security policy 'KSecurityPolictReadUserData' |
|
3752 which checks ReadUserData capability. |
|
3753 |
|
3754 @code |
|
3755 _LIT_SECURITY_POLICY_C1(KSecurityPolictReadUserData,ECapabilityReadUserData) |
|
3756 @endcode |
|
3757 |
|
3758 Or, an array of security policies may be created like this: |
|
3759 @code |
|
3760 static const TStaticSecurityPolicy MyPolicies[] = |
|
3761 { |
|
3762 _INIT_SECURITY_POLICY_C1(ECapabilityReadUserData), |
|
3763 _INIT_SECURITY_POLICY_PASS(), |
|
3764 _INIT_SECURITY_POLICY_S0(0x1234567) |
|
3765 } |
|
3766 @endcode |
|
3767 |
|
3768 This class should not be initialised directly, instead one of the following |
|
3769 macros should be used: |
|
3770 |
|
3771 - _INIT_SECURITY_POLICY_PASS |
|
3772 - _INIT_SECURITY_POLICY_FAIL |
|
3773 - _INIT_SECURITY_POLICY_C1 |
|
3774 - _INIT_SECURITY_POLICY_C2 |
|
3775 - _INIT_SECURITY_POLICY_C3 |
|
3776 - _INIT_SECURITY_POLICY_C4 |
|
3777 - _INIT_SECURITY_POLICY_C5 |
|
3778 - _INIT_SECURITY_POLICY_C6 |
|
3779 - _INIT_SECURITY_POLICY_C7 |
|
3780 - _INIT_SECURITY_POLICY_S0 |
|
3781 - _INIT_SECURITY_POLICY_S1 |
|
3782 - _INIT_SECURITY_POLICY_S2 |
|
3783 - _INIT_SECURITY_POLICY_S3 |
|
3784 - _INIT_SECURITY_POLICY_V0 |
|
3785 - _INIT_SECURITY_POLICY_V1 |
|
3786 - _INIT_SECURITY_POLICY_V2 |
|
3787 - _INIT_SECURITY_POLICY_V3 |
|
3788 - _LIT_SECURITY_POLICY_PASS |
|
3789 - _LIT_SECURITY_POLICY_FAIL |
|
3790 - _LIT_SECURITY_POLICY_C1 |
|
3791 - _LIT_SECURITY_POLICY_C2 |
|
3792 - _LIT_SECURITY_POLICY_C3 |
|
3793 - _LIT_SECURITY_POLICY_C4 |
|
3794 - _LIT_SECURITY_POLICY_C5 |
|
3795 - _LIT_SECURITY_POLICY_C6 |
|
3796 - _LIT_SECURITY_POLICY_C7 |
|
3797 - _LIT_SECURITY_POLICY_S0 |
|
3798 - _LIT_SECURITY_POLICY_S1 |
|
3799 - _LIT_SECURITY_POLICY_S2 |
|
3800 - _LIT_SECURITY_POLICY_S3 |
|
3801 - _LIT_SECURITY_POLICY_V0 |
|
3802 - _LIT_SECURITY_POLICY_V1 |
|
3803 - _LIT_SECURITY_POLICY_V2 |
|
3804 - _LIT_SECURITY_POLICY_V3 |
|
3805 |
|
3806 @see TSecurityPolicy |
|
3807 @publishedAll |
|
3808 @released |
|
3809 */ |
|
3810 struct TStaticSecurityPolicy |
|
3811 { |
|
3812 inline const TSecurityPolicy* operator&() const; |
|
3813 inline operator const TSecurityPolicy&() const; |
|
3814 inline const TSecurityPolicy& operator()() const; |
|
3815 |
|
3816 #ifndef __KERNEL_MODE__ |
|
3817 #ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3818 inline TBool CheckPolicy(RProcess aProcess, const char* aDiagnostic=0) const; |
|
3819 inline TBool CheckPolicy(RThread aThread, const char* aDiagnostic=0) const; |
|
3820 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, const char* aDiagnostic=0) const; |
|
3821 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, const char* aDiagnostic=0) const; |
|
3822 inline TBool CheckPolicyCreator(const char* aDiagnostic=0) const; |
|
3823 #else //__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3824 // Only available to NULL arguments |
|
3825 inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3826 inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3827 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3828 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3829 inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic=NULL) const; |
|
3830 #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3831 // For things using KSuppressPlatSecDiagnostic |
|
3832 inline TBool CheckPolicy(RProcess aProcess, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3833 inline TBool CheckPolicy(RThread aThread, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3834 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3835 inline TBool CheckPolicy(RMessagePtr2 aMsgPtr, TSecurityInfo& aMissing, OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3836 inline TBool CheckPolicyCreator(OnlyCreateWithNull aDiagnostic, OnlyCreateWithNull aSuppress) const; |
|
3837 #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__ |
|
3838 #endif // !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ |
|
3839 #endif // !__KERNEL_MODE__ |
|
3840 |
|
3841 TUint32 iA; /**< @internalComponent */ |
|
3842 TUint32 iB; /**< @internalComponent */ |
|
3843 }; |
|
3844 |
|
3845 |
|
3846 /** |
|
3847 A dummy enum for use by the CAPABILITY_AS_TUINT8 macro |
|
3848 @internalComponent |
|
3849 */ |
|
3850 enum __invalid_capability_value {}; |
|
3851 |
|
3852 /** |
|
3853 A macro to cast a TCapability to a TUint8. |
|
3854 |
|
3855 If an invlid capability value is specified then, dependant on the compiler, |
|
3856 a compile time error or warning will be produced which includes the label |
|
3857 "__invalid_capability_value" |
|
3858 |
|
3859 @param cap The capability value |
|
3860 @internalComponent |
|
3861 */ |
|
3862 #define CAPABILITY_AS_TUINT8(cap) \ |
|
3863 ((TUint8)(int)( \ |
|
3864 (cap)==ECapability_None \ |
|
3865 ? (__invalid_capability_value(*)[1])(ECapability_None) \ |
|
3866 : (__invalid_capability_value(*)[((TUint)(cap+1)<=(TUint)ECapability_Limit)?1:2])(cap) \ |
|
3867 )) |
|
3868 |
|
3869 |
|
3870 /** |
|
3871 A macro to construct a TUint32 from four TUint8s. The TUint32 is in BigEndian |
|
3872 ordering useful for class layout rather than number generation. |
|
3873 |
|
3874 @param i1 The first TUint8 |
|
3875 @param i2 The second TUint8 |
|
3876 @param i3 The third TUint8 |
|
3877 @param i4 The fourth TUint8 |
|
3878 @internalComponent |
|
3879 */ |
|
3880 #define FOUR_TUINT8(i1,i2,i3,i4) \ |
|
3881 (TUint32)( \ |
|
3882 (TUint8)i1 | \ |
|
3883 (TUint8)i2 << 8 | \ |
|
3884 (TUint8)i3 << 16 | \ |
|
3885 (TUint8)i4 << 24 \ |
|
3886 ) |
|
3887 |
|
3888 |
|
3889 /** Macro for compile-time initialisation of a security policy object that |
|
3890 always fails. That is, checks against this policy will always fail, |
|
3891 irrespective of the security attributes of the item being checked. |
|
3892 |
|
3893 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
3894 Taking the address of the object will return a const TSecurityPolicy*. |
|
3895 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
3896 function call operator n(). |
|
3897 @publishedAll |
|
3898 @released |
|
3899 */ |
|
3900 #define _INIT_SECURITY_POLICY_FAIL \ |
|
3901 { \ |
|
3902 FOUR_TUINT8( \ |
|
3903 (TUint8)TSecurityPolicy::ETypeFail, \ |
|
3904 (TUint8)0xff, \ |
|
3905 (TUint8)0xff, \ |
|
3906 (TUint8)0xff \ |
|
3907 ), \ |
|
3908 (TUint32)0xffffffff \ |
|
3909 } |
|
3910 |
|
3911 |
|
3912 /** Macro for compile-time definition of a security policy object that always |
|
3913 fails. That is, checks against this policy will always fail, irrespective of |
|
3914 the security attributes of the item being checked. |
|
3915 |
|
3916 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
3917 Taking the address of the object will return a const TSecurityPolicy*. |
|
3918 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
3919 function call operator n(). |
|
3920 @param n Name to use for policy object |
|
3921 @publishedAll |
|
3922 @released |
|
3923 */ |
|
3924 #define _LIT_SECURITY_POLICY_FAIL(n) const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_FAIL |
|
3925 |
|
3926 |
|
3927 /** Macro for compile-time initialisation of a security policy object that |
|
3928 always passes. That is, checks against this policy will always pass, |
|
3929 irrespective of the security attributes of the item being checked. |
|
3930 |
|
3931 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
3932 Taking the address of the object will return a const TSecurityPolicy*. |
|
3933 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
3934 function call operator n(). |
|
3935 @publishedAll |
|
3936 @released |
|
3937 */ |
|
3938 #define _INIT_SECURITY_POLICY_PASS \ |
|
3939 { \ |
|
3940 FOUR_TUINT8( \ |
|
3941 (TUint8)TSecurityPolicy::ETypePass, \ |
|
3942 (TUint8)0xff, \ |
|
3943 (TUint8)0xff, \ |
|
3944 (TUint8)0xff \ |
|
3945 ), \ |
|
3946 (TUint32)0xffffffff \ |
|
3947 } |
|
3948 |
|
3949 |
|
3950 /** Macro for compile-time definition of a security policy object that always |
|
3951 passes. That is, checks against this policy will always pass, irrespective of |
|
3952 the security attributes of the item being checked. |
|
3953 |
|
3954 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
3955 Taking the address of the object will return a const TSecurityPolicy*. |
|
3956 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
3957 function call operator n(). |
|
3958 @param n Name to use for policy object |
|
3959 @publishedAll |
|
3960 @released |
|
3961 */ |
|
3962 #define _LIT_SECURITY_POLICY_PASS(n) const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_PASS |
|
3963 |
|
3964 |
|
3965 /** Macro for compile-time initialisation of a security policy object |
|
3966 The policy will check for seven capabilities. |
|
3967 |
|
3968 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
3969 Taking the address of the object will return a const TSecurityPolicy*. |
|
3970 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
3971 function call operator n(). |
|
3972 |
|
3973 If an invlid capability value is specified then, dependant on the compiler, |
|
3974 a compile time error or warning will be produced which includes the label |
|
3975 "__invalid_capability_value" |
|
3976 |
|
3977 @param c1 The first capability to check (enumerator of TCapability) |
|
3978 @param c2 The second capability to check (enumerator of TCapability) |
|
3979 @param c3 The third capability to check (enumerator of TCapability) |
|
3980 @param c4 The fourth capability to check (enumerator of TCapability) |
|
3981 @param c5 The fifth capability to check (enumerator of TCapability) |
|
3982 @param c6 The sixth capability to check (enumerator of TCapability) |
|
3983 @param c7 The seventh capability to check (enumerator of TCapability) |
|
3984 |
|
3985 @publishedAll |
|
3986 @released |
|
3987 */ |
|
3988 #define _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,c6,c7) \ |
|
3989 { \ |
|
3990 FOUR_TUINT8( \ |
|
3991 (TUint8)TSecurityPolicy::ETypeC7, \ |
|
3992 CAPABILITY_AS_TUINT8(c1), \ |
|
3993 CAPABILITY_AS_TUINT8(c2), \ |
|
3994 CAPABILITY_AS_TUINT8(c3) \ |
|
3995 ), \ |
|
3996 FOUR_TUINT8( \ |
|
3997 CAPABILITY_AS_TUINT8(c4), \ |
|
3998 CAPABILITY_AS_TUINT8(c5), \ |
|
3999 CAPABILITY_AS_TUINT8(c6), \ |
|
4000 CAPABILITY_AS_TUINT8(c7) \ |
|
4001 ) \ |
|
4002 } |
|
4003 |
|
4004 |
|
4005 /** Macro for compile-time definition of a security policy object |
|
4006 The policy will check for seven capabilities. |
|
4007 |
|
4008 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4009 Taking the address of the object will return a const TSecurityPolicy*. |
|
4010 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4011 function call operator n(). |
|
4012 |
|
4013 If an invlid capability value is specified then, dependant on the compiler, |
|
4014 a compile time error or warning will be produced which includes the label |
|
4015 "__invalid_capability_value" |
|
4016 |
|
4017 @param n Name to use for policy object |
|
4018 @param c1 The first capability to check (enumerator of TCapability) |
|
4019 @param c2 The second capability to check (enumerator of TCapability) |
|
4020 @param c3 The third capability to check (enumerator of TCapability) |
|
4021 @param c4 The fourth capability to check (enumerator of TCapability) |
|
4022 @param c5 The fifth capability to check (enumerator of TCapability) |
|
4023 @param c6 The sixth capability to check (enumerator of TCapability) |
|
4024 @param c7 The seventh capability to check (enumerator of TCapability) |
|
4025 |
|
4026 @publishedAll |
|
4027 @released |
|
4028 */ |
|
4029 #define _LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,c5,c6,c7) \ |
|
4030 const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,c6,c7) |
|
4031 |
|
4032 |
|
4033 /** Macro for compile-time initialisation of a security policy object |
|
4034 The policy will check for six capabilities. |
|
4035 |
|
4036 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4037 Taking the address of the object will return a const TSecurityPolicy*. |
|
4038 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4039 function call operator n(). |
|
4040 |
|
4041 If an invlid capability value is specified then, dependant on the compiler, |
|
4042 a compile time error or warning will be produced which includes the label |
|
4043 "__invalid_capability_value" |
|
4044 |
|
4045 @param c1 The first capability to check (enumerator of TCapability) |
|
4046 @param c2 The second capability to check (enumerator of TCapability) |
|
4047 @param c3 The third capability to check (enumerator of TCapability) |
|
4048 @param c4 The fourth capability to check (enumerator of TCapability) |
|
4049 @param c5 The fifth capability to check (enumerator of TCapability) |
|
4050 @param c6 The sixth capability to check (enumerator of TCapability) |
|
4051 |
|
4052 @publishedAll |
|
4053 @released |
|
4054 */ |
|
4055 #define _INIT_SECURITY_POLICY_C6(c1,c2,c3,c4,c5,c6) \ |
|
4056 _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,c6,ECapability_None) |
|
4057 |
|
4058 |
|
4059 /** Macro for compile-time definition of a security policy object |
|
4060 The policy will check for six capabilities. |
|
4061 |
|
4062 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4063 Taking the address of the object will return a const TSecurityPolicy*. |
|
4064 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4065 function call operator n(). |
|
4066 |
|
4067 If an invlid capability value is specified then, dependant on the compiler, |
|
4068 a compile time error or warning will be produced which includes the label |
|
4069 "__invalid_capability_value" |
|
4070 |
|
4071 @param n Name to use for policy object |
|
4072 @param c1 The first capability to check (enumerator of TCapability) |
|
4073 @param c2 The second capability to check (enumerator of TCapability) |
|
4074 @param c3 The third capability to check (enumerator of TCapability) |
|
4075 @param c4 The fourth capability to check (enumerator of TCapability) |
|
4076 @param c5 The fifth capability to check (enumerator of TCapability) |
|
4077 @param c6 The sixth capability to check (enumerator of TCapability) |
|
4078 |
|
4079 @publishedAll |
|
4080 @released |
|
4081 */ |
|
4082 #define _LIT_SECURITY_POLICY_C6(n,c1,c2,c3,c4,c5,c6) \ |
|
4083 _LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,c5,c6,ECapability_None) |
|
4084 |
|
4085 |
|
4086 /** Macro for compile-time initialisation of a security policy object |
|
4087 The policy will check for five capabilities. |
|
4088 |
|
4089 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4090 Taking the address of the object will return a const TSecurityPolicy*. |
|
4091 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4092 function call operator n(). |
|
4093 |
|
4094 If an invlid capability value is specified then, dependant on the compiler, |
|
4095 a compile time error or warning will be produced which includes the label |
|
4096 "__invalid_capability_value" |
|
4097 |
|
4098 @param c1 The first capability to check (enumerator of TCapability) |
|
4099 @param c2 The second capability to check (enumerator of TCapability) |
|
4100 @param c3 The third capability to check (enumerator of TCapability) |
|
4101 @param c4 The fourth capability to check (enumerator of TCapability) |
|
4102 @param c5 The fifth capability to check (enumerator of TCapability) |
|
4103 |
|
4104 @publishedAll |
|
4105 @released |
|
4106 */ |
|
4107 #define _INIT_SECURITY_POLICY_C5(c1,c2,c3,c4,c5) \ |
|
4108 _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,c5,ECapability_None,ECapability_None) |
|
4109 |
|
4110 |
|
4111 /** Macro for compile-time definition of a security policy object |
|
4112 The policy will check for five capabilities. |
|
4113 |
|
4114 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4115 Taking the address of the object will return a const TSecurityPolicy*. |
|
4116 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4117 function call operator n(). |
|
4118 |
|
4119 If an invlid capability value is specified then, dependant on the compiler, |
|
4120 a compile time error or warning will be produced which includes the label |
|
4121 "__invalid_capability_value" |
|
4122 |
|
4123 @param n Name to use for policy object |
|
4124 @param c1 The first capability to check (enumerator of TCapability) |
|
4125 @param c2 The second capability to check (enumerator of TCapability) |
|
4126 @param c3 The third capability to check (enumerator of TCapability) |
|
4127 @param c4 The fourth capability to check (enumerator of TCapability) |
|
4128 @param c5 The fifth capability to check (enumerator of TCapability) |
|
4129 |
|
4130 @publishedAll |
|
4131 @released |
|
4132 */ |
|
4133 #define _LIT_SECURITY_POLICY_C5(n,c1,c2,c3,c4,c5) \ |
|
4134 _LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,c5,ECapability_None,ECapability_None) |
|
4135 |
|
4136 |
|
4137 /** Macro for compile-time initialisation of a security policy object |
|
4138 The policy will check for four capabilities. |
|
4139 |
|
4140 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4141 Taking the address of the object will return a const TSecurityPolicy*. |
|
4142 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4143 function call operator n(). |
|
4144 |
|
4145 If an invlid capability value is specified then, dependant on the compiler, |
|
4146 a compile time error or warning will be produced which includes the label |
|
4147 "__invalid_capability_value" |
|
4148 |
|
4149 @param c1 The first capability to check (enumerator of TCapability) |
|
4150 @param c2 The second capability to check (enumerator of TCapability) |
|
4151 @param c3 The third capability to check (enumerator of TCapability) |
|
4152 @param c4 The fourth capability to check (enumerator of TCapability) |
|
4153 |
|
4154 @publishedAll |
|
4155 @released |
|
4156 */ |
|
4157 #define _INIT_SECURITY_POLICY_C4(c1,c2,c3,c4) \ |
|
4158 _INIT_SECURITY_POLICY_C7(c1,c2,c3,c4,ECapability_None,ECapability_None,ECapability_None) |
|
4159 |
|
4160 |
|
4161 /** Macro for compile-time definition of a security policy object |
|
4162 The policy will check for four capabilities. |
|
4163 |
|
4164 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4165 Taking the address of the object will return a const TSecurityPolicy*. |
|
4166 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4167 function call operator n(). |
|
4168 |
|
4169 If an invlid capability value is specified then, dependant on the compiler, |
|
4170 a compile time error or warning will be produced which includes the label |
|
4171 "__invalid_capability_value" |
|
4172 |
|
4173 @param n Name to use for policy object |
|
4174 @param c1 The first capability to check (enumerator of TCapability) |
|
4175 @param c2 The second capability to check (enumerator of TCapability) |
|
4176 @param c3 The third capability to check (enumerator of TCapability) |
|
4177 @param c4 The fourth capability to check (enumerator of TCapability) |
|
4178 |
|
4179 @publishedAll |
|
4180 @released |
|
4181 */ |
|
4182 #define _LIT_SECURITY_POLICY_C4(n,c1,c2,c3,c4) \ |
|
4183 _LIT_SECURITY_POLICY_C7(n,c1,c2,c3,c4,ECapability_None,ECapability_None,ECapability_None) |
|
4184 |
|
4185 |
|
4186 /** Macro for compile-time initialisation of a security policy object |
|
4187 The policy will check for three capabilities. |
|
4188 |
|
4189 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4190 Taking the address of the object will return a const TSecurityPolicy*. |
|
4191 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4192 function call operator n(). |
|
4193 |
|
4194 If an invlid capability value is specified then, dependant on the compiler, |
|
4195 a compile time error or warning will be produced which includes the label |
|
4196 "__invalid_capability_value" |
|
4197 |
|
4198 @param c1 The first capability to check (enumerator of TCapability) |
|
4199 @param c2 The second capability to check (enumerator of TCapability) |
|
4200 @param c3 The third capability to check (enumerator of TCapability) |
|
4201 |
|
4202 @publishedAll |
|
4203 @released |
|
4204 */ |
|
4205 #define _INIT_SECURITY_POLICY_C3(c1,c2,c3) \ |
|
4206 { \ |
|
4207 FOUR_TUINT8( \ |
|
4208 (TUint8)TSecurityPolicy::ETypeC3, \ |
|
4209 CAPABILITY_AS_TUINT8(c1), \ |
|
4210 CAPABILITY_AS_TUINT8(c2), \ |
|
4211 CAPABILITY_AS_TUINT8(c3) \ |
|
4212 ), \ |
|
4213 (TUint32)0xffffffff \ |
|
4214 } |
|
4215 |
|
4216 |
|
4217 /** Macro for compile-time definition of a security policy object |
|
4218 The policy will check for three capabilities. |
|
4219 |
|
4220 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4221 Taking the address of the object will return a const TSecurityPolicy*. |
|
4222 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4223 function call operator n(). |
|
4224 |
|
4225 If an invlid capability value is specified then, dependant on the compiler, |
|
4226 a compile time error or warning will be produced which includes the label |
|
4227 "__invalid_capability_value" |
|
4228 |
|
4229 @param n Name to use for policy object |
|
4230 @param c1 The first capability to check (enumerator of TCapability) |
|
4231 @param c2 The second capability to check (enumerator of TCapability) |
|
4232 @param c3 The third capability to check (enumerator of TCapability) |
|
4233 |
|
4234 @publishedAll |
|
4235 @released |
|
4236 */ |
|
4237 #define _LIT_SECURITY_POLICY_C3(n,c1,c2,c3) \ |
|
4238 const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_C3(c1,c2,c3) |
|
4239 |
|
4240 |
|
4241 /** Macro for compile-time initialisation of a security policy object |
|
4242 The policy will check for two capabilities. |
|
4243 |
|
4244 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4245 Taking the address of the object will return a const TSecurityPolicy*. |
|
4246 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4247 function call operator n(). |
|
4248 |
|
4249 If an invlid capability value is specified then, dependant on the compiler, |
|
4250 a compile time error or warning will be produced which includes the label |
|
4251 "__invalid_capability_value" |
|
4252 |
|
4253 @param c1 The first capability to check (enumerator of TCapability) |
|
4254 @param c2 The second capability to check (enumerator of TCapability) |
|
4255 |
|
4256 @publishedAll |
|
4257 @released |
|
4258 */ |
|
4259 #define _INIT_SECURITY_POLICY_C2(c1,c2) \ |
|
4260 _INIT_SECURITY_POLICY_C3(c1,c2,ECapability_None) |
|
4261 |
|
4262 |
|
4263 /** Macro for compile-time definition of a security policy object |
|
4264 The policy will check for two capabilities. |
|
4265 |
|
4266 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4267 Taking the address of the object will return a const TSecurityPolicy*. |
|
4268 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4269 function call operator n(). |
|
4270 |
|
4271 If an invlid capability value is specified then, dependant on the compiler, |
|
4272 a compile time error or warning will be produced which includes the label |
|
4273 "__invalid_capability_value" |
|
4274 |
|
4275 @param n Name to use for policy object |
|
4276 @param c1 The first capability to check (enumerator of TCapability) |
|
4277 @param c2 The second capability to check (enumerator of TCapability) |
|
4278 |
|
4279 @publishedAll |
|
4280 @released |
|
4281 */ |
|
4282 #define _LIT_SECURITY_POLICY_C2(n,c1,c2) \ |
|
4283 _LIT_SECURITY_POLICY_C3(n,c1,c2,ECapability_None) |
|
4284 |
|
4285 |
|
4286 /** Macro for compile-time initialisation of a security policy object |
|
4287 The policy will check for one capability. |
|
4288 |
|
4289 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4290 Taking the address of the object will return a const TSecurityPolicy*. |
|
4291 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4292 function call operator n(). |
|
4293 |
|
4294 If an invlid capability value is specified then, dependant on the compiler, |
|
4295 a compile time error or warning will be produced which includes the label |
|
4296 "__invalid_capability_value" |
|
4297 |
|
4298 @param c1 The first capability to check (enumerator of TCapability) |
|
4299 |
|
4300 |
|
4301 @publishedAll |
|
4302 @released |
|
4303 */ |
|
4304 #define _INIT_SECURITY_POLICY_C1(c1) \ |
|
4305 _INIT_SECURITY_POLICY_C3(c1,ECapability_None,ECapability_None) |
|
4306 |
|
4307 |
|
4308 /** Macro for compile-time definition of a security policy object |
|
4309 The policy will check for one capability. |
|
4310 |
|
4311 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4312 Taking the address of the object will return a const TSecurityPolicy*. |
|
4313 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4314 function call operator n(). |
|
4315 |
|
4316 If an invlid capability value is specified then, dependant on the compiler, |
|
4317 a compile time error or warning will be produced which includes the label |
|
4318 "__invalid_capability_value" |
|
4319 |
|
4320 @param n Name to use for policy object |
|
4321 @param c1 The first capability to check (enumerator of TCapability) |
|
4322 |
|
4323 @publishedAll |
|
4324 @released |
|
4325 */ |
|
4326 #define _LIT_SECURITY_POLICY_C1(n,c1) \ |
|
4327 _LIT_SECURITY_POLICY_C3(n,c1,ECapability_None,ECapability_None) |
|
4328 |
|
4329 |
|
4330 /** Macro for compile-time initialisation of a security policy object |
|
4331 The policy will check for a secure ID and three capabilities. |
|
4332 |
|
4333 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4334 Taking the address of the object will return a const TSecurityPolicy*. |
|
4335 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4336 function call operator n(). |
|
4337 |
|
4338 If an invlid capability value is specified then, dependant on the compiler, |
|
4339 a compile time error or warning be produced which includes the label |
|
4340 "__invalid_capability_value" |
|
4341 |
|
4342 @param sid The SID value to check for |
|
4343 @param c1 The first capability to check (enumerator of TCapability) |
|
4344 @param c2 The second capability to check (enumerator of TCapability) |
|
4345 @param c3 The third capability to check (enumerator of TCapability) |
|
4346 |
|
4347 @publishedAll |
|
4348 @released |
|
4349 */ |
|
4350 #define _INIT_SECURITY_POLICY_S3(sid,c1,c2,c3) \ |
|
4351 { \ |
|
4352 FOUR_TUINT8( \ |
|
4353 (TUint8)TSecurityPolicy::ETypeS3, \ |
|
4354 CAPABILITY_AS_TUINT8(c1), \ |
|
4355 CAPABILITY_AS_TUINT8(c2), \ |
|
4356 CAPABILITY_AS_TUINT8(c3) \ |
|
4357 ), \ |
|
4358 (TUint32)(sid) \ |
|
4359 } |
|
4360 |
|
4361 |
|
4362 /** Macro for compile-time definition of a security policy object |
|
4363 The policy will check for a secure ID and three capabilities. |
|
4364 |
|
4365 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4366 Taking the address of the object will return a const TSecurityPolicy*. |
|
4367 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4368 function call operator n(). |
|
4369 |
|
4370 If an invlid capability value is specified then, dependant on the compiler, |
|
4371 a compile time error or warning be produced which includes the label |
|
4372 "__invalid_capability_value" |
|
4373 |
|
4374 @param n Name to use for policy object |
|
4375 @param sid The SID value to check for |
|
4376 @param c1 The first capability to check (enumerator of TCapability) |
|
4377 @param c2 The second capability to check (enumerator of TCapability) |
|
4378 @param c3 The third capability to check (enumerator of TCapability) |
|
4379 |
|
4380 @publishedAll |
|
4381 @released |
|
4382 */ |
|
4383 #define _LIT_SECURITY_POLICY_S3(n,sid,c1,c2,c3) \ |
|
4384 const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_S3(sid,c1,c2,c3) |
|
4385 |
|
4386 |
|
4387 /** Macro for compile-time initialisation of a security policy object |
|
4388 The policy will check for a secure ID and two capabilities. |
|
4389 |
|
4390 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4391 Taking the address of the object will return a const TSecurityPolicy*. |
|
4392 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4393 function call operator n(). |
|
4394 |
|
4395 If an invlid capability value is specified then, dependant on the compiler, |
|
4396 a compile time error or warning be produced which includes the label |
|
4397 "__invalid_capability_value" |
|
4398 |
|
4399 @param sid The SID value to check for |
|
4400 @param c1 The first capability to check (enumerator of TCapability) |
|
4401 @param c2 The second capability to check (enumerator of TCapability) |
|
4402 |
|
4403 @publishedAll |
|
4404 @released |
|
4405 */ |
|
4406 #define _INIT_SECURITY_POLICY_S2(sid,c1,c2) \ |
|
4407 _INIT_SECURITY_POLICY_S3(sid,c1,c2,ECapability_None) |
|
4408 |
|
4409 |
|
4410 /** Macro for compile-time definition of a security policy object |
|
4411 The policy will check for a secure ID and two capabilities. |
|
4412 |
|
4413 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4414 Taking the address of the object will return a const TSecurityPolicy*. |
|
4415 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4416 function call operator n(). |
|
4417 |
|
4418 If an invlid capability value is specified then, dependant on the compiler, |
|
4419 a compile time error or warning be produced which includes the label |
|
4420 "__invalid_capability_value" |
|
4421 |
|
4422 @param n Name to use for policy object |
|
4423 @param sid The SID value to check for |
|
4424 @param c1 The first capability to check (enumerator of TCapability) |
|
4425 @param c2 The second capability to check (enumerator of TCapability) |
|
4426 |
|
4427 @publishedAll |
|
4428 @released |
|
4429 */ |
|
4430 #define _LIT_SECURITY_POLICY_S2(n,sid,c1,c2) \ |
|
4431 _LIT_SECURITY_POLICY_S3(n,sid,c1,c2,ECapability_None) |
|
4432 |
|
4433 |
|
4434 /** Macro for compile-time initialisation of a security policy object |
|
4435 The policy will check for a secure ID and one capability. |
|
4436 |
|
4437 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4438 Taking the address of the object will return a const TSecurityPolicy*. |
|
4439 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4440 function call operator n(). |
|
4441 |
|
4442 If an invlid capability value is specified then, dependant on the compiler, |
|
4443 a compile time error or warning be produced which includes the label |
|
4444 "__invalid_capability_value" |
|
4445 |
|
4446 @param sid The SID value to check for |
|
4447 @param c1 The first capability to check (enumerator of TCapability) |
|
4448 |
|
4449 @publishedAll |
|
4450 @released |
|
4451 */ |
|
4452 #define _INIT_SECURITY_POLICY_S1(sid,c1) \ |
|
4453 _INIT_SECURITY_POLICY_S3(sid,c1,ECapability_None,ECapability_None) |
|
4454 |
|
4455 |
|
4456 /** Macro for compile-time definition of a security policy object |
|
4457 The policy will check for a secure ID and one capability. |
|
4458 |
|
4459 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4460 Taking the address of the object will return a const TSecurityPolicy*. |
|
4461 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4462 function call operator n(). |
|
4463 |
|
4464 If an invlid capability value is specified then, dependant on the compiler, |
|
4465 a compile time error or warning be produced which includes the label |
|
4466 "__invalid_capability_value" |
|
4467 |
|
4468 @param n Name to use for policy object |
|
4469 @param sid The SID value to check for |
|
4470 @param c1 The first capability to check (enumerator of TCapability) |
|
4471 |
|
4472 @publishedAll |
|
4473 @released |
|
4474 */ |
|
4475 #define _LIT_SECURITY_POLICY_S1(n,sid,c1) \ |
|
4476 _LIT_SECURITY_POLICY_S3(n,sid,c1,ECapability_None,ECapability_None) |
|
4477 |
|
4478 |
|
4479 /** Macro for compile-time initialisation of a security policy object |
|
4480 The policy will check for a secure ID. |
|
4481 |
|
4482 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4483 Taking the address of the object will return a const TSecurityPolicy*. |
|
4484 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4485 function call operator n(). |
|
4486 |
|
4487 @param sid The SID value to check for |
|
4488 |
|
4489 @publishedAll |
|
4490 @released |
|
4491 */ |
|
4492 #define _INIT_SECURITY_POLICY_S0(sid) \ |
|
4493 _INIT_SECURITY_POLICY_S3(sid,ECapability_None,ECapability_None,ECapability_None) |
|
4494 |
|
4495 |
|
4496 /** Macro for compile-time definition of a security policy object |
|
4497 The policy will check for a secure ID. |
|
4498 |
|
4499 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4500 Taking the address of the object will return a const TSecurityPolicy*. |
|
4501 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4502 function call operator n(). |
|
4503 |
|
4504 @param n Name to use for policy object |
|
4505 @param sid The SID value to check for |
|
4506 |
|
4507 @publishedAll |
|
4508 @released |
|
4509 */ |
|
4510 #define _LIT_SECURITY_POLICY_S0(n,sid) \ |
|
4511 _LIT_SECURITY_POLICY_S3(n,sid,ECapability_None,ECapability_None,ECapability_None) |
|
4512 |
|
4513 |
|
4514 /** Macro for compile-time initialisation of a security policy object |
|
4515 The policy will check for a vendor ID and three capabilities. |
|
4516 |
|
4517 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4518 Taking the address of the object will return a const TSecurityPolicy*. |
|
4519 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4520 function call operator n(). |
|
4521 |
|
4522 If an invlid capability value is specified then, dependant on the compiler, |
|
4523 a compile time error or warning be produced which includes the label |
|
4524 "__invalid_capability_value" |
|
4525 |
|
4526 @param vid The VID value to check for |
|
4527 @param c1 The first capability to check (enumerator of TCapability) |
|
4528 @param c2 The second capability to check (enumerator of TCapability) |
|
4529 @param c3 The third capability to check (enumerator of TCapability) |
|
4530 |
|
4531 @publishedAll |
|
4532 @released |
|
4533 */ |
|
4534 #define _INIT_SECURITY_POLICY_V3(vid,c1,c2,c3) \ |
|
4535 { \ |
|
4536 FOUR_TUINT8( \ |
|
4537 (TUint8)TSecurityPolicy::ETypeV3, \ |
|
4538 CAPABILITY_AS_TUINT8(c1), \ |
|
4539 CAPABILITY_AS_TUINT8(c2), \ |
|
4540 CAPABILITY_AS_TUINT8(c3) \ |
|
4541 ), \ |
|
4542 (TUint32)(vid) \ |
|
4543 } |
|
4544 |
|
4545 |
|
4546 /** Macro for compile-time definition of a security policy object |
|
4547 The policy will check for a vendor ID and three capabilities. |
|
4548 |
|
4549 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4550 Taking the address of the object will return a const TSecurityPolicy*. |
|
4551 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4552 function call operator n(). |
|
4553 |
|
4554 If an invlid capability value is specified then, dependant on the compiler, |
|
4555 a compile time error or warning be produced which includes the label |
|
4556 "__invalid_capability_value" |
|
4557 |
|
4558 @param n Name to use for policy object |
|
4559 @param vid The VID value to check for |
|
4560 @param c1 The first capability to check (enumerator of TCapability) |
|
4561 @param c2 The second capability to check (enumerator of TCapability) |
|
4562 @param c3 The third capability to check (enumerator of TCapability) |
|
4563 |
|
4564 @publishedAll |
|
4565 @released |
|
4566 */ |
|
4567 #define _LIT_SECURITY_POLICY_V3(n,vid,c1,c2,c3) \ |
|
4568 const TStaticSecurityPolicy n = _INIT_SECURITY_POLICY_V3(vid,c1,c2,c3) |
|
4569 |
|
4570 |
|
4571 /** Macro for compile-time initialisation of a security policy object |
|
4572 The policy will check for a vendor ID and two capabilities. |
|
4573 |
|
4574 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4575 Taking the address of the object will return a const TSecurityPolicy*. |
|
4576 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4577 function call operator n(). |
|
4578 |
|
4579 If an invlid capability value is specified then, dependant on the compiler, |
|
4580 a compile time error or warning be produced which includes the label |
|
4581 "__invalid_capability_value" |
|
4582 |
|
4583 @param vid The VID value to check for |
|
4584 @param c1 The first capability to check (enumerator of TCapability) |
|
4585 @param c2 The second capability to check (enumerator of TCapability) |
|
4586 |
|
4587 @publishedAll |
|
4588 @released |
|
4589 */ |
|
4590 #define _INIT_SECURITY_POLICY_V2(vid,c1,c2) \ |
|
4591 _INIT_SECURITY_POLICY_V3(vid,c1,c2,ECapability_None) |
|
4592 |
|
4593 |
|
4594 /** Macro for compile-time definition of a security policy object |
|
4595 The policy will check for a vendor ID and two capabilities. |
|
4596 |
|
4597 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4598 Taking the address of the object will return a const TSecurityPolicy*. |
|
4599 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4600 function call operator n(). |
|
4601 |
|
4602 If an invlid capability value is specified then, dependant on the compiler, |
|
4603 a compile time error or warning be produced which includes the label |
|
4604 "__invalid_capability_value" |
|
4605 |
|
4606 @param n Name to use for policy object |
|
4607 @param vid The VID value to check for |
|
4608 @param c1 The first capability to check (enumerator of TCapability) |
|
4609 @param c2 The second capability to check (enumerator of TCapability) |
|
4610 |
|
4611 @publishedAll |
|
4612 @released |
|
4613 */ |
|
4614 #define _LIT_SECURITY_POLICY_V2(n,vid,c1,c2) \ |
|
4615 _LIT_SECURITY_POLICY_V3(n,vid,c1,c2,ECapability_None) |
|
4616 |
|
4617 |
|
4618 /** Macro for compile-time initialisation of a security policy object |
|
4619 The policy will check for a vendor ID and one capability. |
|
4620 |
|
4621 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4622 Taking the address of the object will return a const TSecurityPolicy*. |
|
4623 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4624 function call operator n(). |
|
4625 |
|
4626 If an invlid capability value is specified then, dependant on the compiler, |
|
4627 a compile time error or warning be produced which includes the label |
|
4628 "__invalid_capability_value" |
|
4629 |
|
4630 @param vid The VID value to check for |
|
4631 @param c1 The first capability to check (enumerator of TCapability) |
|
4632 |
|
4633 @publishedAll |
|
4634 @released |
|
4635 */ |
|
4636 #define _INIT_SECURITY_POLICY_V1(vid,c1) \ |
|
4637 _INIT_SECURITY_POLICY_V3(vid,c1,ECapability_None,ECapability_None) |
|
4638 |
|
4639 |
|
4640 /** Macro for compile-time definition of a security policy object |
|
4641 The policy will check for a vendor ID and one capability. |
|
4642 |
|
4643 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4644 Taking the address of the object will return a const TSecurityPolicy*. |
|
4645 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4646 function call operator n(). |
|
4647 |
|
4648 If an invlid capability value is specified then, dependant on the compiler, |
|
4649 a compile time error or warning be produced which includes the label |
|
4650 "__invalid_capability_value" |
|
4651 |
|
4652 @param n Name to use for policy object |
|
4653 @param vid The VID value to check for |
|
4654 @param c1 The first capability to check (enumerator of TCapability) |
|
4655 |
|
4656 @publishedAll |
|
4657 @released |
|
4658 */ |
|
4659 #define _LIT_SECURITY_POLICY_V1(n,vid,c1) \ |
|
4660 _LIT_SECURITY_POLICY_V3(n,vid,c1,ECapability_None,ECapability_None) |
|
4661 |
|
4662 |
|
4663 /** Macro for compile-time initialisation of a security policy object |
|
4664 The policy will check for a vendor ID. |
|
4665 |
|
4666 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4667 Taking the address of the object will return a const TSecurityPolicy*. |
|
4668 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4669 function call operator n(). |
|
4670 |
|
4671 @param vid The VID value to check for |
|
4672 |
|
4673 @publishedAll |
|
4674 @released |
|
4675 */ |
|
4676 #define _INIT_SECURITY_POLICY_V0(vid) \ |
|
4677 _INIT_SECURITY_POLICY_V3(vid,ECapability_None,ECapability_None,ECapability_None) |
|
4678 |
|
4679 |
|
4680 /** Macro for compile-time definition of a security policy object |
|
4681 The policy will check for a vendor ID. |
|
4682 |
|
4683 The object declared has an implicit conversion to const TSecurityPolicy&. |
|
4684 Taking the address of the object will return a const TSecurityPolicy*. |
|
4685 Explicit conversion to const TSecurityPolicy& may be effected by using the |
|
4686 function call operator n(). |
|
4687 |
|
4688 @param n Name to use for policy object |
|
4689 @param vid The VID value to check for |
|
4690 |
|
4691 @publishedAll |
|
4692 @released |
|
4693 */ |
|
4694 #define _LIT_SECURITY_POLICY_V0(n,vid) \ |
|
4695 _LIT_SECURITY_POLICY_V3(n,vid,ECapability_None,ECapability_None,ECapability_None) |
|
4696 |
|
4697 |
|
4698 |
|
4699 #ifdef __KERNEL_MODE__ |
|
4700 class DThread; |
|
4701 class RMessageK; |
|
4702 #endif |
|
4703 class TPlatSecDiagnostic; |
|
4704 |
|
4705 /** |
|
4706 Class containing Platform Security related methods |
|
4707 @internalTechnology |
|
4708 */ |
|
4709 class PlatSec |
|
4710 { |
|
4711 #ifndef __KERNEL_MODE__ |
|
4712 public: |
|
4713 /** |
|
4714 Tests whether a given Platform Security capability is enforced by the system. |
|
4715 |
|
4716 Capabilities may not be enforced for several reasons: |
|
4717 -# The capability has been explicitly disabled on this system |
|
4718 by use of the PlatSecDisabledCaps configuration parameter |
|
4719 -# Platform Security checks have been globally disabled |
|
4720 by use of the EPlatSecEnforcement configuration parameter |
|
4721 -# The capability value is unknown. I.e. Is not part of the set of supported |
|
4722 capabilities. See TCapabilitySet::SetAllSupported(). |
|
4723 |
|
4724 @param aCapability The capability to test |
|
4725 @return A non-zero value if the capability is enforced, zero if it is not. |
|
4726 |
|
4727 @publishedAll |
|
4728 @released |
|
4729 */ |
|
4730 IMPORT_C static TBool IsCapabilityEnforced(TCapability aCapability); |
|
4731 |
|
4732 /** |
|
4733 An enumeration used with PlatSecSetting() |
|
4734 @see PlatSecSetting() |
|
4735 @publishedAll |
|
4736 @test |
|
4737 */ |
|
4738 enum TConfigSetting |
|
4739 { |
|
4740 EPlatSecEnforcement, /**< Used to request the value of the PlatSecEnforcement setting */ |
|
4741 EPlatSecDiagnotics, /**< Used to request the value of the PlatSecDiagnotics setting */ |
|
4742 EPlatSecProcessIsolation, /**< Used to request the value of the PlatSecProcessIsolation setting */ |
|
4743 EPlatSecEnforceSysBin, /**< Used to request the value of the PlatSecEnforceSysBin setting */ |
|
4744 EPlatSecLocked, /**< Used to request the value of the PlatSecLocked setting */ |
|
4745 }; |
|
4746 |
|
4747 /** |
|
4748 A test function to return the state of a given Platform Security configuration setting. |
|
4749 @param aSetting An enumerated value representing the required setting |
|
4750 @return A value representing the setting. 0 represents 'OFF', 1 represents 'ON' |
|
4751 Other values may be returned for some settings, these exceptions are documented |
|
4752 in the description for individual enumerations of TConfigSetting. |
|
4753 @see TConfigSetting |
|
4754 @publishedAll |
|
4755 @test |
|
4756 */ |
|
4757 IMPORT_C static TInt ConfigSetting(TConfigSetting aSetting); |
|
4758 |
|
4759 #endif // Not __KERNEL_MODE__ |
|
4760 |
|
4761 // |
|
4762 // All methods below here are internalTechnology |
|
4763 // |
|
4764 |
|
4765 #ifndef __REMOVE_PLATSEC_DIAGNOSTICS__ |
|
4766 public: |
|
4767 /** @internalTechnology */ |
|
4768 static inline TInt LoaderCapabilityViolation(const TDesC8& aImporterName, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps); |
|
4769 #ifdef __KERNEL_MODE__ |
|
4770 /** @internalTechnology */ |
|
4771 static inline TInt CapabilityCheckFail(const DProcess* aViolatingProcess, TCapability aCapability, const char* aContextText); |
|
4772 /** @internalTechnology */ |
|
4773 static inline TInt CapabilityCheckFail(const DThread* aViolatingThread, TCapability aCapability, const char* aContextText); |
|
4774 /** @internalTechnology */ |
|
4775 static inline TInt SecureIdCheckFail(const DProcess* aViolatingProcess, TSecureId aSid, const char* aContextText); |
|
4776 /** @internalTechnology */ |
|
4777 static inline TInt PolicyCheckFail(const DProcess* aProcess, const SSecurityInfo& aMissing, const char* aContextText); |
|
4778 /** @internalTechnology */ |
|
4779 static inline TInt PolicyCheckFail(const DThread* aProcess, const SSecurityInfo& aMissing, const char* aContextText); |
|
4780 /** @internalTechnology */ |
|
4781 static inline TInt ProcessIsolationFail(const char* aContextText); |
|
4782 /** @internalTechnology */ |
|
4783 static inline TInt ProcessIsolationIPCFail(RMessageK* aMessage, const char* aContextText); |
|
4784 #else // !__KERNEL_MODE__ |
|
4785 /** @internalTechnology */ |
|
4786 static inline TInt LoaderCapabilityViolation(RProcess aLoadingProcess, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps); |
|
4787 /** @internalTechnology */ |
|
4788 static inline TInt CreatorCapabilityCheckFail(TCapability aCapability, const char* aContextText); |
|
4789 /** @internalTechnology */ |
|
4790 static inline TInt CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps, const char* aContextText); |
|
4791 /** @internalTechnology */ |
|
4792 static inline TInt CapabilityCheckFail(TInt aHandle, TCapability aCapability, const char* aContextText); |
|
4793 /** @internalTechnology */ |
|
4794 static inline TInt CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps, const char* aContextText); |
|
4795 /** @internalTechnology */ |
|
4796 static inline TInt PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissing, const char* aContextText); |
|
4797 /** @internalTechnology */ |
|
4798 static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability, const char* aContextText); |
|
4799 /** @internalTechnology */ |
|
4800 static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps, const char* aContextText); |
|
4801 /** @internalTechnology */ |
|
4802 static inline TInt PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissingCaps, const char* aContextText); |
|
4803 /** @internalTechnology */ |
|
4804 static inline TInt PolicyCheckFail(RSessionBase aSession, const SSecurityInfo& aMissingCaps, const char* aContextText); |
|
4805 /** @internalTechnology */ |
|
4806 static inline TInt CreatorPolicyCheckFail(const SSecurityInfo& aMissingCaps, const char* aContextText); |
|
4807 /** @internalTechnology */ |
|
4808 static inline TInt CreatorCapabilityCheckFail(TCapability aCapability); |
|
4809 /** @internalTechnology */ |
|
4810 static inline TInt CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps); |
|
4811 /** @internalTechnology */ |
|
4812 static inline TInt CapabilityCheckFail(TInt aHandle, TCapability aCapability); |
|
4813 /** @internalTechnology */ |
|
4814 static inline TInt CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps); |
|
4815 /** @internalTechnology */ |
|
4816 static inline TInt PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissing); |
|
4817 /** @internalTechnology */ |
|
4818 static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability); |
|
4819 /** @internalTechnology */ |
|
4820 static inline TInt CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps); |
|
4821 /** @internalTechnology */ |
|
4822 static inline TInt PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissingCaps); |
|
4823 /** @internalTechnology */ |
|
4824 static inline TInt CreatorPolicyCheckFail(const SSecurityInfo& aMissingCaps); |
|
4825 #endif //__KERNEL_MODE__ |
|
4826 |
|
4827 private: |
|
4828 UIMPORT_C static TInt EmitDiagnostic(TPlatSecDiagnostic& aDiagnostic, const char* aContextText); |
|
4829 #else //__REMOVE_PLATSEC_DIAGNOSTICS__ |
|
4830 #ifndef __KERNEL_MODE__ |
|
4831 private: |
|
4832 IMPORT_C static TInt EmitDiagnostic(TPlatSecDiagnostic& aDiagnostic, const char* aContextText); |
|
4833 #endif // !__KERNEL_MODE__ |
|
4834 #endif // !__REMOVE_PLATSEC_DIAGNOSTICS__ |
|
4835 |
|
4836 public: |
|
4837 /** @internalTechnology */ |
|
4838 UIMPORT_C static TInt EmitDiagnostic(); |
|
4839 }; |
|
4840 |
|
4841 |
|
4842 |
|
4843 /** |
|
4844 @publishedAll |
|
4845 @released |
|
4846 |
|
4847 Contains information about the code and data sections belonging to a process. |
|
4848 |
|
4849 @see RProcess::GetMemoryInfo |
|
4850 */ |
|
4851 class TProcessMemoryInfo |
|
4852 { |
|
4853 public: |
|
4854 /** |
|
4855 The code base address (.text). |
|
4856 */ |
|
4857 TUint32 iCodeBase; |
|
4858 |
|
4859 |
|
4860 /** |
|
4861 The size of the code section (.text). |
|
4862 */ |
|
4863 TUint32 iCodeSize; |
|
4864 |
|
4865 |
|
4866 /** |
|
4867 The base address of the constant data section (.radata). |
|
4868 */ |
|
4869 TUint32 iConstDataBase; |
|
4870 |
|
4871 |
|
4872 /** |
|
4873 The size of the constant data section (.radata). |
|
4874 */ |
|
4875 |
|
4876 TUint32 iConstDataSize; |
|
4877 |
|
4878 |
|
4879 /** |
|
4880 The base address of the initialised data section (.data). |
|
4881 */ |
|
4882 TUint32 iInitialisedDataBase; |
|
4883 |
|
4884 |
|
4885 /** |
|
4886 The size of the initialised data section (.data). |
|
4887 */ |
|
4888 TUint32 iInitialisedDataSize; |
|
4889 |
|
4890 |
|
4891 /** |
|
4892 The base address of the uninitialised data section (.bss). |
|
4893 */ |
|
4894 TUint32 iUninitialisedDataBase; |
|
4895 |
|
4896 |
|
4897 /** |
|
4898 The size of the uninitialised data section (.bss). |
|
4899 */ |
|
4900 TUint32 iUninitialisedDataSize; |
|
4901 }; |
|
4902 |
|
4903 |
|
4904 |
|
4905 |
|
4906 /** |
|
4907 @publishedAll |
|
4908 @released |
|
4909 |
|
4910 Defines a more useful synonym for TProcessMemoryInfo. |
|
4911 */ |
|
4912 typedef TProcessMemoryInfo TModuleMemoryInfo; // more accurate name - remove old one later |
|
4913 |
|
4914 |
|
4915 |
|
4916 |
|
4917 #ifndef __KERNEL_MODE__ |
|
4918 class CBase; |
|
4919 /** |
|
4920 @publishedAll |
|
4921 @released |
|
4922 |
|
4923 Generic array. |
|
4924 |
|
4925 This class defines a generic array which can be constructed by any of the |
|
4926 following templated concrete arrays: |
|
4927 |
|
4928 1. CArrayFixFlat<class T> |
|
4929 |
|
4930 2. CArrayFixSeg<class T> |
|
4931 |
|
4932 3. CArrayVarFlat<class T> |
|
4933 |
|
4934 4. CArrayVarSeg<class T> |
|
4935 |
|
4936 5. CArrayPakFlat<class T> |
|
4937 |
|
4938 6. RArray<class T> |
|
4939 |
|
4940 7. RPointerArray<class T> |
|
4941 |
|
4942 and also by the following template specialisation classes: |
|
4943 |
|
4944 1. RArray<TInt> |
|
4945 |
|
4946 2. RArray<TUint> |
|
4947 |
|
4948 It allows a degree of polymorphism amongst the array classes. It permits the |
|
4949 operator[] and the Count() member functions of an array to be invoked without |
|
4950 knowing which array class has been used to construct that array. |
|
4951 |
|
4952 TArray allows access to elements of an array but does not permit changes to |
|
4953 those elements. |
|
4954 |
|
4955 Use the Array() member function of an array to construct and return |
|
4956 a TArray<class T> object for that array. |
|
4957 |
|
4958 A TArray<class T> type object is not intended to be constructed explicitly |
|
4959 by user code. |
|
4960 |
|
4961 @see CArrayFixFlat |
|
4962 @see CArrayFixSeg |
|
4963 @see CArrayVarFlat |
|
4964 @see CArrayVarSeg |
|
4965 @see CArrayPakFlat |
|
4966 @see RArray |
|
4967 @see RPointerArray |
|
4968 @see RArray<TInt> |
|
4969 @see RArray<TUint> |
|
4970 */ |
|
4971 template <class T> |
|
4972 class TArray |
|
4973 { |
|
4974 public: |
|
4975 inline TArray(TInt (*aCount)(const CBase* aPtr),const TAny*(*anAt)(const CBase* aPtr,TInt anIndex),const CBase* aPtr); |
|
4976 inline TInt Count() const; |
|
4977 inline const T& operator[](TInt anIndex) const; |
|
4978 private: |
|
4979 const CBase* iPtr; |
|
4980 TInt (*iCount)(const CBase* aPtr); |
|
4981 const TAny*(*iAt)(const CBase* aPtr,TInt anIndex); |
|
4982 }; |
|
4983 #endif |
|
4984 |
|
4985 |
|
4986 |
|
4987 |
|
4988 /** |
|
4989 @publishedAll |
|
4990 @released |
|
4991 |
|
4992 Defines a function type used by a TIdentityRelation object. |
|
4993 |
|
4994 A function of this type implements an algorithm for determining whether |
|
4995 two objects match. |
|
4996 |
|
4997 @see TIdentityRelation |
|
4998 */ |
|
4999 typedef TBool (*TGeneralIdentityRelation)(const TAny*, const TAny*); |
|
5000 |
|
5001 |
|
5002 |
|
5003 |
|
5004 /** |
|
5005 @publishedAll |
|
5006 @released |
|
5007 |
|
5008 Defines a function type used by a TLinearOrder object |
|
5009 |
|
5010 A function of this type implements an algorithm that determines |
|
5011 the order of two objects. |
|
5012 |
|
5013 @see TLinearOrder |
|
5014 */ |
|
5015 typedef TInt (*TGeneralLinearOrder)(const TAny*, const TAny*); |
|
5016 |
|
5017 |
|
5018 |
|
5019 |
|
5020 /** |
|
5021 @publishedAll |
|
5022 @released |
|
5023 |
|
5024 A templated class which packages a function that determines whether two |
|
5025 objects of a given class type match. During linear search operations the search |
|
5026 term is always passed as the first argument and the second argument is an |
|
5027 element of the array being searched. |
|
5028 |
|
5029 A TIdentityRelation<T> object is constructed and passed as a parameter to |
|
5030 member functions of the array classes RArray<T> and RPointerArray<T>. |
|
5031 |
|
5032 @see RArray |
|
5033 @see RPointerArray |
|
5034 */ |
|
5035 template <class T> |
|
5036 class TIdentityRelation |
|
5037 { |
|
5038 public: |
|
5039 inline TIdentityRelation(); |
|
5040 inline TIdentityRelation( TBool (*anIdentity)(const T&, const T&) ); |
|
5041 inline operator TGeneralIdentityRelation() const; |
|
5042 private: |
|
5043 inline static TBool EqualityOperatorCompare(const T& aLeft, const T& aRight); |
|
5044 private: |
|
5045 TGeneralIdentityRelation iIdentity; |
|
5046 }; |
|
5047 |
|
5048 |
|
5049 |
|
5050 /** |
|
5051 @publishedAll |
|
5052 @released |
|
5053 |
|
5054 A set of common identity relations for frequently occurring types. |
|
5055 |
|
5056 @see RArray |
|
5057 @see RPointerArray |
|
5058 @see RHashSet |
|
5059 @see RPtrHashSet |
|
5060 @see RHashMap |
|
5061 @see RPtrHashMap |
|
5062 */ |
|
5063 class DefaultIdentity |
|
5064 { |
|
5065 public: |
|
5066 IMPORT_C static TBool Integer(const TInt&, const TInt&); |
|
5067 IMPORT_C static TBool Des8(const TDesC8&, const TDesC8&); |
|
5068 IMPORT_C static TBool Des16(const TDesC16&, const TDesC16&); |
|
5069 IMPORT_C static TBool IntegerPtr(TInt* const&, TInt* const&); |
|
5070 IMPORT_C static TBool Des8Ptr(TDesC8* const&, TDesC8* const&); |
|
5071 IMPORT_C static TBool Des16Ptr(TDesC16* const&, TDesC16* const&); |
|
5072 }; |
|
5073 |
|
5074 |
|
5075 |
|
5076 |
|
5077 /** |
|
5078 @publishedAll |
|
5079 @released |
|
5080 |
|
5081 A templated class which packages a function that determines the order of two |
|
5082 objects of a given class type. During binary search operations the search term |
|
5083 is always passed as the first argument and the second argument is an element |
|
5084 of the array being searched. |
|
5085 |
|
5086 A TLinearOrder<T> object is constructed and passed as a parameter to member |
|
5087 functions of the array classes RArray<T> and RPointerArray<T>. |
|
5088 |
|
5089 @see RArray |
|
5090 @see RPointerArray |
|
5091 */ |
|
5092 template <class T> |
|
5093 class TLinearOrder |
|
5094 { |
|
5095 public: |
|
5096 inline TLinearOrder( TInt(*anOrder)(const T&, const T&) ); |
|
5097 inline operator TGeneralLinearOrder() const; |
|
5098 private: |
|
5099 TGeneralLinearOrder iOrder; |
|
5100 }; |
|
5101 |
|
5102 |
|
5103 /* |
|
5104 @publishedAll |
|
5105 @released |
|
5106 |
|
5107 A set of values that tell array search functions which array element is to be |
|
5108 returned when there are duplicate elements in the array. |
|
5109 |
|
5110 These values are used by RArray, RPointerArray, RArray<TInt>, |
|
5111 and RArray<TUint> search functions. |
|
5112 |
|
5113 Examples of functions that take |
|
5114 these enum values are: RPointerArray::SpecificFindInOrderL(), |
|
5115 and RArray::SpecificFindInSignedKeyOrder(). |
|
5116 |
|
5117 @see RArray |
|
5118 @see RPointerArray |
|
5119 @see RArray<TInt> |
|
5120 @see RArray<TUint> |
|
5121 */ |
|
5122 enum TArrayFindMode |
|
5123 { |
|
5124 /** |
|
5125 Indicates that any element in a block of duplicate elements can be |
|
5126 returned by a search function. |
|
5127 |
|
5128 Note that using this mode, there can be no guarantee that the element |
|
5129 returned by the search functions will be the same if the size of the array |
|
5130 changes between successive calls to those functions. |
|
5131 */ |
|
5132 EArrayFindMode_Any = 0, |
|
5133 |
|
5134 /** |
|
5135 Indicates that the first element in a block of duplicate elements |
|
5136 is returned. |
|
5137 */ |
|
5138 EArrayFindMode_First = 1, |
|
5139 |
|
5140 /** |
|
5141 Indicates that the first element after the last element in a block |
|
5142 of duplicate elements is returned. |
|
5143 */ |
|
5144 EArrayFindMode_Last = 2, |
|
5145 |
|
5146 /** |
|
5147 @internalTechnology |
|
5148 */ |
|
5149 EArrayFindMode_Limit = 3 |
|
5150 }; |
|
5151 |
|
5152 |
|
5153 /** |
|
5154 @internalComponent |
|
5155 |
|
5156 Base class used in the derivation of RPointerArray, RArray<TInt>, |
|
5157 and RArray<TUint>. |
|
5158 |
|
5159 The base class is inherited privately. |
|
5160 |
|
5161 The class is internal and is not intended for use. |
|
5162 */ |
|
5163 class RPointerArrayBase |
|
5164 { |
|
5165 protected: |
|
5166 IMPORT_C RPointerArrayBase(); |
|
5167 IMPORT_C RPointerArrayBase(TInt aGranularity); |
|
5168 IMPORT_C RPointerArrayBase(TInt aMinGrowBy, TInt aFactor); |
|
5169 IMPORT_C void Close(); |
|
5170 IMPORT_C TInt Count() const; |
|
5171 inline void ZeroCount() {iCount=0;} |
|
5172 inline TAny** Entries() {return iEntries;} |
|
5173 IMPORT_C TAny*& At(TInt anIndex) const; |
|
5174 IMPORT_C TInt Append(const TAny* anEntry); |
|
5175 IMPORT_C TInt Insert(const TAny* anEntry, TInt aPos); |
|
5176 IMPORT_C void Remove(TInt anIndex); |
|
5177 IMPORT_C void Compress(); |
|
5178 IMPORT_C void Reset(); |
|
5179 IMPORT_C TInt Find(const TAny* anEntry) const; |
|
5180 IMPORT_C TInt Find(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const; |
|
5181 IMPORT_C TInt FindReverse(const TAny* aEntry) const; |
|
5182 IMPORT_C TInt FindReverse(const TAny* aEntry, TGeneralIdentityRelation aIdentity) const; |
|
5183 IMPORT_C TInt FindIsqSigned(TInt anEntry) const; |
|
5184 IMPORT_C TInt FindIsqUnsigned(TUint anEntry) const; |
|
5185 IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder) const; |
|
5186 IMPORT_C TInt FindIsqSigned(TInt anEntry, TInt aMode) const; |
|
5187 IMPORT_C TInt FindIsqUnsigned(TUint anEntry, TInt aMode) const; |
|
5188 IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TInt aMode) const; |
|
5189 IMPORT_C TInt InsertIsqSigned(TInt anEntry, TBool aAllowRepeats); |
|
5190 IMPORT_C TInt InsertIsqUnsigned(TUint anEntry, TBool aAllowRepeats); |
|
5191 IMPORT_C TInt InsertIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TBool aAllowRepeats); |
|
5192 IMPORT_C TInt BinarySearchSigned(TInt anEntry, TInt& anIndex) const; |
|
5193 IMPORT_C TInt BinarySearchUnsigned(TUint anEntry, TInt& anIndex) const; |
|
5194 IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder) const; |
|
5195 IMPORT_C TInt BinarySearchSigned(TInt anEntry, TInt& anIndex, TInt aMode) const; |
|
5196 IMPORT_C TInt BinarySearchUnsigned(TUint anEntry, TInt& anIndex, TInt aMode) const; |
|
5197 IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const; |
|
5198 #ifndef __KERNEL_MODE__ |
|
5199 IMPORT_C RPointerArrayBase(TAny** aEntries, TInt aCount); |
|
5200 IMPORT_C void GranularCompress(); |
|
5201 IMPORT_C TInt DoReserve(TInt aCount); |
|
5202 IMPORT_C void HeapSortSigned(); |
|
5203 IMPORT_C void HeapSortUnsigned(); |
|
5204 IMPORT_C void HeapSort(TGeneralLinearOrder anOrder); |
|
5205 IMPORT_C static TInt GetCount(const CBase* aPtr); |
|
5206 IMPORT_C static const TAny* GetElementPtr(const CBase* aPtr, TInt aIndex); |
|
5207 #endif |
|
5208 private: |
|
5209 TInt Grow(); |
|
5210 private: |
|
5211 TInt iCount; |
|
5212 TAny** iEntries; |
|
5213 TInt iAllocated; |
|
5214 TInt iGranularity; // positive means linear, negative means exponential growth |
|
5215 TInt iSpare1; |
|
5216 TInt iSpare2; |
|
5217 }; |
|
5218 |
|
5219 |
|
5220 |
|
5221 |
|
5222 /** |
|
5223 @publishedAll |
|
5224 @released |
|
5225 |
|
5226 A simple and efficient array of pointers to objects. |
|
5227 |
|
5228 The elements of the array are pointers to instances of a class; this class |
|
5229 is specified as the template parameter T. |
|
5230 |
|
5231 The class offers standard array behaviour which includes insertion, appending |
|
5232 and sorting of pointers. |
|
5233 |
|
5234 Derivation from RPointerArrayBase is private. |
|
5235 */ |
|
5236 template <class T> |
|
5237 class RPointerArray : private RPointerArrayBase |
|
5238 { |
|
5239 public: |
|
5240 inline RPointerArray(); |
|
5241 inline explicit RPointerArray(TInt aGranularity); |
|
5242 inline RPointerArray(TInt aMinGrowBy, TInt aFactor); |
|
5243 inline void Close(); |
|
5244 inline TInt Count() const; |
|
5245 inline T* const& operator[](TInt anIndex) const; |
|
5246 inline T*& operator[](TInt anIndex); |
|
5247 inline TInt Append(const T* anEntry); |
|
5248 inline TInt Insert(const T* anEntry, TInt aPos); |
|
5249 inline void Remove(TInt anIndex); |
|
5250 inline void Compress(); |
|
5251 inline void Reset(); |
|
5252 void ResetAndDestroy(); |
|
5253 inline TInt Find(const T* anEntry) const; |
|
5254 inline TInt Find(const T* anEntry, TIdentityRelation<T> anIdentity) const; |
|
5255 template <class K> |
|
5256 inline TInt Find(const K& aKey, TBool (*apfnCompare)(const K* k, const T& t)) const |
|
5257 /** |
|
5258 Finds the first object pointer in the array which matches aKey using |
|
5259 the comparison algorithm provided by apfnCompare. |
|
5260 |
|
5261 The find operation always starts at the low index end of the array. There |
|
5262 is no assumption about the order of objects in the array. |
|
5263 |
|
5264 @param aKey The key of type K to be compared with the elements of the array using apfnCompare. |
|
5265 @param apfnCompare A function defining the identity relation between the |
|
5266 object pointers in the array, and their keys of type K. The |
|
5267 function returns true if k and t match based on this relationship. |
|
5268 |
|
5269 @return The index of the first matching object pointer within the array. |
|
5270 KErrNotFound, if no suitable object pointer can be found. |
|
5271 */ |
|
5272 { return RPointerArrayBase::Find((T*)&aKey,*(TIdentityRelation<T>*)&apfnCompare); } |
|
5273 inline TInt FindReverse(const T* anEntry) const; |
|
5274 inline TInt FindReverse(const T* anEntry, TIdentityRelation<T> anIdentity) const; |
|
5275 template <class K> |
|
5276 inline TInt FindReverse(const K& aKey, TInt (*apfnMatch)(const K* k, const T& t)) const |
|
5277 /** |
|
5278 Finds the first object pointer in the array which matches aKey using |
|
5279 the comparison algorithm provided by apfnCompare. |
|
5280 |
|
5281 The find operation always starts at the high index end of the array. There |
|
5282 is no assumption about the order of objects in the array. |
|
5283 |
|
5284 @param aKey The key of type K to be compared with the elements of the array using apfnMatch. |
|
5285 @param apfnMatch A function defining the identity relation between the |
|
5286 object pointers in the array, and their keys of type K. The |
|
5287 function returns true if k and t match based on this relationship. |
|
5288 |
|
5289 @return The index of the first matching object pointer within the array. |
|
5290 KErrNotFound, if no suitable object pointer can be found. |
|
5291 */ |
|
5292 |
|
5293 { return RPointerArrayBase::FindReverse((T*)&aKey,*(TIdentityRelation<T>*)&apfnMatch); } |
|
5294 inline TInt FindInAddressOrder(const T* anEntry) const; |
|
5295 inline TInt FindInOrder(const T* anEntry, TLinearOrder<T> anOrder) const; |
|
5296 inline TInt FindInAddressOrder(const T* anEntry, TInt& anIndex) const; |
|
5297 inline TInt FindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const; |
|
5298 template <class K> |
|
5299 inline TInt FindInOrder(const K& aKey, TInt (*apfnCompare)(const K* k, const T& t)) const |
|
5300 /** |
|
5301 Finds the object pointer in the array whose object matches the specified |
|
5302 key, (Using the relationship defined within apfnCompare) using a binary search |
|
5303 technique and an ordering algorithm. |
|
5304 |
|
5305 The function assumes that existing object pointers in the array are ordered |
|
5306 so that the objects themselves are in object order as determined by an algorithm |
|
5307 supplied by the caller and packaged as a TLinearOrder<T>. |
|
5308 |
|
5309 @param aKey The key of type K to be compared with the elements of the array using apfnCompare. |
|
5310 @param apfnCompare A function which defines the order that the array was sorted, |
|
5311 where in it aKey (via the defined relationship) should fit, and if the key is present. |
|
5312 |
|
5313 @return The index of the matching object pointer within the array. |
|
5314 KErrNotFound, if no suitable object pointer can be found. |
|
5315 */ |
|
5316 { return RPointerArrayBase::FindIsq((T*)&aKey,*(TLinearOrder<T>*)&apfnCompare); } |
|
5317 inline TInt SpecificFindInAddressOrder(const T* anEntry, TInt aMode) const; |
|
5318 inline TInt SpecificFindInOrder(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const; |
|
5319 inline TInt SpecificFindInAddressOrder(const T* anEntry, TInt& anIndex, TInt aMode) const; |
|
5320 inline TInt SpecificFindInOrder(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const; |
|
5321 inline TInt InsertInAddressOrder(const T* anEntry); |
|
5322 inline TInt InsertInOrder(const T* anEntry, TLinearOrder<T> anOrder); |
|
5323 inline TInt InsertInAddressOrderAllowRepeats(const T* anEntry); |
|
5324 inline TInt InsertInOrderAllowRepeats(const T* anEntry, TLinearOrder<T> anOrder); |
|
5325 #ifndef __KERNEL_MODE__ |
|
5326 inline void AppendL(const T* anEntry); |
|
5327 inline void InsertL(const T* anEntry, TInt aPos); |
|
5328 inline TInt FindL(const T* anEntry) const; |
|
5329 inline TInt FindL(const T* anEntry, TIdentityRelation<T> anIdentity) const; |
|
5330 inline TInt FindReverseL(const T* anEntry) const; |
|
5331 inline TInt FindReverseL(const T* anEntry, TIdentityRelation<T> anIdentity) const; |
|
5332 inline TInt FindInAddressOrderL(const T* anEntry) const; |
|
5333 inline TInt FindInOrderL(const T* anEntry, TLinearOrder<T> anOrder) const; |
|
5334 inline void FindInAddressOrderL(const T* anEntry, TInt& anIndex) const; |
|
5335 inline void FindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const; |
|
5336 inline TInt SpecificFindInAddressOrderL(const T* anEntry, TInt aMode) const; |
|
5337 inline TInt SpecificFindInOrderL(const T* anEntry, TLinearOrder<T> anOrder, TInt aMode) const; |
|
5338 inline void SpecificFindInAddressOrderL(const T* anEntry, TInt& anIndex, TInt aMode) const; |
|
5339 inline void SpecificFindInOrderL(const T* anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const; |
|
5340 inline void InsertInAddressOrderL(const T* anEntry); |
|
5341 inline void InsertInOrderL(const T* anEntry, TLinearOrder<T> anOrder); |
|
5342 inline void InsertInAddressOrderAllowRepeatsL(const T* anEntry); |
|
5343 inline void InsertInOrderAllowRepeatsL(const T* anEntry, TLinearOrder<T> anOrder); |
|
5344 |
|
5345 inline RPointerArray(T** aEntries, TInt aCount); |
|
5346 inline void GranularCompress(); |
|
5347 inline TInt Reserve(TInt aCount); |
|
5348 inline void ReserveL(TInt aCount); |
|
5349 inline void SortIntoAddressOrder(); |
|
5350 inline void Sort(TLinearOrder<T> anOrder); |
|
5351 inline TArray<T*> Array() const; |
|
5352 #endif |
|
5353 }; |
|
5354 |
|
5355 |
|
5356 |
|
5357 /** |
|
5358 @publishedAll |
|
5359 @released |
|
5360 |
|
5361 Array of raw pointers. |
|
5362 |
|
5363 The array is a simple and efficient specialized array of TAny pointers offering |
|
5364 standard array behaviour. |
|
5365 |
|
5366 The derivation from RPointerArrayBase is private. |
|
5367 */ |
|
5368 TEMPLATE_SPECIALIZATION class RPointerArray<TAny> : private RPointerArrayBase |
|
5369 { |
|
5370 public: |
|
5371 inline RPointerArray(); |
|
5372 inline explicit RPointerArray(TInt aGranularity); |
|
5373 inline RPointerArray(TInt aMinGrowBy, TInt aFactor); |
|
5374 inline void Close(); |
|
5375 inline TInt Count() const; |
|
5376 inline TAny* const& operator[](TInt anIndex) const; |
|
5377 inline TAny*& operator[](TInt anIndex); |
|
5378 inline TInt Append(const TAny* anEntry); |
|
5379 inline TInt Insert(const TAny* anEntry, TInt aPos); |
|
5380 inline void Remove(TInt anIndex); |
|
5381 inline void Compress(); |
|
5382 inline void Reset(); |
|
5383 inline TInt Find(const TAny* anEntry) const; |
|
5384 inline TInt FindReverse(const TAny* anEntry) const; |
|
5385 inline TInt FindInAddressOrder(const TAny* anEntry) const; |
|
5386 inline TInt FindInAddressOrder(const TAny* anEntry, TInt& anIndex) const; |
|
5387 inline TInt SpecificFindInAddressOrder(const TAny* anEntry, TInt aMode) const; |
|
5388 inline TInt SpecificFindInAddressOrder(const TAny* anEntry, TInt& anIndex, TInt aMode) const; |
|
5389 inline TInt InsertInAddressOrder(const TAny* anEntry); |
|
5390 inline TInt InsertInAddressOrderAllowRepeats(const TAny* anEntry); |
|
5391 #ifndef __KERNEL_MODE__ |
|
5392 inline void AppendL(const TAny* anEntry); |
|
5393 inline void InsertL(const TAny* anEntry, TInt aPos); |
|
5394 inline TInt FindL(const TAny* anEntry) const; |
|
5395 inline TInt FindReverseL(const TAny* anEntry) const; |
|
5396 inline TInt FindInAddressOrderL(const TAny* anEntry) const; |
|
5397 inline void FindInAddressOrderL(const TAny* anEntry, TInt& anIndex) const; |
|
5398 inline TInt SpecificFindInAddressOrderL(const TAny* anEntry, TInt aMode) const; |
|
5399 inline void SpecificFindInAddressOrderL(const TAny* anEntry, TInt& anIndex, TInt aMode) const; |
|
5400 inline void InsertInAddressOrderL(const TAny* anEntry); |
|
5401 inline void InsertInAddressOrderAllowRepeatsL(const TAny* anEntry); |
|
5402 |
|
5403 inline RPointerArray(TAny** aEntries, TInt aCount); |
|
5404 inline void GranularCompress(); |
|
5405 inline void SortIntoAddressOrder(); |
|
5406 inline TArray<TAny*> Array() const; |
|
5407 #endif |
|
5408 }; |
|
5409 |
|
5410 |
|
5411 |
|
5412 /** |
|
5413 @internalComponent |
|
5414 |
|
5415 Base class used in the derivation of RArray. |
|
5416 |
|
5417 The base class is inherited privately. |
|
5418 |
|
5419 The class is internal and is not intended for use. |
|
5420 */ |
|
5421 class RArrayBase |
|
5422 { |
|
5423 protected: |
|
5424 IMPORT_C RArrayBase(TInt anEntrySize); |
|
5425 IMPORT_C RArrayBase(TInt anEntrySize, TInt aGranularity); |
|
5426 IMPORT_C RArrayBase(TInt anEntrySize, TInt aGranularity, TInt aKeyOffset); |
|
5427 IMPORT_C RArrayBase(TInt anEntrySize, TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor); |
|
5428 IMPORT_C RArrayBase(TInt aEntrySize,TAny* aEntries, TInt aCount); |
|
5429 IMPORT_C void Close(); |
|
5430 IMPORT_C TInt Count() const; |
|
5431 IMPORT_C TAny* At(TInt anIndex) const; |
|
5432 IMPORT_C TInt Append(const TAny* anEntry); |
|
5433 IMPORT_C TInt Insert(const TAny* anEntry, TInt aPos); |
|
5434 IMPORT_C void Remove(TInt anIndex); |
|
5435 IMPORT_C void Compress(); |
|
5436 IMPORT_C void Reset(); |
|
5437 IMPORT_C TInt Find(const TAny* anEntry) const; |
|
5438 IMPORT_C TInt Find(const TAny* anEntry, TGeneralIdentityRelation anIdentity) const; |
|
5439 IMPORT_C TInt FindReverse(const TAny* aEntry) const; |
|
5440 IMPORT_C TInt FindReverse(const TAny* aEntry, TGeneralIdentityRelation aIdentity) const; |
|
5441 IMPORT_C TInt FindIsqSigned(const TAny* anEntry) const; |
|
5442 IMPORT_C TInt FindIsqUnsigned(const TAny* anEntry) const; |
|
5443 IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder) const; |
|
5444 IMPORT_C TInt FindIsqSigned(const TAny* anEntry, TInt aMode) const; |
|
5445 IMPORT_C TInt FindIsqUnsigned(const TAny* anEntry, TInt aMode) const; |
|
5446 IMPORT_C TInt FindIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TInt aMode) const; |
|
5447 IMPORT_C TInt InsertIsqSigned(const TAny* anEntry, TBool aAllowRepeats); |
|
5448 IMPORT_C TInt InsertIsqUnsigned(const TAny* anEntry, TBool aAllowRepeats); |
|
5449 IMPORT_C TInt InsertIsq(const TAny* anEntry, TGeneralLinearOrder anOrder, TBool aAllowRepeats); |
|
5450 IMPORT_C TInt BinarySearchSigned(const TAny* anEntry, TInt& anIndex) const; |
|
5451 IMPORT_C TInt BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex) const; |
|
5452 IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder) const; |
|
5453 IMPORT_C TInt BinarySearchSigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const; |
|
5454 IMPORT_C TInt BinarySearchUnsigned(const TAny* anEntry, TInt& anIndex, TInt aMode) const; |
|
5455 IMPORT_C TInt BinarySearch(const TAny* anEntry, TInt& anIndex, TGeneralLinearOrder anOrder, TInt aMode) const; |
|
5456 #ifndef __KERNEL_MODE__ |
|
5457 IMPORT_C void GranularCompress(); |
|
5458 IMPORT_C TInt DoReserve(TInt aCount); |
|
5459 IMPORT_C void HeapSortSigned(); |
|
5460 IMPORT_C void HeapSortUnsigned(); |
|
5461 IMPORT_C void HeapSort(TGeneralLinearOrder anOrder); |
|
5462 IMPORT_C static TInt GetCount(const CBase* aPtr); |
|
5463 IMPORT_C static const TAny* GetElementPtr(const CBase* aPtr, TInt aIndex); |
|
5464 #endif |
|
5465 private: |
|
5466 TInt Grow(); |
|
5467 private: |
|
5468 TInt iCount; |
|
5469 TAny* iEntries; |
|
5470 TInt iEntrySize; |
|
5471 TInt iKeyOffset; |
|
5472 TInt iAllocated; |
|
5473 TInt iGranularity; // positive means linear, negative means exponential growth |
|
5474 TInt iSpare1; |
|
5475 TInt iSpare2; |
|
5476 }; |
|
5477 |
|
5478 |
|
5479 |
|
5480 |
|
5481 /** |
|
5482 @publishedAll |
|
5483 @released |
|
5484 |
|
5485 A simple and efficient array of fixed length objects. |
|
5486 |
|
5487 The elements of the array are instances of a class; this class is specified |
|
5488 as the template parameter T. |
|
5489 |
|
5490 The array offers standard array behaviour which includes insertion, appending |
|
5491 and sorting of elements. |
|
5492 |
|
5493 Note: |
|
5494 |
|
5495 1. where possible, this class should be used in preference to |
|
5496 CArrayFixFlat<classT>. |
|
5497 |
|
5498 2. the derivation from RArrayBase is private. |
|
5499 |
|
5500 3. for performance reasons, RArray stores objects in the array as |
|
5501 word (4 byte) aligned quantities. This means that some member functions |
|
5502 do not work when RArray is instantiated for classes of less than 4 bytes |
|
5503 in size, or when the class's alignment requirement is not 4. |
|
5504 Be aware that it is possible to get an unhandled exception on hardware |
|
5505 that enforces strict alignment. |
|
5506 |
|
5507 The affected functions are: |
|
5508 |
|
5509 3.1 the constructor: RArray(TInt, T*, TInt) |
|
5510 |
|
5511 3.2 Append(const T&) |
|
5512 |
|
5513 3.3 Insert(const T&, TInt) |
|
5514 |
|
5515 3.4 the [] operator, and then using the pointer to iterate through |
|
5516 the array as you would with a C array. |
|
5517 */ |
|
5518 template <class T> |
|
5519 class RArray : private RArrayBase |
|
5520 { |
|
5521 public: |
|
5522 inline RArray(); |
|
5523 inline explicit RArray(TInt aGranularity); |
|
5524 inline RArray(TInt aGranularity, TInt aKeyOffset); |
|
5525 inline RArray(TInt aMinGrowBy, TInt aKeyOffset, TInt aFactor); |
|
5526 inline RArray(TInt aEntrySize,T* aEntries, TInt aCount); |
|
5527 inline void Close(); |
|
5528 inline TInt Count() const; |
|
5529 inline const T& operator[](TInt anIndex) const; |
|
5530 inline T& operator[](TInt anIndex); |
|
5531 inline TInt Append(const T& anEntry); |
|
5532 inline TInt Insert(const T& anEntry, TInt aPos); |
|
5533 inline void Remove(TInt anIndex); |
|
5534 inline void Compress(); |
|
5535 inline void Reset(); |
|
5536 inline TInt Find(const T& anEntry) const; |
|
5537 inline TInt Find(const T& anEntry, TIdentityRelation<T> anIdentity) const; |
|
5538 template <class K> |
|
5539 inline TInt Find(const K& aKey, TBool (*apfnCompare)(const K* k, const T& t)) const |
|
5540 /** |
|
5541 Finds the first object in the array which matches aKey using |
|
5542 the comparison algorithm provided by apfnCompare. |
|
5543 |
|
5544 The find operation always starts at the low index end of the array. There |
|
5545 is no assumption about the order of objects in the array. |
|
5546 |
|
5547 @param aKey The key of type K to be compared with the elements of the array using apfnCompare. |
|
5548 @param apfnCompare A function defining the identity relation between the |
|
5549 object in the array, and their keys of type K. The function |
|
5550 returns true if k and t match based on this relationship. |
|
5551 |
|
5552 @return The index of the first matching object within the array. |
|
5553 KErrNotFound, if no suitable object can be found. |
|
5554 */ |
|
5555 { return RArrayBase::Find((T*)&aKey,*(TIdentityRelation<T>*)&apfnCompare); } |
|
5556 inline TInt FindReverse(const T& anEntry) const; |
|
5557 inline TInt FindReverse(const T& anEntry, TIdentityRelation<T> anIdentity) const; |
|
5558 template <class K> |
|
5559 inline TInt FindReverse(const K& aKey, TInt (*apfnMatch)(const K* k, const T& t)) const |
|
5560 /** |
|
5561 Finds the first object in the array which matches aKey using the comparison |
|
5562 algorithm provided by apfnCompare. |
|
5563 |
|
5564 The find operation always starts at the high index end of the array. There |
|
5565 is no assumption about the order of objects in the array. |
|
5566 |
|
5567 @param aKey The key of type K to be compared with the elements of the array using apfnMatch. |
|
5568 @param apfnMatch A function defining the identity relation between the |
|
5569 object in the array, and their keys of type K. The function |
|
5570 returns true if k and t match based on this relationship. |
|
5571 |
|
5572 @return The index of the first matching object within the array. |
|
5573 KErrNotFound, if no suitable object can be found. |
|
5574 */ |
|
5575 { return RArrayBase::FindReverse((T*)&aKey,*(TIdentityRelation<T>*)&apfnMatch); } |
|
5576 inline TInt FindInSignedKeyOrder(const T& anEntry) const; |
|
5577 inline TInt FindInUnsignedKeyOrder(const T& anEntry) const; |
|
5578 inline TInt FindInOrder(const T& anEntry, TLinearOrder<T> anOrder) const; |
|
5579 inline TInt FindInSignedKeyOrder(const T& anEntry, TInt& anIndex) const; |
|
5580 inline TInt FindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex) const; |
|
5581 inline TInt FindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const; |
|
5582 template <class K> |
|
5583 inline TInt FindInOrder(const K& aKey, TInt (*apfnCompare)(const K* k, const T& t)) const |
|
5584 /** |
|
5585 Finds the object in the array whose object matches the specified |
|
5586 key, (Using the relationship defined within apfnCompare) using a binary search |
|
5587 technique and an ordering algorithm. |
|
5588 |
|
5589 The function assumes that existing objects in the array are ordered so |
|
5590 that the objects themselves are in object order as determined by an algorithm |
|
5591 supplied by the caller and packaged as a TLinearOrder<T>. |
|
5592 |
|
5593 @param aKey The key of type K to be compared with the elements of the array using apfnCompare. |
|
5594 @param apfnCompare A function which defines the order that the array was sorted, |
|
5595 where in it aKey (via the defined relationship) should fit, and if the key is present. |
|
5596 |
|
5597 @return The index of the matching object within the array. |
|
5598 KErrNotFound, if no suitable object can be found. |
|
5599 */ |
|
5600 |
|
5601 { return RArrayBase::FindIsq((T*)&aKey,*(TLinearOrder<T>*)&apfnCompare); } |
|
5602 inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt aMode) const; |
|
5603 inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt aMode) const; |
|
5604 inline TInt SpecificFindInOrder(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const; |
|
5605 inline TInt SpecificFindInSignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const; |
|
5606 inline TInt SpecificFindInUnsignedKeyOrder(const T& anEntry, TInt& anIndex, TInt aMode) const; |
|
5607 inline TInt SpecificFindInOrder(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const; |
|
5608 inline TInt InsertInSignedKeyOrder(const T& anEntry); |
|
5609 inline TInt InsertInUnsignedKeyOrder(const T& anEntry); |
|
5610 inline TInt InsertInOrder(const T& anEntry, TLinearOrder<T> anOrder); |
|
5611 inline TInt InsertInSignedKeyOrderAllowRepeats(const T& anEntry); |
|
5612 inline TInt InsertInUnsignedKeyOrderAllowRepeats(const T& anEntry); |
|
5613 inline TInt InsertInOrderAllowRepeats(const T& anEntry, TLinearOrder<T> anOrder); |
|
5614 #ifndef __KERNEL_MODE__ |
|
5615 inline void AppendL(const T& anEntry); |
|
5616 inline void InsertL(const T& anEntry, TInt aPos); |
|
5617 inline TInt FindL(const T& anEntry) const; |
|
5618 inline TInt FindL(const T& anEntry, TIdentityRelation<T> anIdentity) const; |
|
5619 inline TInt FindReverseL(const T& anEntry) const; |
|
5620 inline TInt FindReverseL(const T& anEntry, TIdentityRelation<T> anIdentity) const; |
|
5621 inline TInt FindInSignedKeyOrderL(const T& anEntry) const; |
|
5622 inline TInt FindInUnsignedKeyOrderL(const T& anEntry) const; |
|
5623 inline TInt FindInOrderL(const T& anEntry, TLinearOrder<T> anOrder) const; |
|
5624 inline void FindInSignedKeyOrderL(const T& anEntry, TInt& anIndex) const; |
|
5625 inline void FindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex) const; |
|
5626 inline void FindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder) const; |
|
5627 inline TInt SpecificFindInSignedKeyOrderL(const T& anEntry, TInt aMode) const; |
|
5628 inline TInt SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt aMode) const; |
|
5629 inline TInt SpecificFindInOrderL(const T& anEntry, TLinearOrder<T> anOrder, TInt aMode) const; |
|
5630 inline void SpecificFindInSignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const; |
|
5631 inline void SpecificFindInUnsignedKeyOrderL(const T& anEntry, TInt& anIndex, TInt aMode) const; |
|
5632 inline void SpecificFindInOrderL(const T& anEntry, TInt& anIndex, TLinearOrder<T> anOrder, TInt aMode) const; |
|
5633 inline void InsertInSignedKeyOrderL(const T& anEntry); |
|
5634 inline void InsertInUnsignedKeyOrderL(const T& anEntry); |
|
5635 inline void InsertInOrderL(const T& anEntry, TLinearOrder<T> anOrder); |
|
5636 inline void InsertInSignedKeyOrderAllowRepeatsL(const T& anEntry); |
|
5637 inline void InsertInUnsignedKeyOrderAllowRepeatsL(const T& anEntry); |
|
5638 inline void InsertInOrderAllowRepeatsL(const T& anEntry, TLinearOrder<T> anOrder); |
|
5639 |
|
5640 inline void GranularCompress(); |
|
5641 inline TInt Reserve(TInt aCount); |
|
5642 inline void ReserveL(TInt aCount); |
|
5643 inline void SortSigned(); |
|
5644 inline void SortUnsigned(); |
|
5645 inline void Sort(TLinearOrder<T> anOrder); |
|
5646 inline TArray<T> Array() const; |
|
5647 #endif |
|
5648 }; |
|
5649 |
|
5650 |
|
5651 |
|
5652 |
|
5653 /** |
|
5654 @publishedAll |
|
5655 @released |
|
5656 |
|
5657 A simple and efficient specialized array of signed integers offering standard |
|
5658 array behaviour. |
|
5659 |
|
5660 Note that derivation from RPointerArrayBase is private. |
|
5661 */ |
|
5662 TEMPLATE_SPECIALIZATION class RArray<TInt> : private RPointerArrayBase |
|
5663 { |
|
5664 public: |
|
5665 inline RArray(); |
|
5666 inline explicit RArray(TInt aGranularity); |
|
5667 inline RArray(TInt aMinGrowBy, TInt aFactor); |
|
5668 inline void Close(); |
|
5669 inline TInt Count() const; |
|
5670 inline const TInt& operator[](TInt anIndex) const; |
|
5671 inline TInt& operator[](TInt anIndex); |
|
5672 inline TInt Append(TInt anEntry); |
|
5673 inline TInt Insert(TInt anEntry, TInt aPos); |
|
5674 inline void Remove(TInt anIndex); |
|
5675 inline void Compress(); |
|
5676 inline void Reset(); |
|
5677 inline TInt Find(TInt anEntry) const; |
|
5678 inline TInt FindReverse(TInt anEntry) const; |
|
5679 inline TInt FindInOrder(TInt anEntry) const; |
|
5680 inline TInt FindInOrder(TInt anEntry, TInt& anIndex) const; |
|
5681 inline TInt SpecificFindInOrder(TInt anEntry, TInt aMode) const; |
|
5682 inline TInt SpecificFindInOrder(TInt anEntry, TInt& anIndex, TInt aMode) const; |
|
5683 inline TInt InsertInOrder(TInt anEntry); |
|
5684 inline TInt InsertInOrderAllowRepeats(TInt anEntry); |
|
5685 #ifndef __KERNEL_MODE__ |
|
5686 inline void AppendL(TInt anEntry); |
|
5687 inline void InsertL(TInt anEntry, TInt aPos); |
|
5688 inline TInt FindL(TInt anEntry) const; |
|
5689 inline TInt FindReverseL(TInt anEntry) const; |
|
5690 inline TInt FindInOrderL(TInt anEntry) const; |
|
5691 inline void FindInOrderL(TInt anEntry, TInt& anIndex) const; |
|
5692 inline TInt SpecificFindInOrderL(TInt anEntry, TInt aMode) const; |
|
5693 inline void SpecificFindInOrderL(TInt anEntry, TInt& anIndex, TInt aMode) const; |
|
5694 inline void InsertInOrderL(TInt anEntry); |
|
5695 inline void InsertInOrderAllowRepeatsL(TInt anEntry); |
|
5696 |
|
5697 inline RArray(TInt* aEntries, TInt aCount); |
|
5698 inline void GranularCompress(); |
|
5699 inline TInt Reserve(TInt aCount); |
|
5700 inline void ReserveL(TInt aCount); |
|
5701 inline void Sort(); |
|
5702 inline TArray<TInt> Array() const; |
|
5703 #endif |
|
5704 }; |
|
5705 |
|
5706 |
|
5707 |
|
5708 |
|
5709 /** |
|
5710 @publishedAll |
|
5711 @released |
|
5712 |
|
5713 Array of unsigned integers. |
|
5714 |
|
5715 The array is a simple and efficient specialized array of unsigned integers |
|
5716 offering standard array behaviour. |
|
5717 |
|
5718 The derivation from RPointerArrayBase is private. |
|
5719 */ |
|
5720 TEMPLATE_SPECIALIZATION class RArray<TUint> : private RPointerArrayBase |
|
5721 { |
|
5722 public: |
|
5723 inline RArray(); |
|
5724 inline explicit RArray(TInt aGranularity); |
|
5725 inline RArray(TInt aMinGrowBy, TInt aFactor); |
|
5726 inline void Close(); |
|
5727 inline TInt Count() const; |
|
5728 inline const TUint& operator[](TInt anIndex) const; |
|
5729 inline TUint& operator[](TInt anIndex); |
|
5730 inline TInt Append(TUint anEntry); |
|
5731 inline TInt Insert(TUint anEntry, TInt aPos); |
|
5732 inline void Remove(TInt anIndex); |
|
5733 inline void Compress(); |
|
5734 inline void Reset(); |
|
5735 inline TInt Find(TUint anEntry) const; |
|
5736 inline TInt FindReverse(TUint anEntry) const; |
|
5737 inline TInt FindInOrder(TUint anEntry) const; |
|
5738 inline TInt FindInOrder(TUint anEntry, TInt& anIndex) const; |
|
5739 inline TInt SpecificFindInOrder(TUint anEntry, TInt aMode) const; |
|
5740 inline TInt SpecificFindInOrder(TUint anEntry, TInt& anIndex, TInt aMode) const; |
|
5741 inline TInt InsertInOrder(TUint anEntry); |
|
5742 inline TInt InsertInOrderAllowRepeats(TUint anEntry); |
|
5743 #ifndef __KERNEL_MODE__ |
|
5744 inline void AppendL(TUint anEntry); |
|
5745 inline void InsertL(TUint anEntry, TInt aPos); |
|
5746 inline TInt FindL(TUint anEntry) const; |
|
5747 inline TInt FindReverseL(TUint anEntry) const; |
|
5748 inline TInt FindInOrderL(TUint anEntry) const; |
|
5749 inline void FindInOrderL(TUint anEntry, TInt& anIndex) const; |
|
5750 inline TInt SpecificFindInOrderL(TUint anEntry, TInt aMode) const; |
|
5751 inline void SpecificFindInOrderL(TUint anEntry, TInt& anIndex, TInt aMode) const; |
|
5752 inline void InsertInOrderL(TUint anEntry); |
|
5753 inline void InsertInOrderAllowRepeatsL(TUint anEntry); |
|
5754 |
|
5755 inline RArray(TUint* aEntries, TInt aCount); |
|
5756 inline void GranularCompress(); |
|
5757 inline TInt Reserve(TInt aCount); |
|
5758 inline void ReserveL(TInt aCount); |
|
5759 inline void Sort(); |
|
5760 inline TArray<TUint> Array() const; |
|
5761 #endif |
|
5762 }; |
|
5763 |
|
5764 #ifndef __LEAVE_EQUALS_THROW__ |
|
5765 |
|
5766 class TTrapHandler; |
|
5767 |
|
5768 /** |
|
5769 @internalComponent |
|
5770 */ |
|
5771 class TTrap |
|
5772 { |
|
5773 public: |
|
5774 #ifndef __KERNEL_MODE__ |
|
5775 IMPORT_C TInt Trap(TInt& aResult); |
|
5776 IMPORT_C static void UnTrap(); |
|
5777 #endif |
|
5778 public: |
|
5779 enum {EMaxState=0x10}; |
|
5780 public: |
|
5781 TInt iState[EMaxState]; |
|
5782 TTrap* iNext; |
|
5783 TInt* iResult; |
|
5784 TTrapHandler* iHandler; |
|
5785 }; |
|
5786 |
|
5787 |
|
5788 |
|
5789 /** |
|
5790 @publishedAll |
|
5791 @released |
|
5792 |
|
5793 Executes the set of C++ statements _s under a trap harness. |
|
5794 |
|
5795 Use this macro as a C++ statement. |
|
5796 |
|
5797 _r must be a TInt which has already been declared; if any of the |
|
5798 C++ statements _s leaves, then the leave code is returned in _r, |
|
5799 otherwise _r is set to KErrNone. |
|
5800 |
|
5801 _s can consist of multiple C++ statements; in theory, _s can consist |
|
5802 of any legal C++ code but in practice, such statements consist of simple |
|
5803 function calls, e.g. Foo() or an assignment of some value to the result of |
|
5804 a function call, e.g. functionValue=GetFoo(). |
|
5805 |
|
5806 A cleanup stack is constructed for the set of C++ statements _s. |
|
5807 If any function in _s leaves, objects pushed to the cleanup stack are |
|
5808 cleaned-up. In addition, if any of the C++ statements in _s leaves, |
|
5809 then remaining C++ code in _s is not executed and any variables which |
|
5810 are assigned within that remaining code are not defined. |
|
5811 |
|
5812 @param _r An lvalue, convertible to TInt&, which will receive the result of |
|
5813 any User::Leave() executed within _s or, if no leave occurred, |
|
5814 it will be set to KErrNone. The value of _r on entry is not used. |
|
5815 |
|
5816 @param _s C++ statements which will be executed under a trap harness. |
|
5817 |
|
5818 @see TRAPD |
|
5819 */ |
|
5820 #define TRAP(_r,_s) {TTrap __t;if (__t.Trap(_r)==0){_s;TTrap::UnTrap();}} |
|
5821 |
|
5822 /** |
|
5823 @publishedAll |
|
5824 @released |
|
5825 |
|
5826 Executes the set of C++ statements _s under a trap harness. |
|
5827 |
|
5828 Use this macro in the same way as you would TRAP, except that the |
|
5829 variable _r is defined as part of the macro (and is therefore valid for the |
|
5830 rest of the block in which the macro occurs). Often, this saves a line of code. |
|
5831 |
|
5832 @param _r A name, which will be declared as a TInt, and will receive the result |
|
5833 of any User::Leave() executed within _s or, if no leave occurred, it |
|
5834 will be set to KErrNone. After the macro, _r remains in scope until |
|
5835 the end of its enclosing block. |
|
5836 |
|
5837 @param _s C++ statements which will be executed under a trap harness. |
|
5838 |
|
5839 @see TRAP |
|
5840 */ |
|
5841 #define TRAPD(_r,_s) TInt _r;{TTrap __t;if (__t.Trap(_r)==0){_s;TTrap::UnTrap();}} |
|
5842 |
|
5843 /** |
|
5844 @publishedAll |
|
5845 @released |
|
5846 |
|
5847 Executes the set of C++ statements _s under a trap harness. |
|
5848 Any leave code generated is ignored. |
|
5849 |
|
5850 Use this macro as a C++ statement. |
|
5851 |
|
5852 This macro is functionally equivalent to: |
|
5853 @code |
|
5854 TInt x; |
|
5855 TRAP(x,_s) |
|
5856 @endcode |
|
5857 or |
|
5858 @code |
|
5859 TRAPD(x,_s) |
|
5860 @endcode |
|
5861 where the value in 'x' is not used by any subsequent code. |
|
5862 |
|
5863 _s can consist of multiple C++ statements; in theory, _s can consist |
|
5864 of any legal C++ code but in practice, such statements consist of simple |
|
5865 function calls, e.g. Foo() or an assignment of some value to the result of |
|
5866 a function call, e.g. functionValue=GetFoo(). |
|
5867 |
|
5868 A cleanup stack is constructed for the set of C++ statements _s. |
|
5869 If any function in _s leaves, objects pushed to the cleanup stack are |
|
5870 cleaned-up. In addition, if any of the C++ statements in _s leaves, |
|
5871 then remaining C++ code in _s is not executed and any variables which |
|
5872 are assigned within that remaining code are not defined. |
|
5873 |
|
5874 @param _s C++ statements which will be executed under a trap harness. |
|
5875 |
|
5876 @see TRAPD |
|
5877 @see TRAP |
|
5878 */ |
|
5879 #define TRAP_IGNORE(_s) {TInt _ignore;TTrap __t;if (__t.Trap(_ignore)==0){_s;TTrap::UnTrap();}} |
|
5880 |
|
5881 |
|
5882 #else //__LEAVE_EQUALS_THROW__ |
|
5883 |
|
5884 #ifdef __WINS__ |
|
5885 /** @internalComponent */ |
|
5886 #define __WIN32SEHTRAP TWin32SEHTrap __trap; __trap.Trap(); |
|
5887 /** @internalComponent */ |
|
5888 #define __WIN32SEHUNTRAP __trap.UnTrap(); |
|
5889 IMPORT_C void EmptyFunction(); |
|
5890 #define __CALL_EMPTY_FUNCTION EmptyFunction(); |
|
5891 #else // !__WINS__ |
|
5892 #define __WIN32SEHTRAP |
|
5893 #define __WIN32SEHUNTRAP |
|
5894 #define __CALL_EMPTY_FUNCTION |
|
5895 #endif //__WINS__ |
|
5896 |
|
5897 /** |
|
5898 This macro is used by the TRAP and TRAPD macros and provides a means |
|
5899 of inserting code into uses of these. |
|
5900 |
|
5901 This macro is invoked before any 'trapped' code is called, and it should be |
|
5902 redefined to do whatever task is required. E.g. this code: |
|
5903 |
|
5904 @code |
|
5905 #undef TRAP_INSTRUMENTATION_START |
|
5906 #define TRAP_INSTRUMENTATION_START DoMyLoging(__LINE__) |
|
5907 @endcode |
|
5908 |
|
5909 Will cause all subsequent uses of the TRAP macros to behave in an |
|
5910 equivalent way to: |
|
5911 |
|
5912 @code |
|
5913 DoMyLoging(__LINE__) |
|
5914 TRAP(r,SomeCodeL()); |
|
5915 @endcode |
|
5916 |
|
5917 |
|
5918 @publishedPartner |
|
5919 @released |
|
5920 |
|
5921 @see TRAP |
|
5922 @see TRAPD |
|
5923 */ |
|
5924 #define TRAP_INSTRUMENTATION_START |
|
5925 |
|
5926 |
|
5927 |
|
5928 /** |
|
5929 This macro is used by the TRAP and TRAPD macros and provides a means |
|
5930 of inserting code into uses of these. |
|
5931 |
|
5932 This macro is invoked if the 'trapped' code did not Leave. |
|
5933 E.g. this code: |
|
5934 |
|
5935 @code |
|
5936 #undef TRAP_INSTRUMENTATION_NOLEAVE |
|
5937 #define TRAP_INSTRUMENTATION_NOLEAVE DoMyLoging(__LINE__) |
|
5938 @endcode |
|
5939 |
|
5940 Will cause all subsequent uses of the TRAP macros to behave in an |
|
5941 equivalent way to: |
|
5942 |
|
5943 @code |
|
5944 TRAP(r,SomeCodeL()); |
|
5945 if(r==KErrNone) DoMyLoging(__LINE__); |
|
5946 @endcode |
|
5947 |
|
5948 |
|
5949 @param aLine The line number in the C++ source file where the TRAP or TRAPD |
|
5950 macro was used. |
|
5951 |
|
5952 @publishedPartner |
|
5953 @released |
|
5954 |
|
5955 @see TRAP |
|
5956 @see TRAPD |
|
5957 */ |
|
5958 #define TRAP_INSTRUMENTATION_NOLEAVE |
|
5959 |
|
5960 |
|
5961 /** |
|
5962 This macro is used by the TRAP and TRAPD macros and provides a means |
|
5963 of inserting code into uses of these. |
|
5964 |
|
5965 This macro is invoked if the 'trapped' code did Leave. E.g. this code: |
|
5966 |
|
5967 @code |
|
5968 #undef TRAP_INSTRUMENTATION_LEAVE |
|
5969 #define TRAP_INSTRUMENTATION_LEAVE(aResult) DoMyLoging(aResult,__LINE__) |
|
5970 @endcode |
|
5971 |
|
5972 Will cause all subsequent uses of the TRAP macros to behave in an |
|
5973 equivalent way to: |
|
5974 |
|
5975 @code |
|
5976 TRAP(r,SomeCodeL()); |
|
5977 if(r!=KErrNone) DoMyLoging(r,__LINE__); |
|
5978 @endcode |
|
5979 |
|
5980 |
|
5981 @param aResult A reference to the result value used in the TRAP macro. |
|
5982 |
|
5983 |
|
5984 @publishedPartner |
|
5985 @released |
|
5986 |
|
5987 @see TRAP |
|
5988 @see TRAPD |
|
5989 */ |
|
5990 #define TRAP_INSTRUMENTATION_LEAVE(aResult) |
|
5991 |
|
5992 |
|
5993 |
|
5994 /** |
|
5995 This macro is used by the TRAP and TRAPD macros and provides a means |
|
5996 of inserting code into uses of these. |
|
5997 |
|
5998 This macro is invoked after the 'trapped' code is called, regardless of whether |
|
5999 or not it did Leave. It should be redefined to do whatever task is |
|
6000 required. E.g. this code: |
|
6001 |
|
6002 @code |
|
6003 #undef TRAP_INSTRUMENTATION_END |
|
6004 #define TRAP_INSTRUMENTATION_END DoMyLoging(__LINE__) |
|
6005 @endcode |
|
6006 |
|
6007 Will cause all subsequent uses of the TRAP macros to behave in an |
|
6008 equivalent way to: |
|
6009 |
|
6010 @code |
|
6011 TRAP(r,SomeCodeL()); |
|
6012 DoMyLoging(__LINE__) |
|
6013 @endcode |
|
6014 |
|
6015 |
|
6016 @publishedPartner |
|
6017 @released |
|
6018 |
|
6019 @see TRAP |
|
6020 @see TRAPD |
|
6021 */ |
|
6022 #define TRAP_INSTRUMENTATION_END |
|
6023 |
|
6024 |
|
6025 |
|
6026 /** |
|
6027 @publishedAll |
|
6028 @released |
|
6029 |
|
6030 Executes the set of C++ statements _s under a trap harness. |
|
6031 |
|
6032 Use this macro as a C++ statement. |
|
6033 |
|
6034 _r must be a TInt which has already been declared; if any of the |
|
6035 C++ statements _s leaves, then the leave code is returned in _r, |
|
6036 otherwise _r is set to KErrNone. |
|
6037 |
|
6038 _s can consist of multiple C++ statements; in theory, _s can consist |
|
6039 of any legal C++ code but in practice, such statements consist of simple |
|
6040 function calls, e.g. Foo() or an assignment of some value to the result of |
|
6041 a function call, e.g. functionValue=GetFoo(). |
|
6042 |
|
6043 A cleanup stack is constructed for the set of C++ statements _s. |
|
6044 If any function in _s leaves, objects pushed to the cleanup stack are |
|
6045 cleaned-up. In addition, if any of the C++ statements in _s leaves, |
|
6046 then remaining C++ code in _s is not executed and any variables which |
|
6047 are assigned within that remaining code are not defined. |
|
6048 |
|
6049 @param _r An lvalue, convertible to TInt&, which will receive the result of |
|
6050 any User::Leave() executed within _s or, if no leave occurred, |
|
6051 it will be set to KErrNone. The value of _r on entry is not used. |
|
6052 |
|
6053 @param _s C++ statements which will be executed under a trap harness. |
|
6054 |
|
6055 @see TRAPD |
|
6056 */ |
|
6057 |
|
6058 /*__CALL_EMPTY_FUNCTION(call to a function with an empty body) was added as a |
|
6059 workaround to a compiler bug (mwccsym2 - winscw ) which caused an incorrect |
|
6060 trap handler to be invoked when multiple nested TRAP's were present and |
|
6061 User::Leave(..) was called. */ |
|
6062 |
|
6063 #define TRAP(_r, _s) \ |
|
6064 { \ |
|
6065 TInt& __rref = _r; \ |
|
6066 __rref = 0; \ |
|
6067 { TRAP_INSTRUMENTATION_START; } \ |
|
6068 try { \ |
|
6069 __WIN32SEHTRAP \ |
|
6070 TTrapHandler* ____t = User::MarkCleanupStack(); \ |
|
6071 _s; \ |
|
6072 User::UnMarkCleanupStack(____t); \ |
|
6073 { TRAP_INSTRUMENTATION_NOLEAVE; } \ |
|
6074 __WIN32SEHUNTRAP \ |
|
6075 } \ |
|
6076 catch (XLeaveException& l) \ |
|
6077 { \ |
|
6078 __rref = l.GetReason(); \ |
|
6079 { TRAP_INSTRUMENTATION_LEAVE(__rref); } \ |
|
6080 } \ |
|
6081 catch (...) \ |
|
6082 { \ |
|
6083 User::Invariant(); \ |
|
6084 } \ |
|
6085 __CALL_EMPTY_FUNCTION \ |
|
6086 { TRAP_INSTRUMENTATION_END; } \ |
|
6087 } |
|
6088 |
|
6089 |
|
6090 /** |
|
6091 @publishedAll |
|
6092 @released |
|
6093 |
|
6094 Executes the set of C++ statements _s under a trap harness. |
|
6095 |
|
6096 Use this macro in the same way as you would TRAP, except that the |
|
6097 variable _r is defined as part of the macro (and is therefore valid for the |
|
6098 rest of the block in which the macro occurs). Often, this saves a line of code. |
|
6099 |
|
6100 @param _r A name, which will be declared as a TInt, and will receive the result |
|
6101 of any User::Leave() executed within _s or, if no leave occurred, it |
|
6102 will be set to KErrNone. After the macro, _r remains in scope until |
|
6103 the end of its enclosing block. |
|
6104 |
|
6105 @param _s C++ statements which will be executed under a trap harness. |
|
6106 |
|
6107 @see TRAP |
|
6108 */ |
|
6109 |
|
6110 /*__CALL_EMPTY_FUNCTION(call to a function with an empty body) was added as a |
|
6111 workaround to a compiler bug (mwccsym2 - winscw ) which caused an incorrect |
|
6112 trap handler to be invoked when multiple nested TRAP's were present and |
|
6113 User::Leave(..) was called. */ |
|
6114 |
|
6115 |
|
6116 #define TRAPD(_r, _s) \ |
|
6117 TInt _r; \ |
|
6118 { \ |
|
6119 _r = 0; \ |
|
6120 { TRAP_INSTRUMENTATION_START; } \ |
|
6121 try { \ |
|
6122 __WIN32SEHTRAP \ |
|
6123 TTrapHandler* ____t = User::MarkCleanupStack(); \ |
|
6124 _s; \ |
|
6125 User::UnMarkCleanupStack(____t); \ |
|
6126 { TRAP_INSTRUMENTATION_NOLEAVE; } \ |
|
6127 __WIN32SEHUNTRAP \ |
|
6128 } \ |
|
6129 catch (XLeaveException& l) \ |
|
6130 { \ |
|
6131 _r = l.GetReason(); \ |
|
6132 { TRAP_INSTRUMENTATION_LEAVE(_r); } \ |
|
6133 } \ |
|
6134 catch (...) \ |
|
6135 { \ |
|
6136 User::Invariant(); \ |
|
6137 } \ |
|
6138 __CALL_EMPTY_FUNCTION \ |
|
6139 { TRAP_INSTRUMENTATION_END; } \ |
|
6140 } |
|
6141 |
|
6142 /** |
|
6143 @publishedAll |
|
6144 @released |
|
6145 |
|
6146 Executes the set of C++ statements _s under a trap harness. |
|
6147 Any leave code generated is ignored. |
|
6148 |
|
6149 Use this macro as a C++ statement. |
|
6150 |
|
6151 This macro is functionally equivalent to: |
|
6152 @code |
|
6153 TInt x; |
|
6154 TRAP(x,_s) |
|
6155 @endcode |
|
6156 or |
|
6157 @code |
|
6158 TRAPD(x,_s) |
|
6159 @endcode |
|
6160 where the value in 'x' is not used by any subsequent code. |
|
6161 |
|
6162 Use this macro as a C++ statement. |
|
6163 |
|
6164 _s can consist of multiple C++ statements; in theory, _s can consist |
|
6165 of any legal C++ code but in practice, such statements consist of simple |
|
6166 function calls, e.g. Foo() or an assignment of some value to the result of |
|
6167 a function call, e.g. functionValue=GetFoo(). |
|
6168 |
|
6169 A cleanup stack is constructed for the set of C++ statements _s. |
|
6170 If any function in _s leaves, objects pushed to the cleanup stack are |
|
6171 cleaned-up. In addition, if any of the C++ statements in _s leaves, |
|
6172 then remaining C++ code in _s is not executed and any variables which |
|
6173 are assigned within that remaining code are not defined. |
|
6174 |
|
6175 @param _s C++ statements which will be executed under a trap harness. |
|
6176 |
|
6177 @see TRAPD |
|
6178 @see TRAP |
|
6179 */ |
|
6180 |
|
6181 /*__CALL_EMPTY_FUNCTION(call to a function with an empty body) was added as a |
|
6182 workaround to a compiler bug (mwccsym2 - winscw ) which caused an incorrect |
|
6183 trap handler to be invoked when multiple nested TRAP's were present and |
|
6184 User::Leave(..) was called. */ |
|
6185 |
|
6186 #define TRAP_IGNORE(_s) \ |
|
6187 { \ |
|
6188 { TRAP_INSTRUMENTATION_START; } \ |
|
6189 try { \ |
|
6190 __WIN32SEHTRAP \ |
|
6191 TTrapHandler* ____t = User::MarkCleanupStack(); \ |
|
6192 _s; \ |
|
6193 User::UnMarkCleanupStack(____t); \ |
|
6194 { TRAP_INSTRUMENTATION_NOLEAVE; } \ |
|
6195 __WIN32SEHUNTRAP \ |
|
6196 } \ |
|
6197 catch (XLeaveException& l) \ |
|
6198 { \ |
|
6199 l.GetReason(); \ |
|
6200 { TRAP_INSTRUMENTATION_LEAVE(l.Reason()); } \ |
|
6201 } \ |
|
6202 catch (...) \ |
|
6203 { \ |
|
6204 User::Invariant(); \ |
|
6205 } \ |
|
6206 __CALL_EMPTY_FUNCTION \ |
|
6207 { TRAP_INSTRUMENTATION_END; } \ |
|
6208 } |
|
6209 |
|
6210 |
|
6211 #endif //__LEAVE_EQUALS_THROW__ |
|
6212 |
|
6213 /* The macro __SYMBIAN_STDCPP_SUPPORT__ is defined when building a StdC++ target. |
|
6214 * In this case, operator new and operator delete below should not be declared |
|
6215 * to avoid clashing with StdC++ declarations. |
|
6216 */ |
|
6217 |
|
6218 #ifndef __SYMBIAN_STDCPP_SUPPORT__ |
|
6219 |
|
6220 #ifndef __OPERATOR_NEW_DECLARED__ |
|
6221 |
|
6222 /* Some operator new and operator delete overloads may be declared in compiler |
|
6223 * pre-include files. |
|
6224 * |
|
6225 * __OPERATOR_NEW_DECLARED__ is #defined if they are, so that we can avoid |
|
6226 * re-declaring them here. |
|
6227 */ |
|
6228 |
|
6229 #define __OPERATOR_NEW_DECLARED__ |
|
6230 |
|
6231 /** |
|
6232 @publishedAll |
|
6233 @released |
|
6234 */ |
|
6235 GLREF_C TAny* operator new(TUint aSize) __NO_THROW; |
|
6236 |
|
6237 /** |
|
6238 @publishedAll |
|
6239 @released |
|
6240 */ |
|
6241 GLREF_C TAny* operator new(TUint aSize,TUint anExtraSize) __NO_THROW; |
|
6242 |
|
6243 /** |
|
6244 @publishedAll |
|
6245 @released |
|
6246 */ |
|
6247 GLREF_C void operator delete(TAny* aPtr) __NO_THROW; |
|
6248 |
|
6249 #ifndef __OMIT_VEC_OPERATOR_NEW_DECL__ |
|
6250 /** |
|
6251 @publishedAll |
|
6252 @released |
|
6253 */ |
|
6254 GLREF_C TAny* operator new[](TUint aSize) __NO_THROW; |
|
6255 |
|
6256 /** |
|
6257 @publishedAll |
|
6258 @released |
|
6259 */ |
|
6260 GLREF_C void operator delete[](TAny* aPtr) __NO_THROW; |
|
6261 #endif // !__OMIT_VEC_OPERATOR_NEW_DECL__ |
|
6262 |
|
6263 #endif // !__OPERATOR_NEW_DECLARED__ |
|
6264 |
|
6265 #endif // !__SYMBIAN_STDCPP_SUPPORT__ |
|
6266 |
|
6267 /** |
|
6268 @publishedAll |
|
6269 @released |
|
6270 */ |
|
6271 inline TAny* operator new(TUint aSize, TAny* aBase) __NO_THROW; |
|
6272 |
|
6273 /** |
|
6274 @publishedAll |
|
6275 @released |
|
6276 */ |
|
6277 inline void operator delete(TAny* aPtr, TAny* aBase) __NO_THROW; |
|
6278 |
|
6279 #ifndef __PLACEMENT_VEC_NEW_INLINE |
|
6280 /** |
|
6281 @publishedAll |
|
6282 @released |
|
6283 */ |
|
6284 inline TAny* operator new[](TUint aSize, TAny* aBase) __NO_THROW; |
|
6285 |
|
6286 /** |
|
6287 @publishedAll |
|
6288 @released |
|
6289 */ |
|
6290 inline void operator delete[](TAny* aPtr, TAny* aBase) __NO_THROW; |
|
6291 |
|
6292 #endif // !__PLACEMENT_VEC_NEW_INLINE |
|
6293 |
|
6294 #if !defined(__BOOL_NO_TRUE_TRAP__) |
|
6295 |
|
6296 /** |
|
6297 @publishedAll |
|
6298 @released |
|
6299 */ |
|
6300 TBool operator==(TTrue,volatile const TBool); |
|
6301 |
|
6302 /** |
|
6303 @publishedAll |
|
6304 @released |
|
6305 */ |
|
6306 TBool operator==(volatile const TBool,TTrue); |
|
6307 |
|
6308 /** |
|
6309 @publishedAll |
|
6310 @released |
|
6311 */ |
|
6312 TBool operator!=(TTrue,volatile const TBool); |
|
6313 |
|
6314 /** |
|
6315 @publishedAll |
|
6316 @released |
|
6317 */ |
|
6318 TBool operator!=(volatile const TBool,TTrue); |
|
6319 #endif |
|
6320 |
|
6321 |
|
6322 |
|
6323 |
|
6324 /** |
|
6325 @publishedAll |
|
6326 @released |
|
6327 |
|
6328 A Version 2 client/server class that clients use to package |
|
6329 the arguments to be sent to a server. |
|
6330 |
|
6331 The object can package up to 4 arguments together with information about each |
|
6332 argument's type, width and accessibility; it is also possible for |
|
6333 the package to contain zero arguments. In addition to the default constructor, |
|
6334 the class has four templated constructors, allowing an object of this type to |
|
6335 be constructed for 0, 1, 2, 3 or 4 arguments. |
|
6336 |
|
6337 Internally, the arguments are stored in a simple TInt array. |
|
6338 Consecutive arguments in a constructor's parameter list are put into |
|
6339 consecutive slots in the array. The Set() overloaded functions can be used |
|
6340 to set argument values into specific slots within this array. |
|
6341 */ |
|
6342 class TIpcArgs |
|
6343 { |
|
6344 public: |
|
6345 /** |
|
6346 @internalComponent |
|
6347 |
|
6348 Argument types; some of these may be ORed together to specify |
|
6349 type, accessibility, and width. |
|
6350 */ |
|
6351 enum TArgType |
|
6352 { |
|
6353 EUnspecified = 0, /**< Type not specified.*/ |
|
6354 EHandle = 1, /**< Handle type.*/ |
|
6355 EFlagDes = 4, /**< Descriptor type.*/ |
|
6356 EFlagConst = 2, /**< Read only type.*/ |
|
6357 EFlag16Bit = 1, /**< 16 bit rather than 8 bit.*/ |
|
6358 EDes8 = EFlagDes, /**< 8 bit read/write descriptor.*/ |
|
6359 EDes16 = EFlagDes|EFlag16Bit, /**< 16 bit read/write descriptor.*/ |
|
6360 EDesC8 = EFlagDes|EFlagConst, /**< 8 bit read only descriptor.*/ |
|
6361 EDesC16 = EFlagDes|EFlagConst|EFlag16Bit, /**< 16 bit read only descriptor.*/ |
|
6362 }; |
|
6363 |
|
6364 |
|
6365 /** |
|
6366 @internalComponent |
|
6367 */ |
|
6368 enum |
|
6369 { |
|
6370 KBitsPerType = 3, /**< Number of bits of type information used for each of the 4 arguments.*/ |
|
6371 KPinArgShift = KBitsPerType*KMaxMessageArguments, /**< Bit number of the start of the pin flags. */ |
|
6372 KPinArg0 = 1<<(KPinArgShift+0), /**< Set to pin argument at index 0.*/ |
|
6373 KPinArg1 = 1<<(KPinArgShift+1), /**< Set to pin argument at index 1.*/ |
|
6374 KPinArg2 = 1<<(KPinArgShift+2), /**< Set to pin argument at index 2.*/ |
|
6375 KPinArg3 = 1<<(KPinArgShift+3), /**< Set to pin argument at index 3.*/ |
|
6376 KPinMask = 0xf<<KPinArgShift, /**< The bits used for the pinning attributes of each argument.*/ |
|
6377 }; |
|
6378 |
|
6379 |
|
6380 /** |
|
6381 Indicates a Null argument. |
|
6382 */ |
|
6383 enum TNothing { |
|
6384 /** |
|
6385 An enum value that can be used to indicate an empty or |
|
6386 unused argument to a server. For example: |
|
6387 |
|
6388 @code |
|
6389 TIpcArgs args(arg1, TIpcArgs::ENothing, arg2); |
|
6390 @endcode |
|
6391 |
|
6392 This argument will have an undefined value when the server |
|
6393 receives the message. |
|
6394 */ |
|
6395 ENothing |
|
6396 }; |
|
6397 public: |
|
6398 /** |
|
6399 Default constructor. |
|
6400 |
|
6401 An argument package constructed using this constructor has no arguments; |
|
6402 however, arguments can subsequently be set into this argument package object |
|
6403 using the Set() member functions. |
|
6404 */ |
|
6405 inline TIpcArgs() |
|
6406 :iFlags(0) |
|
6407 {} |
|
6408 |
|
6409 |
|
6410 /** |
|
6411 A templated constructor that constructs the argument package; it takes |
|
6412 1 argument. |
|
6413 |
|
6414 @param a0 An argument of general class type T0 to be contained by |
|
6415 this object. |
|
6416 */ |
|
6417 template <class T0> |
|
6418 inline explicit TIpcArgs(T0 a0) |
|
6419 { |
|
6420 Assign(iArgs[0],a0); |
|
6421 iFlags=(Type(a0)<<(0*KBitsPerType)); |
|
6422 } |
|
6423 |
|
6424 |
|
6425 /** |
|
6426 A templated constructor that constructs the argument package; it takes |
|
6427 2 arguments. |
|
6428 |
|
6429 @param a0 An argument of general class type T0 to be contained by |
|
6430 this object. |
|
6431 @param a1 An argument of general class type T1 to be contained by |
|
6432 this object. |
|
6433 */ |
|
6434 template <class T0,class T1> |
|
6435 inline TIpcArgs(T0 a0,T1 a1) |
|
6436 { |
|
6437 Assign(iArgs[0],a0); |
|
6438 Assign(iArgs[1],a1); |
|
6439 iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType)); |
|
6440 } |
|
6441 |
|
6442 |
|
6443 /** |
|
6444 A templated constructor that constructs the argument package; it takes |
|
6445 3 arguments. |
|
6446 |
|
6447 @param a0 An argument of general class type T0 to be contained by |
|
6448 this object. |
|
6449 @param a1 An argument of general class type T1 to be contained by |
|
6450 this object. |
|
6451 @param a2 An argument of general class type T2 to be contained by |
|
6452 this object. |
|
6453 */ |
|
6454 template <class T0,class T1,class T2> |
|
6455 inline TIpcArgs(T0 a0,T1 a1,T2 a2) |
|
6456 { |
|
6457 Assign(iArgs[0],a0); |
|
6458 Assign(iArgs[1],a1); |
|
6459 Assign(iArgs[2],a2); |
|
6460 iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType)); |
|
6461 } |
|
6462 |
|
6463 |
|
6464 /** |
|
6465 A templated constructor that constructs the argument package; it takes |
|
6466 4 arguments. |
|
6467 |
|
6468 @param a0 An argument of general class type T0 to be contained by |
|
6469 this object. |
|
6470 @param a1 An argument of general class type T1 to be contained by |
|
6471 this object. |
|
6472 @param a2 An argument of general class type T2 to be contained by |
|
6473 this object. |
|
6474 @param a3 An argument of general class type T3 to be contained by |
|
6475 this object. |
|
6476 */ |
|
6477 template <class T0,class T1,class T2,class T3> |
|
6478 inline TIpcArgs(T0 a0,T1 a1,T2 a2,T3 a3) |
|
6479 { |
|
6480 Assign(iArgs[0],a0); |
|
6481 Assign(iArgs[1],a1); |
|
6482 Assign(iArgs[2],a2); |
|
6483 Assign(iArgs[3],a3); |
|
6484 iFlags=(Type(a0)<<(0*KBitsPerType))|(Type(a1)<<(1*KBitsPerType))|(Type(a2)<<(2*KBitsPerType))|(Type(a3)<<(3*KBitsPerType)); |
|
6485 } |
|
6486 // |
|
6487 inline void Set(TInt aIndex,TNothing); |
|
6488 inline void Set(TInt aIndex,TInt aValue); |
|
6489 inline void Set(TInt aIndex,const TAny* aValue); |
|
6490 inline void Set(TInt aIndex,RHandleBase aValue); |
|
6491 inline void Set(TInt aIndex,const TDesC8* aValue); |
|
6492 #ifndef __KERNEL_MODE__ |
|
6493 inline void Set(TInt aIndex,const TDesC16* aValue); |
|
6494 #endif |
|
6495 inline void Set(TInt aIndex,TDes8* aValue); |
|
6496 #ifndef __KERNEL_MODE__ |
|
6497 inline void Set(TInt aIndex,TDes16* aValue); |
|
6498 #endif |
|
6499 |
|
6500 inline TIpcArgs& PinArgs(TBool aPinArg0=ETrue, TBool aPinArg1=ETrue, TBool aPinArg2=ETrue, TBool aPinArg3=ETrue); |
|
6501 private: |
|
6502 inline static TArgType Type(TNothing); |
|
6503 inline static TArgType Type(TInt); |
|
6504 inline static TArgType Type(const TAny*); |
|
6505 inline static TArgType Type(RHandleBase aValue); |
|
6506 inline static TArgType Type(const TDesC8*); |
|
6507 #ifndef __KERNEL_MODE__ |
|
6508 inline static TArgType Type(const TDesC16*); |
|
6509 #endif |
|
6510 inline static TArgType Type(TDes8*); |
|
6511 #ifndef __KERNEL_MODE__ |
|
6512 inline static TArgType Type(TDes16*); |
|
6513 #endif |
|
6514 // |
|
6515 inline static void Assign(TInt&,TNothing); |
|
6516 inline static void Assign(TInt& aArg,TInt aValue); |
|
6517 inline static void Assign(TInt& aArg,const TAny* aValue); |
|
6518 inline static void Assign(TInt& aArg,RHandleBase aValue); |
|
6519 inline static void Assign(TInt& aArg,const TDesC8* aValue); |
|
6520 #ifndef __KERNEL_MODE__ |
|
6521 inline static void Assign(TInt& aArg,const TDesC16* aValue); |
|
6522 #endif |
|
6523 inline static void Assign(TInt& aArg,TDes8* aValue); |
|
6524 #ifndef __KERNEL_MODE__ |
|
6525 inline static void Assign(TInt& aArg,TDes16* aValue); |
|
6526 #endif |
|
6527 public: |
|
6528 |
|
6529 /** |
|
6530 The location where the message arguments are stored. |
|
6531 |
|
6532 There is no reason to access this data member directly and it should be |
|
6533 considered as internal. |
|
6534 */ |
|
6535 TInt iArgs[KMaxMessageArguments]; |
|
6536 |
|
6537 /** |
|
6538 The location where the flag bits describing the argument types are stored. |
|
6539 |
|
6540 The symbolic values describing the argument types are internal to Symbian, |
|
6541 and there is therefore no reason to access this data member directly. |
|
6542 It should be considered as internal. |
|
6543 */ |
|
6544 TInt iFlags; |
|
6545 }; |
|
6546 |
|
6547 // Structures for passing 64 bit integers and doubles across GCC/EABI boundaries |
|
6548 |
|
6549 /** |
|
6550 @internalComponent |
|
6551 */ |
|
6552 struct SInt64 |
|
6553 { |
|
6554 public: |
|
6555 inline SInt64(); |
|
6556 inline SInt64(Int64 a); |
|
6557 inline SInt64& operator=(Int64 a); |
|
6558 inline operator Int64() const; |
|
6559 public: |
|
6560 TUint32 iData[2]; // little endian |
|
6561 }; |
|
6562 |
|
6563 /** |
|
6564 @internalComponent |
|
6565 */ |
|
6566 struct SUint64 |
|
6567 { |
|
6568 public: |
|
6569 inline SUint64(); |
|
6570 inline SUint64(Uint64 a); |
|
6571 inline SUint64& operator=(Uint64 a); |
|
6572 inline operator Uint64() const; |
|
6573 public: |
|
6574 TUint32 iData[2]; // little endian |
|
6575 }; |
|
6576 |
|
6577 /** |
|
6578 @internalComponent |
|
6579 */ |
|
6580 struct SDouble |
|
6581 { |
|
6582 public: |
|
6583 inline SDouble(); |
|
6584 inline SDouble(TReal a); |
|
6585 inline SDouble& operator=(TReal a); |
|
6586 inline operator TReal() const; |
|
6587 public: |
|
6588 TUint32 iData[2]; // always little endian |
|
6589 }; |
|
6590 |
|
6591 /** |
|
6592 @publishedAll |
|
6593 @released |
|
6594 |
|
6595 Stores information about a thread's stack. |
|
6596 |
|
6597 Note, on the emulator, the memory between iLimit and the thread's current stack pointer |
|
6598 may not actually be committed. |
|
6599 |
|
6600 @see RThread::StackInfo() |
|
6601 */ |
|
6602 class TThreadStackInfo |
|
6603 { |
|
6604 public: |
|
6605 /** |
|
6606 The address which the stack pointer would contain if the stack were empty. |
|
6607 */ |
|
6608 TLinAddr iBase; |
|
6609 |
|
6610 /** |
|
6611 The address which the stack pointer would contain if the stack were full, |
|
6612 (The lowest valid address). |
|
6613 */ |
|
6614 TLinAddr iLimit; |
|
6615 |
|
6616 /** |
|
6617 The limit value for the stack if it were expanded to its maximum size. |
|
6618 |
|
6619 Currently expanding stacks is not supported so iExpandLimit==iLimit |
|
6620 */ |
|
6621 TLinAddr iExpandLimit; |
|
6622 }; |
|
6623 |
|
6624 |
|
6625 |
|
6626 |
|
6627 #ifdef __SUPPORT_CPP_EXCEPTIONS__ |
|
6628 /** |
|
6629 @internalComponent |
|
6630 @released |
|
6631 |
|
6632 The class used to implement User::Leave in term of throw and TRAP in terms of catch. |
|
6633 |
|
6634 */ |
|
6635 class XLeaveException |
|
6636 { |
|
6637 public: |
|
6638 inline XLeaveException() {} |
|
6639 inline XLeaveException(TInt aReason) {iR = aReason;} |
|
6640 inline TInt Reason() const {return iR;} |
|
6641 IMPORT_C TInt GetReason() const; |
|
6642 private: |
|
6643 #if __ARMCC_VERSION >= 220000 |
|
6644 // From rvct 2.2 onwards we want the class impedimenta to be shared, so create a key function. |
|
6645 // Unfortunately we can't make this the key function the dtor since this would make it impossible for existing 2.1 |
|
6646 // derived binaries to be 'BC' with 2.2 binaries (in the general case (which I wont attempt to describe coz its |
|
6647 // too complex) so its best to be safe). As a clue: if 2.1 is used to compile with a key function its not possible |
|
6648 // for catch handlers to work :-( (see the old code). |
|
6649 virtual void ForceKeyFunction(); |
|
6650 #endif |
|
6651 private: |
|
6652 #if __ARMCC_VERSION < 220000 |
|
6653 TAny* iVtable; // reserve space for vtable |
|
6654 #endif |
|
6655 TInt iR; |
|
6656 }; |
|
6657 |
|
6658 // The standard header file <exception> defines the following guard macro for EDG and CW, VC++, GCC respectively. |
|
6659 // The guard below is ugly. It will surely come back and bite us unless we resolve the whole issue of standard headers |
|
6660 // when we move to supporting Standard C++. |
|
6661 |
|
6662 // The macro __SYMBIAN_STDCPP_SUPPORT__ is defined when building a StdC++ target. |
|
6663 // In this case, we include the StdC++ specification <exception> rather than declaring uncaught_exception. |
|
6664 |
|
6665 #ifdef __SYMBIAN_STDCPP_SUPPORT__ |
|
6666 #include <stdapis/stlportv5/exception> |
|
6667 #elif !defined(_EXCEPTION) && !defined(_EXCEPTION_) && !defined(__EXCEPTION__) |
|
6668 // Declare standard C++ functions relating to exceptions here |
|
6669 namespace std { |
|
6670 #if defined(__VC32__) || defined(__CW32__) |
|
6671 bool uncaught_exception(); |
|
6672 #else |
|
6673 IMPORT_C bool uncaught_exception(); |
|
6674 #endif |
|
6675 void terminate(void); |
|
6676 void unexpected(void); |
|
6677 typedef void (*terminate_handler)(); |
|
6678 terminate_handler set_terminate(terminate_handler h) throw(); |
|
6679 typedef void (*unexpected_handler)(); |
|
6680 unexpected_handler set_unexpected(unexpected_handler h) throw(); |
|
6681 } |
|
6682 |
|
6683 #endif |
|
6684 #endif //__SUPPORT_CPP_EXCEPTIONS__ |
|
6685 |
|
6686 #ifdef __WINS__ |
|
6687 |
|
6688 #ifndef __WIN32_SEH_TYPES_KNOWN__ |
|
6689 class __UnknownWindowsType1; |
|
6690 class __UnknownWindowsType2; |
|
6691 #endif |
|
6692 |
|
6693 class TWin32SEHTrap; |
|
6694 |
|
6695 /** |
|
6696 * Typedef for the SEH handler function |
|
6697 * @internalComponent |
|
6698 */ |
|
6699 typedef TUint32 (TWin32SEHExceptionHandler)(__UnknownWindowsType1* aExceptionRecord, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext); |
|
6700 |
|
6701 /** |
|
6702 * @internalComponent |
|
6703 */ |
|
6704 class TWin32SEHTrap |
|
6705 { |
|
6706 private: |
|
6707 // Prevent copy/assign |
|
6708 TWin32SEHTrap(TWin32SEHTrap const &); |
|
6709 TWin32SEHTrap& operator=(TWin32SEHTrap const &); |
|
6710 |
|
6711 #ifdef __KERNEL_MODE__ |
|
6712 // |
|
6713 // Kernel-side functions for nkern exception handler |
|
6714 // |
|
6715 public: |
|
6716 /** Find final exception handler in SEH chain */ |
|
6717 static TWin32SEHTrap* IterateForFinal(); |
|
6718 |
|
6719 /** Access exception handler */ |
|
6720 TWin32SEHExceptionHandler* ExceptionHandler(); |
|
6721 |
|
6722 private: |
|
6723 |
|
6724 #else // !__KERNEL_MODE__ |
|
6725 // |
|
6726 // User-side functions for use in TRAP(...) |
|
6727 // |
|
6728 public: |
|
6729 UIMPORT_C TWin32SEHTrap(); |
|
6730 |
|
6731 public: |
|
6732 /** Add object to SEH chain */ |
|
6733 UIMPORT_C void Trap(); |
|
6734 |
|
6735 /** Remove object from SEH chain */ |
|
6736 UIMPORT_C void UnTrap(); |
|
6737 |
|
6738 #ifndef __IN_SEH_CPP__ |
|
6739 private: |
|
6740 #endif |
|
6741 /** Handle Win32 exceptions */ |
|
6742 static TUint32 ExceptionHandler(__UnknownWindowsType1* aException, TWin32SEHTrap* aRegistrationRecord, __UnknownWindowsType2* aContext); |
|
6743 |
|
6744 #endif //__KERNEL_MODE__ |
|
6745 |
|
6746 // |
|
6747 // NB: This is really an _EXCEPTION_REGISTRATION_RECORD |
|
6748 // |
|
6749 TWin32SEHTrap* iPrevExceptionRegistrationRecord; /** Link to previous SEH record */ |
|
6750 TWin32SEHExceptionHandler* iExceptionHandler; /** SEH handler function */ |
|
6751 |
|
6752 private: |
|
6753 TUint32 iPadding[254]; // discourage the compiler from putting this in reused function parameter space |
|
6754 }; |
|
6755 |
|
6756 #else // !__WINS__ |
|
6757 |
|
6758 #ifdef __X86__ |
|
6759 /** |
|
6760 * @internalComponent |
|
6761 */ |
|
6762 class TWin32SEHTrap |
|
6763 { |
|
6764 public: |
|
6765 UIMPORT_C TWin32SEHTrap(); |
|
6766 UIMPORT_C void Trap(); |
|
6767 UIMPORT_C void UnTrap(); |
|
6768 }; |
|
6769 #endif //__X86__ |
|
6770 #endif //__WINS__ |
|
6771 |
|
6772 /** |
|
6773 @internalTechnology |
|
6774 */ |
|
6775 struct TEmulatorImageHeader |
|
6776 { |
|
6777 TUid iUids[KMaxCheckedUid]; |
|
6778 TProcessPriority iPriority; |
|
6779 SSecurityInfo iS; |
|
6780 TUint32 iSpare1; |
|
6781 TUint32 iSpare2; |
|
6782 TUint32 iModuleVersion; |
|
6783 TUint32 iFlags; |
|
6784 }; |
|
6785 |
|
6786 // forward declaration of shareable data buffers pool infomation |
|
6787 class TShPoolInfo; |
|
6788 |
|
6789 #include <e32cmn.inl> |
|
6790 |
|
6791 #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS |
|
6792 #include <e32cmn_private.h> |
|
6793 #endif |
|
6794 |
|
6795 #endif //__E32CMN_H__ |
|
6796 |