/*

* Copyright (c) 1994-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 "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

* e32\include\e32def.h

* NOTE: THIS FILE SHOULD BE ACCEPTABLE TO A C COMPILER

* 

*

*/

#ifndef __E32DEF_H__

#define __E32DEF_H__

/*

 * __LEAVE_EQUALS_THROW__ requires the compiler to support C++ exceptions

 */

#ifndef __SUPPORT_CPP_EXCEPTIONS__

#undef __LEAVE_EQUALS_THROW__

#endif

#if defined(__VC32__)

/**

@publishedAll

@released

*/

#define __NO_CLASS_CONSTS__

#if (_MSC_VER >= 1200)

/**

@publishedAll

@released

*/

#define __NORETURN__ __declspec(noreturn)

#else

#define __NORETURN__

#endif

/**

@publishedAll

@released

*/

#define __NORETURN_TERMINATOR()

/**

@publishedAll

@released

*/

#define IMPORT_C __declspec(dllexport)

/**

@publishedAll

@released

*/

#define EXPORT_C __declspec(dllexport)

/**

@publishedAll

@released

*/

#define IMPORT_D __declspec(dllexport)

/**

@publishedAll

@released

*/

#define EXPORT_D __declspec(dllexport)

/**

@publishedAll

@released

*/

#define NONSHARABLE_CLASS(x) class x

/**

@publishedAll

@released

*/

#define NONSHARABLE_STRUCT(x) struct x

/**

@publishedAll

@released

*/

#define __NO_THROW throw()

/**

@publishedAll

@released

*/

#define __THROW(t) throw(t)

#pragma warning( disable : 4355 )	/* 'this' used in base member initializer list */

#pragma warning( disable : 4511 )	/* copy constructor could not be generated */

#pragma warning( disable : 4512 )	/* assignment operator could not be generated */

#pragma warning( disable : 4514 )	/* unreferenced inline function has been removed */

#pragma warning( disable : 4699 )	/* Note: Using precompiled header %s */

#pragma warning( disable : 4710 )	/* function not inlined */

#pragma warning( disable : 4121 )	/* alignment sensitive to packing */

#pragma warning( disable : 4273 )

#pragma warning( disable : 4097 )	/* typedef-name 'identifier1' used as synonym for class-name 'identifier2' */

#pragma warning( disable : 4291 )	/* 'TAny *CBase::operator new(TUint,TLeave)' : no matching operator delete found; memory will not be freed if initialization throws an exception */

#if _MSC_VER  >= 1100

/**

@publishedAll

@released

*/

#define TEMPLATE_SPECIALIZATION template<>

#else

#define TEMPLATE_SPECIALIZATION

#endif

#endif

#if defined(__CW32__)

#undef __embedded_cplusplus

/** @internalTechnology */

#define __embedded_cplusplus	1

#define __NO_CLASS_CONSTS__

#define __NORETURN__

#define __NORETURN_TERMINATOR()

#define IMPORT_C __declspec(dllexport)

#define EXPORT_C __declspec(dllexport)

#define IMPORT_D __declspec(dllexport)

#define EXPORT_D __declspec(dllexport)

#define NONSHARABLE_CLASS(x) class x

#define NONSHARABLE_STRUCT(x) struct x

#define __NO_THROW throw()

#define __THROW(t) throw(t)

#define TEMPLATE_SPECIALIZATION template<>

/**

@publishedAll

@released

*/

#define _asm	asm

#ifndef __int64

#pragma longlong on

/** @internalTechnology */

#define __int64  long long

#endif

#ifndef __SUPPORT_CPP_EXCEPTIONS__

#pragma exceptions off    /* no support for C++ exception handling */

#pragma RTTI off          /* no support for C++ runtime type information */

#endif

#if __MWERKS__ >= 0x3200

#pragma warning off (10480)	/* deleteing void pointer is undefined */

#pragma warning off (10350) /* N pad byte(s) inserted after data member */

#endif

#endif

//

// GCC (ARM) compiler

//

#if defined(__GCC32__) && defined(__MARM__)

#ifndef __GNUC__		/* GCC98r2 doesn't define this for some reason */

#define __GNUC__	2

#endif

#define __NO_CLASS_CONSTS__

#define __NORETURN__  __attribute__ ((noreturn))

#ifdef __GCCV3__

#define __NORETURN_TERMINATOR()

#else

#define __NORETURN_TERMINATOR()		abort()

#endif

#define IMPORT_C

#define IMPORT_D

#if !defined __WINS__ && defined _WIN32 /* VC++ Browser Hack */

#define EXPORT_C

#define EXPORT_D

/** @internalTechnology */

#define asm(x)

#else

#define EXPORT_C __declspec(dllexport)

#define EXPORT_D __declspec(dllexport)

#endif

#define NONSHARABLE_CLASS(x) class x

#define NONSHARABLE_STRUCT(x) struct x

#define __NO_THROW

#define __THROW(t)

#ifdef __EABI__

#define TEMPLATE_SPECIALIZATION template<>

#else

#define TEMPLATE_SPECIALIZATION

#endif

/**

@publishedAll

@released

*/

#define __DOUBLE_WORDS_SWAPPED__

#endif

/** @internalTechnology */

#define __NO_MUTABLE_KEYWORD

#if defined(__NO_MUTABLE_KEYWORD)

/**

@publishedAll

@deprecated

*/

#define __MUTABLE

#else

#define __MUTABLE mutable

#endif

/**

@publishedAll

@deprecated

*/

#define CONST_CAST(type,exp) (const_cast<type>(exp))

/**

@publishedAll

@deprecated

*/

#define STATIC_CAST(type,exp) (static_cast<type>(exp))

/**

@publishedAll

@deprecated

*/

#define REINTERPRET_CAST(type,exp) (reinterpret_cast<type>(exp))

#if defined(__NO_MUTABLE_KEYWORD)

/**

@publishedAll

@deprecated

*/

#define MUTABLE_CAST(type,exp) (const_cast<type>(exp))

#else

#define MUTABLE_CAST(type,exp) (exp)

#endif

/**

@publishedAll

@deprecated

*/

#define GLREF_D extern

/**

@publishedAll

@deprecated

*/

#define GLDEF_D

/**

@publishedAll

@deprecated

*/

#define LOCAL_D static

/**

@publishedAll

@deprecated

*/

#define GLREF_C extern

/**

@publishedAll

@deprecated

*/

#define GLDEF_C

/**

@publishedAll

@deprecated

*/

#define LOCAL_C static

/**

@internalAll

@prototype

*/

#ifndef IMPORT_D

#define IMPORT_D IMPORT_C 

#endif

/**

@publishedAll

@deprecated

*/

#define FOREVER for(;;)

/**

@publishedAll

@released

Symbolic definition for a true value.

*/

#define TRUE 1

/**

@publishedAll

@released

Symbolic definition for a false value.

*/

#define FALSE 0

#ifndef NULL

/**

@publishedAll

@released

Symbolic definition for a NULL value.

*/

#define NULL 0

#endif

#ifndef VA_START

/**

@publishedAll

@released

A macro used by Symbian OS code for handling a variable argument list

in a function call.

Sets a pointer to point to the first of the variable arguments.

Typical usage:

@code

Foo(CAbcdef aAbcdef,...)

   {

   VA_LIST list;

   VA_START(list, aAbcdef);

   // other code

   } 

@endcode

@param ap   A pointer used to hold the address of an argument in

            the variable argument list. After execution of the code generated 

            by this macro, the pointer points to the first argument in

            the variable argument list.

            This symbol is usually declared as a VA_LIST type. 

@param pn   The argument that immediately precedes the variable argument list.

@see VA_LIST

@see VA_ARG

*/

#define VA_START(ap,pn) ((ap)[0]=(TInt8 *)&pn+((sizeof(pn)+sizeof(TInt)-1)&~(sizeof(TInt)-1)),(void)0)

#endif

#ifndef VA_ARG

/**

@publishedAll

@released

A macro used by Symbian OS code for handling a variable argument list

in a function call.

Increments a pointer to a variable argument list to point to the next argument

in the list. The current argument is assumed to be of a type defined by

the second parameter to this macro.

Typical usage:

@code

Foo(CAbcdef aAbcdef,...)

   {

   VA_LIST list;

   VA_START(list, aAbcdef);

   ...

   TInt x = VA_ARG(list,TInt);

   ...

   const TDesC *pS=VA_ARG(aList,const TDesC*);

   ... 

   etc

   } 

@endcode

@param ap   A pointer used to hold the address of an argument in

            the variable argument list. It is assumed to point to the current

            argument in the variable argument list. After execution of the code

            generated by this macro, the pointer points to the next argument in

            the list. This symbol is usually declared as a VA_LIST type. 

@param type The type of the current argument.

            This can be any valid type, for example, TInt, const TDesC*, etc.

@see VA_LIST

@see VA_START            

*/

#define VA_ARG(ap,type) ((ap)[0]+=((sizeof(type)+sizeof(TInt)-1)&~(sizeof(TInt)-1)),(*(type *)((ap)[0]-((sizeof(type)+sizeof(TInt)-1)&~(sizeof(TInt)-1)))))

#endif

#ifndef VA_END

/**

@publishedAll

@released

A macro used by Symbian OS code for handling a variable argument list

in a function call.

Sets a pointer to zero.

@param ap   A pointer used to hold the address of an argument in

            the variable argument list. After execution of the code generated 

            by this macro, the pointer is reset to 0.

            This symbol is usually declared as a VA_LIST type. 

@see VA_LIST

@see VA_START

@see VA_ARG            

*/

#define VA_END(ap) ((ap)[0]=0,(void)0)

#endif

/**

@publishedAll

@released

Calculates the offset of member f within class c.

This is used in the TSglQue and TDblQue constructors to set the offset of

the link object from the start of a list element.

@param c The name of the class.

@param f The name of the member within the specified class.

@see TSglQue

@see TDblQue

*/

#ifndef _FOFF

#if __GNUC__ < 4

#define _FOFF(c,f)			(((TInt)&(((c *)0x1000)->f))-0x1000)

#else

#define _FOFF(c,f)			(__builtin_offsetof(c,f))

#endif

#endif

/**

@internalTechnology

@released

*/

#define _ALIGN_DOWN(x,a)	((x)&~((a)-1))

/**

@internalTechnology

@released

*/

#define _ALIGN_UP(x,a)		_ALIGN_DOWN((x)+(a)-1, a)

/** 

@publishedAll

@released

Pointer to any type.

TAny* is equivalent to void* in standard C or C++. TAny* is used in preference 

to void* because it is more suggestive of the actual meaning,

e.g. TAny* foo();.

TAny is not used where it really means "nothing", as in the declaration of 

functions which do not return a value; void is used instead, e.g. void Foo();.

*/

typedef void TAny;

/**

@publishedAll

@released

8-bit signed integer type, used in Symbian OS to mean an 8-bit

signed integer, independent of the implementation.

*/

typedef signed char TInt8;

/**

@publishedAll

@released

8-bit unsigned integer type; used in Symbian OS to mean an 8-bit

unsigned integer, independent of the implementation.

*/

typedef unsigned char TUint8;

/**

@publishedAll

@released

16-bit signed integer type, used in Symbian OS to mean a 16-bit

signed integer, independent of the implementation.

*/

typedef short int TInt16;

/**

@publishedAll

@released

16-bit unsigned integer type. used in Symbian OS to mean a 16-bit

unsigned integer, independent of the implementation.

*/

typedef unsigned short int TUint16;

/**

@publishedAll

@released

32-bit signed integer type, used in Symbian OS to mean a 32-bit

signed integer, independent of the implementation.

*/

typedef long int TInt32;

/**

@publishedAll

@released

A signed integer type of the same size as a pointer.

*/

typedef TInt32 T_IntPtr;

typedef TInt32 TIntPtr;

/**

@publishedAll

@released

32-bit unsigned integer type; used in Symbian OS to mean a 32-bit

unsigned integer, independent of the implementation.

*/

typedef unsigned long int TUint32;

/**

@publishedAll

@released

An unsigned integer type of the same size as a pointer.

*/

typedef TUint32 T_UintPtr;

typedef TUint32 TUintPtr;

/**

@publishedAll

@released

Signed integer type of the natural machine word length.

This is as defined by the C++ implementation's int type. In all

implementations, this is guaranteed to be at least 32 bits.

A TInt should be used in preference to a sized integer (TInt32, TInt16) for 

all general use. Sized integers should only be used when packing is essential. 

C++'s type conversion rules imply that all sized integers smaller than the 

natural machine word are in any case broadened to the natural machine word 

size when passed as function parameters.

A TInt should be used in preference to an unsigned integer (TUint) for all 

general use. Unsigned integers should only be used for flags (which use Boolean 

operations but not arithmetic) and, in very rare cases, for numbers whose 

range exceeds that available from signed integers. Although it is natural 

to attempt to use unsigned integers for quantities which cannot by nature 

be negative, the C++ language does not provide the support necessary to enforce 

the "expected" behaviour in these circumstances, and experience has shown 

that it is better to use signed integers unless there is good reason not to.

@see TUint

@see TInt32

@see TInt16

*/

typedef signed int TInt;

/**

@publishedAll

@released

Unsigned integer type of the natural machine word length. 

This is guaranteed to be at least 32 bits in all implementations.

In almost all circumstances, a TInt should be used in preference to a TUint. 

The main exception is in flags bytes.

@see TInt

*/

typedef unsigned int TUint;

/**

@publishedAll

@released

32-bit floating point number, providing IEEE754 single precision on all Symbian 

OS implementations.

TReal should normally be used in preference to TReal32.

Use of floating-point numbers should generally be avoided unless a natural 

part of the problem specification. Most Symbian OS implementations do not 

have a hardware floating point unit: as a result, their floating-point performance 

is hundreds of times slower than integer performance.

*/

typedef float TReal32;

/**

@publishedAll

@released

64-bit floating point number, providing IEEE754 double precision on all Symbian 

OS implementations.

Use of floating-point numbers should generally be avoided unless a natural 

part of the problem specification. Most Symbian OS implementations do not 

have a hardware floating point unit: as a result, their floating-point performance 

is hundreds of times slower than integer performance.

This type is identical to TReal.

@see TReal

*/

typedef double TReal64;

/**

@publishedAll

@released

64-bit floating point number; identical to TReal64.

Use of floating-point numbers should generally be avoided unless a natural 

part of the problem specification. Most Symbian OS implementations do not 

have a hardware floating point unit: as a result, their floating-point performance 

is hundreds of times slower than integer performance.

Most serious floating-point calculations require double-precision. All standard 

math functions (see Math class) take double-precision arguments. Single-precision 

should only be used where space and performance are at a premium, and when 

their limited precision is acceptable.

@see TReal64

@see Math

*/

typedef double TReal;

/**

@publishedAll

@released

8-bit unsigned character.

Use instead of C++ built-in char type because it is guaranteed to be unsigned. 

Use instead of TInt8 where the application is really for text rather than 

8-bit arithmetic or binary quantities.

For most purposes, you should use TText rather than TText8. TText is mapped 

onto either TText8 or TText16 depending on whether a non-Unicode or Unicode 

variant is being built. Use TText8 only when you are dealing explicitly with 

8-bit text, regardless of build.

@see TText */

typedef unsigned char TText8;

/**

@publishedAll

@released

16-bit unsigned character.

Use instead of C++ wchar_t type because it is guaranteed to be unsigned. Use 

instead of TInt16 where the application is really for text rather than 8-bit 

arithmetic or binary quantities.

For most purposes, you should use TText rather than TText16. TText is mapped 

onto either TText8 or TText16 depending on whether a non-Unicode or Unicode 

variant is being built. Use TText16 only when you are dealing explicitly with 

16-bit text, regardless of build.

@see TText

*/

typedef unsigned short int TText16;

/**

@publishedAll

@released

Boolean type which takes the value either ETrue or EFalse.

Although only a single bit would theoretically be necessary to represent a 

Boolean, a machine word is used instead, so that these quantities can be easily 

passed. Also, TBool must map onto int because of C++'s interpretation of 

operands in conditional expressions.

*/

typedef int TBool;

/**

@publishedPartner

@released

Defines a linear (virtual) address type.

*/

typedef T_UintPtr TLinAddr;

#if defined(__GCC32__)

/**

@publishedAll

@released

Defines a 64-bit signed integer type.

*/

typedef long long Int64;

/**

@publishedAll

@released

Defines a 64-bit unsigned integer type.

*/

typedef unsigned long long Uint64;

/**

@publishedAll

@released

*/

#define	I64LIT(x)	x##LL

/**

@publishedAll

@released

*/

#define	UI64LIT(x)	x##ULL

#elif defined(__VC32__)

typedef __int64 Int64;

typedef unsigned __int64 Uint64;

#define	I64LIT(x)	(__int64)##x

#define	UI64LIT(x)	(unsigned __int64)##x

#elif defined(__CW32__)

#pragma longlong on

typedef long long Int64;

typedef unsigned long long Uint64;

#define	I64LIT(x)	x##LL

#define	UI64LIT(x)	x##ULL

#endif

/**

@publishedAll

@released

Defines a 64-bit signed integer type.

NOTE: For those migrating from versions of Symbian OS before 8.1b (i.e. 8.1a, 7.0s etc)

TInt64 is now defined as a built-in type instead of as a class type. This means

that the member functions of the old TInt64 class are no longer exported

from EUSER.LIB, and represents a compatibility break.

To ease migration of source code, a number of macros are provided. Similar

macros have also been defined in Symbian OS versions 7.0s and 8.1a, but

implemented in terms of the old TInt64 class. This is important for code that

is common to : one or both of these Symbian OS versions, and to 8.1b and

subsequent versions.

The following list shows the new macros and the functions that they replace.

It also shows some alternative techniques.

In this list: x, v and r are declared as TInt64, c is declared as TInt, High

and Low are declared as TUint.

@code

OLD USAGE						REPLACEMENT

TInt64(High,Low);				MAKE_TINT64(High,Low);

x.Set(High,Low);				MAKE_TINT64(High,Low);

x.Low();						I64LOW(x);

x.High();						I64HIGH(x); 

x.GetTInt();					I64INT(x); 

x.GetTReal();					I64REAL(x); 

x.Lsr(c);						I64LSR(x,c); 

x.Mul10();						x*=10; 

x.MulTop(a);					I64MULTOP(x,a); 

x.DivMod(v,r);					r=x%v; x/=v;

@endcode 

*/

typedef	Int64	TInt64;

/**

@publishedAll

@released

Defines a 64-bit unsigned integer type.

*/

typedef	Uint64	TUint64;

/** @internalComponent */

#define _MAKE_TINT64_ZX(x)	((TInt64)((TUint32)(x)))

/** @internalComponent */

#define _MAKE_TUINT64_ZX(x)	((TUint64)((TUint32)(x)))

/**

@publishedAll

@released

*/

#define MAKE_TINT64(h,l)	( (_MAKE_TINT64_ZX(h)<<32) | _MAKE_TINT64_ZX(l) )

/**

@publishedAll

@released

*/

#define MAKE_TUINT64(h,l)	( (_MAKE_TUINT64_ZX(h)<<32) | _MAKE_TUINT64_ZX(l) )

/**

@publishedAll

@released

Generates code to access the high order 32 bits of a 64 bit number.

*/

#define	I64HIGH(x)			( (TUint32)((x)>>32) )

/**

@publishedAll

@released

Generates code to access the low order 32 bits of a 64 bit number.

*/

#define	I64LOW(x)			( (TUint32)(x) )

/**

@publishedAll

@released

Generates code to cast a 64 bit value as an signed integer.

*/

#define	I64INT(x)			( (TInt)(x) )

/**

@publishedAll

@released

Generates code to cast a 64 bit value as a TReal type.

*/

#define	I64REAL(x)			( (TReal)(x) )

/**

@publishedAll

@released

Generates code to logically shift a 64 bit integer right.

*/

#define	I64LSR(x, shift)	( *reinterpret_cast<TUint64*>(&(x)) >>= (shift) )

/**

@publishedAll

@released

Generates code to multiply a 64 bit integer by 10.

*/

#define	I64MUL10(x)			( (x) *= 10 )

/**

@publishedAll

@released

Generates code to divide a 64 bit integer by another and find the remainder.

*/

#define	I64DIVMOD(x, divisor, remainder)	( ((remainder) = (x) % (divisor), (x) /= (divisor)) )

/**

@publishedAll

@released

Generates code to cast a double to a 64 bit integer.

*/

#define	I64DOUBLECAST(x)	( static_cast<TInt64>(x) )

/**

@publishedAll

@deprecated Use _LIT8 instead.

8-bit literal.