--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/e32/include/u32std.h	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,771 @@
+// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32\include\u32std.h
+// 
+//
+
+/**
+ @file
+ @internalComponent
+ @released
+*/
+
+#ifndef __U32STD_H__
+#define __U32STD_H__
+#include <e32cmn.h>
+#include <e32cmn_private.h>
+#include <e32hal.h>
+#include <e32lmsg.h>
+#include <e32event.h>
+#include <e32ldr.h>
+#include <e32power.h>
+#include <e32shbufcmn.h>
+#include <e32property.h>
+#include <u32property.h>
+#include <u32hal.h>
+
+#include <cpudefs.h>
+
+#ifdef __MARM__
+#define	EKA2_ENTRY_POINT_VERSION_IDENTIFIER	\
+	asm("tst pc, #%a0" : : "i" ((TInt)0) )
+#endif
+
+struct TUnicodeDataSet;                 // forward declaration
+struct TCollationDataSet;               // forward declaration
+
+/*
+The LCharSet structure is used in Unicode builds to supply locale-specific
+character attribute and collation data.
+
+The structure is defined in both builds to avoid having to have a dummy ExecHandler::GetLocaleCharSet function
+with a different signature in the 8-bit build.
+*/
+struct LCharSet
+	{
+	const TUnicodeDataSet* iCharDataSet;			// if non-null, character data overriding standard Unicode data
+	const TCollationDataSet* iCollationDataSet;		// if non-null, locale-specific collation data
+	};
+
+extern const LCharSet* GetLocaleCharSet();
+
+/** @internalTechnology */
+const TInt KNumLocaleExports = 22;
+
+//
+// The bits in the type table (non-Unicode build only)
+//
+#ifndef _UNICODE
+
+/** @internalTechnology */
+const TUint __U=0x01; // Uppercase letter
+
+/** @internalTechnology */
+const TUint __L=0x02; // Lowercase letter
+
+/** @internalTechnology */
+const TUint __D=0x04; // Decimal digit
+
+/** @internalTechnology */
+const TUint __S=0x08; // Space
+
+/** @internalTechnology */
+const TUint __P=0x10; // Punctuation
+
+/** @internalTechnology */
+const TUint __C=0x20; // Control character
+
+/** @internalTechnology */
+const TUint __X=0x40; // Hex digit
+
+/** @internalTechnology */
+const TUint __B=0x80; // A blank character
+
+#endif
+
+//
+// Time set mode parameters for setting system time and offset
+// 
+enum TTimeSetMode
+	{
+	ETimeSetTime = 1,    // set the time to the value given, else leave it unchanged
+	ETimeSetOffset = 2,  // set the offset to the value given, else leave it unchanged
+	ETimeSetAllowTimeReversal = 4,  // allow time to go backwards
+	ETimeSetNoTimeUpdate = 8,       // Don't restart second queue or notify changes - not valid with ESetTime, used early in boot only
+	ETimeSetLocalTime = 16,			// Set time in local time, instead of UTC
+	ETimeSetSecure = 32,  // use when setting the secure hardware clock
+	};
+
+//
+enum TMatchType {EMatchNormal,EMatchFolded,EMatchCollated};
+
+//
+// Constants for descriptor implementation code
+//
+enum TDesType {EBufC,EPtrC,EPtr,EBuf,EBufCPtr};
+const TUint KMaskDesLength=0xfffffff;
+const TInt KShiftDesType=28;
+
+//
+// Constants for iFlags in DProcess and DThread
+//
+const TUint KThreadFlagProcessCritical		= 0x00000001;	// thread panic panics process
+const TUint KThreadFlagProcessPermanent		= 0x00000002;	// thread exit of any kind causes process to exit (=main)
+const TUint KThreadFlagSystemCritical		= 0x00000004;	// thread panic reboots entire system
+const TUint KThreadFlagSystemPermanent		= 0x00000008;	// thread exit of any kind reboots entire system
+const TUint KThreadFlagOriginal				= 0x00000010;
+const TUint KThreadFlagLastChance			= 0x00000020;
+const TUint KThreadFlagRealtime				= 0x00000040;	// thread will be panicked when using some non-realtime functions
+const TUint KThreadFlagRealtimeTest			= 0x00000080;	// non-realtime functions only warn rather than panic
+const TUint KProcessFlagPriorityControl		= 0x40000000;
+const TUint KProcessFlagJustInTime			= 0x80000000;
+const TUint KProcessFlagSystemCritical		= KThreadFlagSystemCritical;	// process panic reboots entire system
+const TUint KProcessFlagSystemPermanent		= KThreadFlagSystemPermanent;	// process exit of any kind reboots entire system
+//
+const TUint KThreadHandle=0x40000000;
+//
+struct SPtrC8 {TInt length;const TUint8 *ptr;};
+struct SBufC8 {TInt length;TUint8 buf[1];};
+struct SPtr8 {TInt length;TInt maxLength;TUint8 *ptr;};
+struct SBuf8 {TInt length;TInt maxLength;TUint8 buf[1];};
+struct SBufCPtr8 {TInt length;TInt maxLength;SBufC8 *ptr;};
+
+struct SPtrC16 {TInt length;const TUint16 *ptr;};
+struct SBufC16 {TInt length;TUint16 buf[1];};
+struct SPtr16 {TInt length;TInt maxLength;TUint16 *ptr;};
+struct SBuf16 {TInt length;TInt maxLength;TUint16 buf[1];};
+struct SBufCPtr16 {TInt length;TInt maxLength;SBufC16 *ptr;};
+
+//
+// Flags used for IPC copy functions
+//
+const TInt KChunkShiftBy0=0;
+const TInt KChunkShiftBy1=KMinTInt;
+const TInt KIpcDirRead=0;
+const TInt KIpcDirWrite=0x10000000;
+
+class TChunkCreate
+	{
+public:
+	enum TChunkCreateAtt
+		{
+		ENormal=0x00,
+		EDoubleEnded=0x01,
+		EDisconnected=0x02,
+		EMappingMask=0x0f,
+		ELocal=0x00,
+		EGlobal=0x10,
+		EData=0x00,
+		ECode=0x20,
+
+		EChunkCreateAttMask = EMappingMask | EGlobal | ECode,
+		};
+public:
+	TUint iAtt;
+	TBool iForceFixed;
+	TInt iInitialBottom;
+	TInt iInitialTop;
+	TInt iMaxSize;
+	TUint8 iClearByte;
+	};
+
+enum TChunkRestrictions
+	{
+	// Keep this in sync with definitions in RChunk
+	EChunkPreventAdjust = 0x01,  // Disallow Adjust, Commit, Allocate and Decommit
+	};
+
+class TChannelDoCreate
+	{
+public:
+	TVersion iVer;
+	const TDesC *iName;
+	const TDesC *iPhysicalDevice;
+	const TDesC8 *iInfo;
+	};
+
+class TCreateSession
+	{
+public:
+	TVersion iVer;
+	TInt iMessageSlots;
+	};
+
+enum TObjectType
+	{
+	EThread=0,
+	EProcess,
+	EChunk,
+	ELibrary,
+	ESemaphore,
+	EMutex,
+	ETimer,
+	EServer,
+	ESession,
+	ELogicalDevice,
+	EPhysicalDevice,
+	ELogicalChannel,
+	EChangeNotifier,
+	EUndertaker,
+	EMsgQueue,	
+	EPropertyRef,
+	ECondVar,
+	EShPool,
+	EShBuf,
+	ENumObjectTypes,	// number of DObject-derived types
+	EObjectTypeAny=-1,
+
+	EIpcMessageD=0x20,	// lookup IPC message handle, allow disconnect
+	EIpcMessage=0x21,	// lookup IPC message handle, don't allow disconnect
+	EIpcClient=0x22,	// lookup IPC message client, don't allow disconnect
+	};
+
+class TObjectOpenInfo
+	{
+public:
+	TObjectType iObjType;
+	TBool isReadOnly;
+	};
+
+class TChannelCreateInfo
+	{
+public:
+	TVersion iVersion;
+	TInt iUnit;
+	const TDesC* iPhysicalDevice;
+	const TDesC8* iInfo;
+	};
+
+#if defined(_UNICODE) && !defined(__KERNEL_MODE__)
+class TChannelCreateInfo8
+	{
+public:
+	TVersion iVersion;
+	TInt iUnit;
+	const TDesC8* iPhysicalDevice;
+	const TDesC8* iInfo;
+	};
+#else
+typedef TChannelCreateInfo TChannelCreateInfo8;
+#endif
+
+const TInt KMaxThreadCreateInfo = 256;
+struct SThreadCreateInfo
+	{
+	TAny* iHandle;
+	TInt iType;
+	TThreadFunction iFunction;
+	TAny* iPtr;
+	TAny* iSupervisorStack;
+	TInt iSupervisorStackSize;
+	TAny* iUserStack;
+	TInt iUserStackSize;
+	TInt iInitialThreadPriority;
+	TPtrC iName;
+	TInt iTotalSize;	// Size including any extras (must be a multiple of 8 bytes)
+	};
+
+enum EThreadCreationFlags
+	{
+	ETraceHeapAllocs = 1,
+	EMonitorHeapMemory = 2,
+	};
+
+struct SStdEpocThreadCreateInfo : public SThreadCreateInfo
+	{
+	RAllocator* iAllocator;
+	TInt iHeapInitialSize;
+	TInt iHeapMaxSize;
+	TUint iFlags;
+	};
+
+#if defined(_UNICODE) && !defined(__KERNEL_MODE__)
+struct SThreadCreateInfo8
+	{
+	TAny* iHandle;
+	TInt iType;
+	TThreadFunction iFunction;
+	TAny* iPtr;
+	TAny* iSupervisorStack;
+	TInt iSupervisorStackSize;
+	TAny* iUserStack;
+	TInt iUserStackSize;
+	TInt iInitialThreadPriority;
+	TPtrC8 iName;
+	TInt iTotalSize;	// size including any extras
+	};
+
+struct SStdEpocThreadCreateInfo8 : public SThreadCreateInfo8
+	{
+	RAllocator* iAllocator;
+	TInt iHeapInitialSize;
+	TInt iHeapMaxSize;
+	TInt iPadding;		// Make structure size a multiple of 8 bytes
+	};
+#else
+typedef SThreadCreateInfo SThreadCreateInfo8;
+typedef SStdEpocThreadCreateInfo SStdEpocThreadCreateInfo8;
+#endif
+
+struct SIpcCopyInfo
+	{
+	TUint8* iLocalPtr;
+	TInt iLocalLen;
+	TInt iFlags;
+	};
+
+enum TChunkAdjust
+	{
+	EChunkAdjust=0,
+	EChunkAdjustDoubleEnded=1,
+	EChunkCommit=2,
+	EChunkDecommit=3,
+	EChunkAllocate=4,
+	EChunkUnlock=5,
+	EChunkLock=6
+	};
+
+enum TMemModelAttributes
+	{
+	EMemModelTypeMask=0xf,					// bottom 4 bits give type of memory model
+	EMemModelTypeDirect=0,					// direct memory model on hardware
+	EMemModelTypeMoving=1,					// moving memory model on hardware
+	EMemModelTypeMultiple=2,				// multiple memory model on hardware
+	EMemModelTypeEmul=3,					// emulation using single host process
+	EMemModelTypeFlexible=4,				// flexible memory model on hardware
+
+	EMemModelAttrRomPaging=0x10,			// Demand paging of XIP ROM
+	EMemModelAttrCodePaging=0x20,			// Demand paging of RAM loaded code
+	EMemModelAttrDataPaging=0x40,			// Demand paging of all RAM
+	EMemModelAttrPagingMask=0xf0,			// Mask for demand paging attributes
+
+	EMemModelAttrNonExProt=(TInt)0x80000000,// accesses to nonexistent addresses are trapped
+	EMemModelAttrKernProt=0x40000000,		// accesses to kernel memory from user mode are trapped
+	EMemModelAttrWriteProt=0x20000000,		// addresses can be marked as read-only; writes to these are trapped
+	EMemModelAttrVA=0x10000000,				// system supports virtual addresses
+	EMemModelAttrProcessProt=0x08000000,	// accesses to other processes' memory are trapped
+	EMemModelAttrSameVA=0x04000000,			// different processes map the same virtual address to different physical addresses
+	EMemModelAttrSupportFixed=0x02000000,	// 'fixed' processes are supported
+	EMemModelAttrSvKernProt=0x01000000,		// unexpected accesses to kernel memory within an executive call are trapped
+	EMemModelAttrIPCKernProt=0x00800000,	// accesses to kernel memory via IPC are trapped
+	EMemModelAttrIPCFullProt=0x00400000,	// accesses via IPC have same protection as user mode
+	EMemModelAttrRamCodeProt=0x00200000,	// RAM-loaded code is only visible to processes which have loaded it
+	};
+
+/** @test */
+enum TKernelHeapDebugFunction {EDbgMarkStart,EDbgMarkCheck,EDbgMarkEnd,EDbgSetAllocFail,EDbgSetBurstAllocFail,EDbgCheckFailure};
+
+/** @test */
+class TKernelHeapMarkCheckInfo
+	{
+public:
+	TBool iCountAll;
+	const TDesC8* iFileName;
+	TInt iLineNum;
+	};
+//
+class TTrapHandler;
+class CActiveScheduler;
+class TLocale;
+
+//
+//
+//
+// Handler below is used by test prints to trucate rather than panic the caller.
+//
+#if defined(_UNICODE) && !defined(__KERNEL_MODE__)
+NONSHARABLE_CLASS(TestOverflowTruncate) : public TDes16Overflow
+	{
+public:
+	virtual void Overflow(TDes16 &aDes);
+	};
+#else
+NONSHARABLE_CLASS(TestOverflowTruncate) : public TDes8Overflow
+	{
+public:
+	virtual void Overflow(TDes8 &aDes);
+	};
+#endif
+//
+
+/********************************************
+ * Thread local storage entry
+ ********************************************/
+struct STls
+	{
+	TInt	iHandle;
+	TInt	iDllUid;
+	TAny*	iPtr;
+	};
+
+const TInt KDllUid_Default = 0;		// for ROM DLLs and direct calls to UserSvr::DllTls
+const TInt KDllUid_Special = -1;	// used on emulator to instruct the kernel to get the DLL UID from the module handle
+
+/********************************************
+ * Entry point call values
+ ********************************************/
+const TInt	KModuleEntryReasonProcessInit		=0;		// Process start
+const TInt	KModuleEntryReasonThreadInit		=1;		// Start new thread
+const TInt	KModuleEntryReasonProcessAttach		=2;		// Process attach (init static data)
+const TInt	KModuleEntryReasonProcessDetach		=3;		// Process detach (destroy static data)
+const TInt	KModuleEntryReasonException			=4;		// Handle exception
+const TInt	KModuleEntryReasonVariantInit0		=-3;	// Call variant static constructors
+
+/** @publishedPartner
+	@released
+*/
+const TInt	KModuleEntryReasonExtensionInit0	=-2;	// Extension early initialisation check
+
+/** @publishedPartner
+	@released
+*/
+const TInt	KModuleEntryReasonExtensionInit1	=-1;	// Extension initialisation
+
+/**
+	Flags returned by Exec::KernelConfigFlags()
+*/
+enum TKernelConfigFlags
+	{
+	EKernelConfigIpcV1Available = 1<<0,
+	EKernelConfigPlatSecEnforcement = 1<<1,
+	EKernelConfigPlatSecDiagnostics = 1<<2,
+	EKernelConfigPlatSecProcessIsolation = 1<<3,
+	EKernelConfigPlatSecEnforceSysBin = 1<<4,
+
+	EKernelConfigPagingPolicyMask = 3<<5,
+	EKernelConfigPagingPolicyNoPaging = 0<<5,
+	EKernelConfigPagingPolicyAlwaysPage = 1<<5,
+	EKernelConfigPagingPolicyDefaultUnpaged = 2<<5,
+	EKernelConfigPagingPolicyDefaultPaged = 3<<5,
+
+	EKernelConfigPlatSecLocked = 1<<7,					// Primarily used by __PLATSEC_UNLOCKED__ (q.v.) test code
+
+	EKernelConfigCrazyScheduling = 1<<8,				// Enables thread priority/timeslice craziness
+
+	EKernelConfigDisableAPs = 1u<<30,
+
+	EKernelConfigTest = 1u<<31,							// Only used by test code for __PLATSEC_UNLOCKED__
+	};
+
+/**
+	If __PLATSEC_UNLOCKED__ is not defined, these flags must always
+	be considered to be set.  See KernelConfigFlags() in kern_priv.h.
+
+	@see KernelConfigFlags()
+
+	@internalTechnology
+*/
+#ifdef __PLATSEC_UNLOCKED__
+#define __PLATSEC_FORCED_FLAGS__	 0
+#else
+#define __PLATSEC_FORCED_FLAGS__	(EKernelConfigPlatSecEnforcement|EKernelConfigPlatSecProcessIsolation|EKernelConfigPlatSecEnforceSysBin)
+#endif
+
+/**
+@internalTechnology
+*/
+enum TGlobalUserData
+	{
+	ELocaleDefaultCharSet,
+	ELocalePreferredCharSet,
+	EMaxGlobalUserData
+	};
+
+typedef void (*TGlobalDestructorFunc)(void);
+
+// This must not conflict with any possible valid TLS keys
+const TInt KGlobalDestructorTlsKey = -1;
+
+GLREF_C void ExitCurrentThread(TExitType, TInt, const TDesC8*);
+
+#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__
+/**
+@internalTechnology
+*/
+class TPlatSecDiagnostic
+	{
+public:
+	enum TType
+		{
+		ELoaderCapabilityViolation1,
+		ELoaderCapabilityViolation2,
+		EThreadCapabilityCheckFail,
+		EProcessCapabilityCheckFail,
+		EKernelSecureIdCheckFail,
+		EKernelObjectPolicyCheckFail,
+		EHandleCapabilityCheckFail,
+		ECreatorCapabilityCheckFail,
+		EMessageCapabilityCheckFail,
+		EKernelProcessIsolationFail,
+		EKernelProcessIsolationIPCFail,
+		ECreatorPolicyCheckFail,		
+		};
+public:
+	inline TPlatSecDiagnostic();
+	inline TPlatSecDiagnostic(TType aType);
+	inline TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2, const SCapabilitySet& aCaps);
+	inline TPlatSecDiagnostic(TType aType, TInt aInt1, const SSecurityInfo& aCaps);
+	inline TPlatSecDiagnostic(TType aType, TInt aInt, const TDesC8& aString, const SCapabilitySet& aCaps);
+	inline TPlatSecDiagnostic(TType aType, const TDesC8& aString1, const TDesC8& aString2, const SCapabilitySet& aCaps);
+	inline TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2);
+	inline TPlatSecDiagnostic(TType aType, TInt aInt1);
+	inline const TDesC8* String1();
+	inline const TDesC8* String2();
+public:
+	TType iType;
+	TInt iArg1;
+	TInt iArg2;
+	const char* iContextText;
+	TInt iContextTextLength;
+	SSecurityInfo iSecurityInfo;
+	};
+
+inline TPlatSecDiagnostic::TPlatSecDiagnostic()
+	{}
+
+inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType)
+	: iType(aType)
+	{}
+
+inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType,TInt aInt1)
+	: iType(aType), iArg1(aInt1)
+	{}
+
+inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2, const SCapabilitySet& aCaps)
+	: iType(aType), iArg1(aInt1), iArg2(aInt2), iContextText(0) 
+	{
+	iSecurityInfo.iSecureId = 0;
+	iSecurityInfo.iVendorId = 0;
+	iSecurityInfo.iCaps = aCaps;
+	};
+inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt1, const SSecurityInfo& aInfo)
+	: iType(aType), iArg1(aInt1), iArg2(ECapability_None), iContextText(0), iSecurityInfo(aInfo) 
+	{
+	};
+
+inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt, const TDesC8& aString, const SCapabilitySet& aCaps)
+	: iType(aType), iArg1(aInt), iArg2((TInt)&aString), iContextText(0) 
+	{
+	iSecurityInfo.iSecureId = 0;
+	iSecurityInfo.iVendorId = 0;
+	iSecurityInfo.iCaps = aCaps;
+	};
+
+inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, const TDesC8& aString1, const TDesC8& aString2, const SCapabilitySet& aCaps)
+	: iType(aType), iArg1((TInt)&aString1), iArg2((TInt)&aString2), iContextText(0) 
+	{
+	iSecurityInfo.iSecureId = 0;
+	iSecurityInfo.iVendorId = 0;
+	iSecurityInfo.iCaps = aCaps;
+	};
+
+inline TPlatSecDiagnostic::TPlatSecDiagnostic(TType aType, TInt aInt1, TInt aInt2)
+	: iType(aType), iArg1(aInt1), iArg2(aInt2) 
+	{
+	iSecurityInfo.iSecureId = 0;
+	iSecurityInfo.iVendorId = 0;
+	iSecurityInfo.iCaps[0] = 0;
+	iSecurityInfo.iCaps[1] = 0;
+	};
+
+inline const TDesC8* TPlatSecDiagnostic::String1()
+	{ return (const TDesC8*)iArg1; }
+
+inline const TDesC8* TPlatSecDiagnostic::String2()
+	{ return (const TDesC8*)iArg2; }
+
+inline TInt PlatSec::LoaderCapabilityViolation(const TDesC8& aImporterName, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::ELoaderCapabilityViolation2,aImporterName,aFileName,aMissingCaps);
+	return EmitDiagnostic(d, NULL);
+	}
+
+#ifdef __KERNEL_MODE__
+
+inline TInt PlatSec::CapabilityCheckFail(const DProcess* aViolatingProcess, TCapability aCapability, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EProcessCapabilityCheckFail,(TInt)aViolatingProcess,(TInt)aCapability);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::CapabilityCheckFail(const DThread* aViolatingThread, TCapability aCapability, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EThreadCapabilityCheckFail,(TInt)aViolatingThread,(TInt)aCapability);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::SecureIdCheckFail(const DProcess* aViolatingProcess, TSecureId aSid, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelSecureIdCheckFail,(TInt)aViolatingProcess,(TInt)aSid);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::PolicyCheckFail(const DProcess* aProcess, const SSecurityInfo& aMissingSecurityInfo, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelObjectPolicyCheckFail,(TInt)aProcess,(const SSecurityInfo&)aMissingSecurityInfo);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::PolicyCheckFail(const DThread* aThread, const SSecurityInfo& aMissingSecurityInfo, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelObjectPolicyCheckFail,(TInt)aThread,(const SSecurityInfo&)aMissingSecurityInfo);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::ProcessIsolationFail(const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelProcessIsolationFail);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::ProcessIsolationIPCFail(RMessageK* aMessage, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EKernelProcessIsolationIPCFail,(TInt)aMessage);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+#else // !__KERNEL_MODE__
+
+inline TInt PlatSec::LoaderCapabilityViolation(RProcess aLoadingProcess, const TDesC8& aFileName, const SCapabilitySet& aMissingCaps)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::ELoaderCapabilityViolation1,aLoadingProcess.Handle(),aFileName,aMissingCaps);
+	return EmitDiagnostic(d, NULL);
+	}
+
+inline TInt PlatSec::CreatorCapabilityCheckFail(TCapability aCapability, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::ECreatorCapabilityCheckFail,(TInt)0,aCapability);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::CreatorCapabilityCheckFail(const TCapabilitySet& aMissingCaps, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::ECreatorCapabilityCheckFail,(TInt)0,ECapability_None,(const SCapabilitySet&)aMissingCaps);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::CapabilityCheckFail(TInt aHandle, TCapability aCapability, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EHandleCapabilityCheckFail,aHandle,aCapability);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::CapabilityCheckFail(TInt aHandle, const TCapabilitySet& aMissingCaps, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EHandleCapabilityCheckFail,aHandle,ECapability_None,(const SCapabilitySet&)aMissingCaps);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::PolicyCheckFail(TInt aHandle, const SSecurityInfo& aMissingSecurityInfo, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EHandleCapabilityCheckFail,aHandle,(const SSecurityInfo&)aMissingSecurityInfo);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::CapabilityCheckFail(RMessagePtr2 aMessage, TCapability aCapability, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EMessageCapabilityCheckFail,(TInt)aMessage.Handle(),aCapability);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::CapabilityCheckFail(RMessagePtr2 aMessage, const TCapabilitySet& aMissingCaps, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EMessageCapabilityCheckFail,(TInt)aMessage.Handle(),ECapability_None,(const SCapabilitySet&)aMissingCaps);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::PolicyCheckFail(RMessagePtr2 aMessage, const SSecurityInfo& aMissing, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::EMessageCapabilityCheckFail,(TInt)aMessage.Handle(),(const SSecurityInfo&)aMissing);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+inline TInt PlatSec::CreatorPolicyCheckFail(const SSecurityInfo& aMissing, const char* aContextText)
+	{
+	TPlatSecDiagnostic d(TPlatSecDiagnostic::ECreatorPolicyCheckFail,(TInt)0,(const SSecurityInfo&)aMissing);
+	return EmitDiagnostic(d,aContextText);
+	}
+
+#endif //__KERNEL_MODE__
+#endif // !__REMOVE_PLATSEC_DIAGNOSTICS__
+
+const TInt KTlsArrayGranularity=2;
+
+#ifdef __CPU_HAS_CP15_THREAD_ID_REG
+
+#ifndef __TOOLS2__
+#define __USERSIDE_THREAD_DATA__
+#endif // __TOOLS2__
+
+class TLocalThreadData
+	{
+public:
+	void Close();
+#ifndef __KERNEL_MODE__
+	TAny* DllTls(TInt aHandle, TInt aDllUid);
+	TInt DllSetTls(TInt aHandle, TInt aDllUid, TAny* aPtr);
+	void DllFreeTls(TInt aHandle);
+#endif
+public:
+#ifndef __TOOLS2__
+	RAllocator* iHeap;				///< The thread's current heap
+#endif // __TOOLS2__
+	CActiveScheduler* iScheduler;	///< The thread's current active scheduler
+	TTrapHandler* iTrapHandler;		///< The thread's current trap handler
+private:
+	RAllocator* iTlsHeap; 			///< The heap that the DLL TLS data is stored on
+	RArray<STls> iTls; 				///< DLL TLS data
+	};
+
+const TInt KLocalThreadDataSize = _ALIGN_UP(sizeof(TLocalThreadData), 8);
+
+#endif
+
+#ifdef __WINS__
+
+enum TWin32RuntimeReason
+	{
+	// Same values as passed to DllMain
+	EWin32RuntimeProcessAttach = 1,
+	EWin32RuntimeThreadAttach = 2,
+	EWin32RuntimeThreadDetach = 3,
+	EWin32RuntimeProcessDetach = 4,
+	};
+
+typedef TBool (*TWin32RuntimeHook)(TWin32RuntimeReason);
+
+#endif
+
+struct SAtomicOpInfo64
+	{
+	TAny*		iA;
+	TAny*		iQ;
+	TUint64		i1;
+	TUint64		i2;
+	TUint64		i3;
+	};
+
+struct SAtomicOpInfo32
+	{
+	TAny*		iA;
+	union
+		{
+		TAny*	iQ;
+		TUint32	i0;
+		};
+	TUint32		i1;
+	TUint32		i2;
+	};
+
+#endif //__U32STD_H__