diff --git a/.gitattributes b/.gitattributes index 9b165644a0..71424c39fb 100644 --- a/.gitattributes +++ b/.gitattributes @@ -5257,6 +5257,8 @@ rtl/symbian/Makefile svneol=native#text/plain rtl/symbian/Makefile.fpc svneol=native#text/plain rtl/symbian/bindings/pbeexe.cpp -text rtl/symbian/buildrtl.pp -text +rtl/symbian/e32def.inc -text +rtl/symbian/e32err.inc -text rtl/symbian/symbian.pas -text rtl/symbian/sysdir.inc svneol=native#text/plain rtl/symbian/sysfile.inc svneol=native#text/plain diff --git a/rtl/symbian/bindings/pbeexe.cpp b/rtl/symbian/bindings/pbeexe.cpp index 74706bb73b..9d32c8afa6 100644 --- a/rtl/symbian/bindings/pbeexe.cpp +++ b/rtl/symbian/bindings/pbeexe.cpp @@ -1,30 +1,59 @@ -// pbeexe.cpp +/* + This file is part of the Free Pascal run time library. + Copyright (c) 2007 by contributors of the Free Pascal Compiler + + pbeexe.cpp + + This file is part of the Pascal interface for the c++ API on Symbian OS + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************/ #include +#include extern "C" { /* Pascal Entry point declaration */ -int Pascal_E32Main(); +long int Pascal_E32Main(); -/* class User : public UserHeap */ +/******************************************************************* +* File e32std.h +*******************************************************************/ -/* User::InfoPrint */ -void User_InfoPrint() +/******************************************************************* +* Class User +*******************************************************************/ + +/******************************************************************* +* User::InfoPrint +*******************************************************************/ +TInt User_InfoPrint(const char* aString) { - // Define a non-modifiable compile time allocated - // descriptor (Symbian OS string) - _LIT(KQHelloWorldString, "My Hello World"); - // show an indication - User::InfoPrint(KQHelloWorldString); + TPtrC8 pStr(reinterpret_cast(aString)); + HBufC* buf = HBufC::New(pStr.Length()); + if (buf == NULL) + { + return KErrNoMemory; + } + buf->Des().Copy(pStr); + User::InfoPrint(*buf); + return KErrNone; } -} -/* Symbian OS Entry Point */ +} /* extern "C" */ + +/******************************************************************* +* Symbian OS Entry Point +*******************************************************************/ TInt E32Main() { - Pascal_E32Main(); - - return KErrNone; + return Pascal_E32Main(); } diff --git a/rtl/symbian/e32def.inc b/rtl/symbian/e32def.inc new file mode 100644 index 0000000000..b6e679e513 --- /dev/null +++ b/rtl/symbian/e32def.inc @@ -0,0 +1,2865 @@ +{%MainUnit symbian.pas} + +{ + This file is part of the Free Pascal run time library. + Copyright (c) 2007 by contributors of the Free Pascal Compiler + + This file is a pascal translation of the Symbian OS headers + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +{ e32\include\e32def.h + * + * Copyright (c) Symbian Software Ltd 1994-2005. All rights reserved. + * + * NOTE: THIS FILE SHOULD BE ACCEPTABLE TO A C COMPILER + } + +{ + * __LEAVE_EQUALS_THROW__ requires the compiler to support C++ exceptions + } +{#ifndef __SUPPORT_CPP_EXCEPTIONS__ +#undef __LEAVE_EQUALS_THROW__ +#endif} + + + + + +{#ifdef __PROFILING__ + +/** +@publishedPartner +@removed +*/ +#define __PROFILE_START(aBin) RDebug::ProfileStart(aBin) + +/** +@publishedPartner +@removed +*/ +#define __PROFILE_END(aBin) RDebug::ProfileEnd(aBin) + +/** +@publishedPartner +@removed +*/ +#define __PROFILE_RESET(aNumberOfBins) RDebug::ProfileReset(0,aNumberOfBins) + +/** +@publishedPartner +@removed +*/ +#define __PROFILE_DISPLAY(aNumberOfBins) \ + begin TFixedArray result; \ + RDebug::ProfileResult(result.Begin(), 0, aNumberOfBins); \ + for (TInt i=0; i= 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 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 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} + + + +{#if defined(__GCC32__) +#define __NO_CLASS_CONSTS__ +#define __NORETURN__ __attribute__ ((noreturn)) +#ifdef __GCCV3__ +#define __NORETURN_TERMINATOR() +#else +#define __NORETURN_TERMINATOR() abort() +#endif +#define IMPORT_C +#if !defined __WINS__ && defined _WIN32 /* VC++ Browser Hack */ +#define EXPORT_C +/** @internalTechnology */ +#define asm(x) +#else +#define EXPORT_C __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 +#endif} + + + +{#ifdef __GCC32__ +/** +@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(exp)) + +/** +@publishedAll +@deprecated +*/ +#define STATIC_CAST(type,exp) (static_cast(exp)) + +/** +@publishedAll +@deprecated +*/ +#define REINTERPRET_CAST(type,exp) (reinterpret_cast(exp)) + +#if defined(__NO_MUTABLE_KEYWORD) +/** +@publishedAll +@deprecated +*/ +#define MUTABLE_CAST(type,exp) (const_cast(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 +/** +@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 +*/ +#define _FOFF(c,f) (((TInt)&(((c *)0x1000)->f))-0x1000) + + + +/** +@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();. +} +type TAny = Pointer; + + + + +{ +@publishedAll +@released + +8-bit signed integer type, used in Symbian OS to mean an 8-bit +unsigned integer, independent of the implementation. +} +type TInt8 = Byte; + + + + +{ +@publishedAll +@released + +8-bit unsigned integer type; used in Symbian OS to mean an 8-bit +unsigned integer, independent of the implementation. +} +type TUint8 = Char; + + + + +{ +@publishedAll +@released + +16-bit signed integer type, used in Symbian OS to mean a 16-bit +unsigned integer, independent of the implementation. +} +type TInt16 = ShortInt; + + + + +{ +@publishedAll +@released + +16-bit unsigned integer type. used in Symbian OS to mean a 16-bit +unsigned integer, independent of the implementation. +} +type TUint16 = Word; + + + + +{ +@publishedAll +@released + +32-bit signed integer type, used in Symbian OS to mean a 32-bit +unsigned integer, independent of the implementation. +} +type TInt32 = Integer; + + + + +{ +@publishedAll +@released + +32-bit unsigned integer type; used in Symbian OS to mean a 32-bit +unsigned integer, independent of the implementation. +} +type TUint32 = Cardinal; + + + + +{ +@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 +} +type TInt = cint; + + + + +{ +@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 +} +type TUint = cuint; + + + + +{ +@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. +} +//type 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 +} +//type 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 +} +//type 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 } +type TText8 = Char; + + + + +{ +@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 +} +type TText16 = Word; + + + + +{ +@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. + +On implementations of Symbian OS in which the compiler supports the ANSI-recommended +bool type, TBool will be type'ed to bool instead of int. +} +//type int TBool; + + + + +{ +@publishedPartner +@released + +Defines a linear (virtual) address type. +} +type TLinAddr = TUint32; + +{ +@internalTechnology + +A sorted list of all the code segments in ROM that contain an Exception Descriptor. + +} +type + TRomExceptionSearchTable = record + { + The number of entries in the following table. + } + iNumEntries: TInt32; + + { + Address of the code segment of each TRomImageHeader that has an Exception Descriptor. + } + iEntries: array[0..0] of TLinAddr; + end; + +{ +@internalComponent +} +{type + TExceptionDescriptor = record + TLinAddr iExIdxBase; + TLinAddr iExIdxLimit; + TLinAddr iROSegmentBase; + TLinAddr iROSegmentLimit; + end;} + + +{$if defined(__GCC32__)} + + + + +{ +@publishedAll +@released + +Defines a 64-bit signed integer type. +} +//type Int64; + + + + +{ +@publishedAll +@released + +Defines a 64-bit unsigned integer type. +} +//type unsigned long long Uint64; + + + + +{ +@publishedAll +@released +} +#define I64LIT(x) x##LL +{ +@publishedAll +@released +} +#define UI64LIT(x) x##ULL + +#elif defined(__VC32__) +type __int64 Int64; +type unsigned __int64 Uint64; +#define I64LIT(x) (__int64)##x +#define UI64LIT(x) (unsigned __int64)##x + +#elif defined(__CW32__) +#pragma longlong on +type long long Int64; +type 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 +} +type TInt64 = Int64; + + + + +{ +@publishedAll +@released + +Defines a 64-bit unsigned integer type. +} +//type 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(&(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(x) ) + + + + +{ +@publishedAll +@deprecated Use _LIT8 instead. + +8-bit literal. + +The macro defines an explicit 8-bit constant literal which is suitable +for non-Unicode literal text, regardless of the build. + +@see _L +@see _LIT8 +@see _LIT +} +//#define _L8(a) (TPtrC8((const TText8 *)(a))) + + + + +{ +@publishedAll +@released + +Defines an explicit 8-bit string which is suitable when non-Unicode text +is required, regardless of the build. + +This is used by the deprecated literal descriptor _L8. +} +//#define _S8(a) ((const TText8 *)a) + + + + +{ +@publishedAll +@released + +Constructs a constant literal descriptor of type TLitC8 with +the specified name and text. + +The 8-bit build variant is generated for both non-Unicode and Unicode builds. + +@param name The name of the C++ variable to be generated. +@param s The literal text enclosed within a pair of double quotes. + +@see _LIT +} +//#define _LIT8(name,s) const static TLitC8 name={sizeof(s)-1,s} + + + + +{ +@publishedAll +@deprecated Use _LIT16 instead. + +16-bit literal. + +The macro defines an explicit 16-bit constant literal which is suitable +for Unicode literal text, regardless of the build. + +@see _L +@see _LIT16 +@see _LIT +} +//#define _L16(a) (TPtrC16((const TText16 *)L ## a)) + + + +{ +@publishedAll +@released + +Defines an explicit 16-bit string which is suitable when Unicode text +is required, regardless of the build. + +This is used by the deprecated literal descriptor _L16. +} +//#define _S16(a) ((const TText16 *)L ## a) + + + + +{ +@publishedAll +@released + +Constructs a constant literal descriptor of type TLitC16 with +the specified name and text. + +The 16-bit build variant is generated for both non-Unicode and Unicode builds. + +@param name The name of the C++ variable to be generated. +@param s The literal text enclosed within a pair of double quotes. + +@see _LIT +} +//#define _LIT16(name,s) const static TLitC16 name={sizeof(L##s)/2-1,L##s} + + + + +{$if defined(_UNICODE) and not defined(__KERNEL_MODE__)} +{ +@publishedAll +@released + +Build independent general text character. + +In non-Unicode builds, this is mapped to TText8. In Unicode builds, this is +mapped to TText16. Use the classes with explicit width only when you wish +the width to be independent of the build variant. + +Use this class rather than TChar for general use. +} +type TText16 TText; + + + +{ +@publishedAll +@deprecated Use _LIT instead. + +Build independent literal. + +The macro defines either an 8-bit constant literal (for non-Unicode text), +or a 16-bit constant literal (for Unicode text) depending on the build. + +@see _LIT +@see _L16 +@see _L8 +} +#define _L(a) (TPtrC((const TText *)L ## a)) + + + + +{ +@publishedAll +@released + +Defines either an 8-bit string (for non-Unicode text), +or a 16-bit string (for Unicode text) depending on the build. + +This is used by the deprecated build independent literal _L. +} +#define _S(a) ((const TText *)L ## a) + + + + +{ +@publishedAll +@released + +Constructs a build independent constant literal descriptor of type TLitC +with the specified name and text. + +An 8-bit build variant is generated for a non-Unicode build; +A 16-bit build variant is generated for a Unicode build. + +@param name The name of the C++ variable to be generated. +@param s The literal text enclosed within a pair of double quotes. + +@see _LIT16 +@see _LIT8 +} +#define _LIT(name,s) const static TLitC name={sizeof(L##s)/2-1,L##s} + + + + +{$else} +{ +@publishedAll +@released + +Build independent general text character. + +In non-Unicode builds, this is mapped to TText8. In Unicode builds, this is +mapped to TText16. Use the classes with explicit width only when you wish +the width to be independent of the build variant. + +Use this class rather than TChar for general use. +} +type TText = TText8; + + + +{ +@publishedAll +@released + +@deprecated Use _LIT instead. + +Build independent literal. + +The macro defines either an 8-bit constant literal (for non-Unicode text), +or a 16-bit constant literal (for Unicode text) depending on the build. + +@see _LIT +@see _L16 +@see _L8 +} +//#define _L(a) (TPtrC((const TText *)(a))) + + + + +{ +@publishedAll +@released + +Defines either an 8-bit string (for non-Unicode text), +or a 16-bit string (for Unicode text) depending on the build. + +This is used by the deprecated build independent literal _L. +} +//#define _S(a) ((const TText *)a) + + + + +{ +@publishedAll +@released + +Constructs a build independent constant literal descriptor of type TLitC +with the specified name and text. + +An 8-bit build variant is generated for a non-Unicode build; +A 16-bit build variant is generated for a Unicode build. + +@param name The name of the C++ variable to be generated. +@param s The literal text enclosed within a pair of double quotes. + +@see _LIT16 +@see _LIT8 +} +//#define _LIT(name,s) const static TLitC name={sizeof(s)-1,s} +{$endif} + + + + +{$ifndef __VA_LIST_defined} +{ +@publishedAll +@released + +Defines a 'C' style array of pointers to TInt8 types. + +The type is most commonly used by code that needs to deal with a variable +number of arguments passed to a function. + +@see TInt8 +} +//type TInt8 *VA_LIST[1]; +{$endif} + +{ +@publishedAll +@released + +Asserts that a condition is true. + +Code is generated for all builds. + +This macro is used as a C++ statement to assert the truth of some condition, +and to take appropriate action if the condition is false. Unlike __ASSERT_DEBUG +it is defined in both release and debug builds. + +The most common use for this macro is to check that the external environment of +a function or class is behaving as expected; for example, that parameters +passed to a function are credible, or that called functions are behaving as +expected; the macro is commonly placed at the beginning of a function. + +The effect of the macro is to generate code which tests +the conditional expression c; if the expression is false, then +function p is called. In the majority of cases, the function p is one that +raises a panic. + +Note that the macro definition is, in effect, equivalent to: + +@code +if !(c)p; +@endcode + +@param c a conditional expression which results in true or false. +@param p a function which is called if the conditional expression c is false. + +@see __ASSERT_DEBUG +} +//#define __ASSERT_ALWAYS(c,p) (void)((c)||(p,0)) + + + +//#ifdef __WINS__ +//#ifdef __CW32__ +{ +@internalAll +@released +} +//#define __BREAKPOINT() \ +// { \ +// __asm { byte 0xcc }; \ +// } +//#else //!__CW32__ +{ +@internalAll +@released +} +//#define __BREAKPOINT() \ +// { \ +// __asm { int 3 }; \ +// } +//#endif //__CW32__ +//#else +{ +@internalAll +@released +} +//#define __BREAKPOINT() +//#endif + +//#if defined(_DEBUG) + +{ +@internalComponent +@deprecated +} +//#define __ASSERT_DEBUG_MB(aCond,aPanicNo) (void)((aCond)||(PanicMB(aPanicNo,_L(#aPanicNo),_L(#aCond)),0)) + + + + +{ +@publishedAll +@released + +Asserts that a condition is true. + +Code is generated for debug builds only. + +This macro is used as a C++ statement to assert the truth of some condition, +and to take appropriate action if the condition is false. It is used in +the same way as __ASSERT_ALWAYS, except that it is only defined for debug builds. + +The macro may be used to insert extra checks at various points in source code +as desired; the code will only be generated in debug builds and not in release +builds. + +@param c A conditional expression which results in true or false. +@param p A function which is called if the conditional expression c is false. + +@see __ASSERT_ALWAYS +} +//#define __ASSERT_DEBUG(c,p) (void)((c)||(p,0)) + + + +{ +@internalAll +@removed +} +//#define __DECLARE_NAME(t) + + + + +{ +@publishedAll +@released + +Calls the function for testing object invariance. + +Classes can define a standard member function __DbgTestInvariant(), +which checks that the object is in a valid state, and panics if it is not. +In debug builds, this macro simply expands to call that function. For details on how +to define __DbgTestInvariant(), and an example of its use, see __DECLARE_TEST. + +The macro is typically invoked at the beginning of all the member functions of +the class. For non-const functions (those which can change the object’s state), +you can ensure that the object has been left in a stable state by invoking +the macro at the end of the function. + +In release builds, no code is generated for the macro. +} +//#define __TEST_INVARIANT __DbgTestInvariant() + + + + +{ +@publishedAll +@released + +Marks the start of checking the current thread's heap. + +This macro is defined only for debug builds. + +This macro must be matched by a corresponding call to __UHEAP_MARKEND or __UHEAP_MARKENDC. + +Calls to this macro can be nested but each call must be matched by corresponding +call to __UHEAP_MARKEND or __UHEAP_MARKENDC. + +@see User::__DbgMarkStart() +@see __UHEAP_MARKEND +@see __UHEAP_MARKENDC +} +//#define __UHEAP_MARK User::__DbgMarkStart(FALSE) + + + + +{ +@publishedAll +@released + +Checks that the number of allocated cells at the current nested level on the +current thread's heap is the same as the specified value. + +This macro is defined only for debug builds. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +The macro assumes that: + +1. the heap being checked is a user heap + +2. checking is being done for the number of allocated cells at the current nested + level; i.e. that aCountAll is set to false + +3. the line number is the line number of this source code statement. + +4. the file name is the full path name of the file containing this source statement + +@param aCount The number of heap cells expected to be allocated at + the current nest level. + +@see User::__DbgMarkCheck() +@see __KHEAP_CHECK +} +//#define __UHEAP_CHECK(aCount) User::__DbgMarkCheck(FALSE,FALSE,aCount,(TText8*)__FILE__,__LINE__) + + + + +{ +@publishedAll +@released + +Checks that the total number of allocated cells on the current thread's heap +is the same as the specified value. + +This macro is defined only for debug builds. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +@param aCount The total number of heap cells expected to be allocated. + +@see User::__DbgMarkCheck() +@see __KHEAP_CHECKALL +} +//#define __UHEAP_CHECKALL(aCount) User::__DbgMarkCheck(FALSE,TRUE,aCount,(TText8*)__FILE__,__LINE__) + + + + +{ +@publishedAll +@released + +Marks the end of checking the current thread's heap. + +The macro expects zero heap cells to remain allocated at the current nest +level. This macro is defined only for debug builds. + +This macro must match an earlier call to __UHEAP_MARK. + +@see User::__DbgMarkEnd() +@see __UHEAP_MARK +} +//#define __UHEAP_MARKEND User::__DbgMarkEnd(FALSE,0) + + + + +{ +@publishedAll +@released + +Marks the end of checking the current thread's heap. + +The macro expects aCount heap cells to remain allocated at the current nest +level. + +This macro must match an earlier call to __UHEAP_MARK. + +@param aCount The number of heap cells expected to remain allocated at + the current nest level. + +@see User::__DbgMarkEnd() +@see __UHEAP_MARK +} +//#define __UHEAP_MARKENDC(aCount) User::__DbgMarkEnd(FALSE,aCount) + + + + +{ +@publishedAll +@released + +Simulates heap allocation failure for the current thread's heap. + +The failure occurs on the next call to new or any of the functions which +allocate memory from the heap. This macro is defined only for debug builds. + +@param aCount Determines when the allocation will fail. + Heap allocation fails on attempt number aCount - later + allocations will succeed. + For example, if aCount is 3, then heap allocation fails + on the 3rd attempt, but all subsequent allocations succeed. + +@see User::__DbgSetAllocFail() +} +//#define __UHEAP_FAILNEXT(aCount) User::__DbgSetAllocFail(FALSE,RAllocator::EFailNext,aCount) + + + + +{ +@publishedAll +@released + +Simulates heap allocation failure for the current thread's heap. + +The failure occurs on subsequent calls to new or any of the functions which +allocate memory from the heap. This macro is defined only for debug builds. + +@param aType The type of failure to be simulated. +@param aValue The failure rate. + +@see User::__DbgSetAllocFail() +} +//#define __UHEAP_SETFAIL(aType,aValue) User::__DbgSetAllocFail(FALSE,aType,aValue) + + + + +{ +@publishedAll +@released + +Cancels simulated heap allocation failure for the current thread's heap. + +This macro is defined only for debug builds. + +@see User::__DbgSetAllocFail() +} +//#define __UHEAP_RESET User::__DbgSetAllocFail(FALSE,RAllocator::ENone,1) + + +{ +@publishedAll +@released + +Cancels simulated heap allocation failure for the current thread's heap. +It walks the the heap and sets the nesting level for all allocated +cells to zero. + +This macro is defined only for debug builds. +} +//#define __UHEAP_TOTAL_RESET User::__DbgSetAllocFail(FALSE,RAllocator::EReset,1) + + + +{ +@publishedPartner +@released + +Marks the start of Kernel heap checking. + +Checking the Kernel heap is only useful when developing Kernel side code such +as device drivers and media drivers. + +This macro is defined only for debug builds. + +This macro must be matched by a corresponding call to __KHEAP_MARKEND or __KHEAP_MARKENDC. +Calls to this macro can be nested but each call must be matched by corresponding +call to __KHEAP_MARKEND or __KHEAP_MARKENDC. + +@see User::__DbgMarkStart() +@see __KHEAP_MARKEND +@see __KHEAP_MARKENDC +} +//#define __KHEAP_MARK User::__DbgMarkStart(TRUE) + + + + +{ +@publishedPartner +@released + +Checks that the number of allocated cells at the current nested level of the +Kernel heap is the same as the specified value. This macro is defined only +for debug builds. Checking the Kernel heap is only useful when developing +Kernel side code such as device drivers and media drivers. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +@param aCount The number of heap cells expected to be allocated at + the current nest level. + +@see User::__DbgMarkCheck() +@see __UHEAP_CHECK +} +//#define __KHEAP_CHECK(aCount) User::__DbgMarkCheck(TRUE,FALSE,aCount,(TText8*)__FILE__,__LINE__) + + + + +{ +@publishedPartner +@released + +Checks that the total number of allocated cells on the Kernel heap is the same +as the specified value. + +It is only useful when developing Kernel side code such as device drivers +and media drivers. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +This macro is defined only for debug builds. + +@param aCount The total number of heap cells expected to be allocated + +@see User::__DbgMarkCheck() +@see __UHEAP_CHECKALL +} +//#define __KHEAP_CHECKALL(aCount) User::__DbgMarkCheck(TRUE,TRUE,aCount,(TText8*)__FILE__,__LINE__) + + + + +{ +@publishedPartner +@released + +Marks the end of Kernel heap checking. The macro expects zero heap cells to +remain allocated at the current nest level. + +This macro is defined only for debug builds. Checking the Kernel heap is only +useful when developing Kernel side code such as device drivers and media drivers. + +This macro must match an earlier call to __KHEAP_MARK. + +@see User::__DbgMarkEnd() +@see __KHEAP_MARK +} +//#define __KHEAP_MARKEND User::__DbgMarkEnd(TRUE,0) + + + + +{ +@publishedPartner +@released + +Marks the end of Kernel heap checking. The macro expects aCount heap cells +to remain allocated at the current nest level. + +This macro is defined only for debug builds. + +This macro must match an earlier call to __KHEAP_MARK. + +@param aCount The number of heap cells expected to remain allocated at + the current nest level. + +@see User::__DbgMarkEnd() +@see __KHEAP_MARK +} +//#define __KHEAP_MARKENDC(aCount) User::__DbgMarkEnd(TRUE,aCount) + + + + +{ +@publishedPartner +@released + +Simulates Kernel heap allocation failure. The failure occurs on the next call +to new or any of the functions which allocate memory from the heap. This macro +is defined only for debug builds. + +Checking the Kernel heap is only useful when developing Kernel side code such +as device drivers and media drivers. + +@param aCount The rate of failure - heap allocation fails every aCount attempt. + +@see User::__DbgSetAllocFail() +} +//#define __KHEAP_FAILNEXT(aCount) User::__DbgSetAllocFail(TRUE,RAllocator::EFailNext,aCount) + + + + +{ +@publishedPartner +@released + +Simulates Kernel heap allocation failure. + +The failure occurs on subsequent calls to new or any of the functions which +allocate memory from this heap. + +This macro is defined only for debug builds. + +@param aType The type of failure to be simulated. +@param aValue The failure rate. + +@see User::__DbgSetAllocFail() +} +//#define __KHEAP_SETFAIL(aType,aValue) User::__DbgSetAllocFail(TRUE,aType,aValue) + + + + +{ +@publishedPartner +@released + +Cancels simulated Kernel heap allocation failure. + +Checking the Kernel heap is only useful when developing Kernel side code such +as device drivers and media drivers. + +This macro is defined only for debug builds. + +@see User::__DbgSetAllocFail() +} +//#define __KHEAP_RESET User::__DbgSetAllocFail(TRUE,RAllocator::ENone,1) + + + + +{ +@publishedPartner +@released + +Cancels simulated kernel heap allocation failure. +It walks the the heap and sets the nesting level for all allocated +cells to zero. + +Checking the kernel heap is only useful when developing kernel side code such +as device drivers and media drivers. + +This macro is defined only for debug builds. +} +//#define __KHEAP_TOTAL_RESET User::__DbgSetAllocFail(TRUE,RAllocator::EReset,1) + + + + +{ +@publishedAll +@released + +Marks the start of heap checking for the specific heap. + +This macro is defined only for debug builds. + +This macro must be matched by a corresponding call to __RHEAP_MARKEND or __RHEAP_MARKENDC. + +Calls to this macro can be nested but each call must be matched by corresponding +call to __RHEAP_MARKEND or __RHEAP_MARKENDC. + +@param aHeap A pointer to the specific RHeap + +@see RHeap +@see RAllocator::__DbgMarkStart() +@see __RHEAP_MARKEND +@see __RHEAP_MARKENDC +} +//#define __RHEAP_MARK(aHeap) (aHeap)->__DbgMarkStart() + + + + +{ +@publishedAll +@released + +Checks that the number of allocated cells at the current nested level on the +specified heap is the same as the specified value. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. +@param aCount The number of heap cells expected to be allocated at + the current nest level. + +@see RAllocator::__DbgMarkCheck() +} +//#define __RHEAP_CHECK(aHeap,aCount) (aHeap)->__DbgMarkCheck(FALSE,aCount,(TText8*)__FILE__,__LINE__) + + + + +{ +@publishedAll +@released + +Checks that the total number of allocated cells on the specified heap is the +same as the specified value. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. +@param aCount The total number of heap cells expected to be allocated. + +@see RAllocator::__DbgMarkCheck() +} +//#define __RHEAP_CHECKALL(aHeap,aCount) (aHeap)->__DbgMarkCheck(TRUE,aCount,(TText8*)__FILE__,__LINE__) + + + + +{ +@publishedAll +@released + +Marks the end of heap checking for the specific heap. + +The macro expects zero heap cells to remain allocated at the current nest +level. This macro is defined only for debug builds. + +This macro must match an earlier call to __RHEAP_MARK. + +@param aHeap A pointer to the specific RHeap. + +@see RAllocator::__DbgMarkEnd() +@see __RHEAP_MARK +} +//#define __RHEAP_MARKEND(aHeap) (aHeap)->__DbgMarkEnd(0) + + + + +{ +@publishedAll +@released + +Marks the end of heap checking for the specific heap. + +The macro expects aCount heap cells to remain allocated at the current nest +level. This macro is defined only for debug builds. + +This macro must match an earlier call to __RHEAP_MARK. + +@param aHeap A pointer to the specific RHeap. +@param aCount The number of heap cells expected to remain allocated at + the current nest level + +@see RAllocator::__DbgMarkEnd() +@see __RHEAP_MARK +} +//#define __RHEAP_MARKENDC(aHeap,aCount) (aHeap)->__DbgMarkEnd(aCount) + + + + +{ +@publishedAll +@released + +Simulates an allocation failure for the specific heap. + +The failure occurs on the next call to new or any of the functions which allocate +memory from the heap. This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. +@param aCount The rate of failure - heap allocation fails every aCount attempt. + +@see RAllocator::__DbgSetAllocFail() +} +//#define __RHEAP_FAILNEXT(aHeap,aCount) (aHeap)->__DbgSetAllocFail(RAllocator::EFailNext,aCount) + + + + +{ +@publishedAll +@released + +Simulates an allocation failure for the specific heap. + +The failure occurs on subsequent calls to new or any of the functions which +allocate memory from the heap. This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. +@param aType The type of failure to be simulated. +@param aValue The failure rate. + +@see RAllocator::__DbgSetAllocFail() +} +//#define __RHEAP_SETFAIL(aHeap,aType,aValue) (aHeap)->__DbgSetAllocFail(aType,aValue) + + + + +{ +@publishedAll +@released + +Cancels simulated allocation failure for the specific heap. + +This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. + +@see RAllocator::__DbgSetAllocFail() +} +//#define __RHEAP_RESET(aHeap) (aHeap)->__DbgSetAllocFail(RAllocator::ENone,1) + + + +{ +@publishedAll +@released + +Cancels simulated allocation failure for the specific heap. +It walks the the heap and sets the nesting level for all allocated +cells to zero. + +This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. + +@see RAllocator::__DbgSetAllocFail() +} +//#define __RHEAP_TOTAL_RESET(aHeap) (aHeap)->__DbgSetAllocFail(RAllocator::EReset,1) + + + + +//#if defined (__WINS__) + +{ +@publishedAll +@released +} +//#define __DEBUGGER() {if (User::JustInTime()) __BREAKPOINT()} + +//#else +//#define __DEBUGGER() +//#endif + + +//#if defined(__DLL__) +{ +@publishedAll +@released + +Declares a function for testing object invariance. + +For complex classes, it is often useful to provide a function that can +be called to check that the object is in a valid state. +The __DECLARE_TEST macro supplies a standard prototype for such a function +named __DbgTestInvariant(). A companion macro __TEST_INVARIANT is provided +to call the function. + +For DLLs, as opposed to EXEs, __DbgTestInvariant() is exported, +i.e. the macro expands to: + +@code +public: IMPORT_C void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const +@endcode + +This macro should placed as the last item in a class declaration (as it +switches back to public access). Note that a terminating semi-colon must be used. + +You should define the __DbgTestInvariant() function to check that the object +is in a healthy state. If it finds an error, it should call User::Invariant(), +which will cause a panic. + +If a class is derived from a base class, then the base class __DbgTestInvariant() +should be called first, and then any further checking done. + +The second function declared, __DbgTest(), is intended to allow test code a way +of directly accessing non-public members of a class. The function is +implemented by any test code that requires it, rather than in the class’s own +source code. The function is therefore not exported. + +__DECLARE_TEST is defined for both debug and release builds. This point is +particularly important for DLLs, as otherwise the exported interfaces would +differ between the build versions, giving potential binary compatibility +problems. To avoid using memory unnecessarily in release builds, you can, +however, use preprocessor directives to define the code within +__DbgTestInvariant() only for debug builds. __DbgTestInvariant() is never +called in release builds. + +@see __TEST_INVARIANT +} +{#define __DECLARE_TEST public: IMPORT_C void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const +#else +#define __DECLARE_TEST public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const +#endif + +#else +#define __ASSERT_DEBUG(c,p) +#define __DECLARE_NAME(t) +#define __TEST_INVARIANT +#if defined(__DLL__) +#define __DECLARE_TEST public: IMPORT_C void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const +#else +#define __DECLARE_TEST public: void __DbgTestInvariant() const; void __DbgTest(TAny *aPtr) const +#endif} + + + + +{ +@publishedAll +@released + +Marks the start of checking the current thread's heap. + +This macro is defined only for debug builds. + +This macro must be matched by a corresponding call to __UHEAP_MARKEND or __UHEAP_MARKENDC. + +Calls to this macro can be nested but each call must be matched by corresponding +call to __UHEAP_MARKEND or __UHEAP_MARKENDC. + +@see User::__DbgMarkStart() +@see __UHEAP_MARKEND +@see __UHEAP_MARKENDC +} +//#define __UHEAP_MARK + + + + +{ +@publishedAll +@released + +Checks that the number of allocated cells at the current nested level on the +current thread's heap is the same as the specified value. + +This macro is defined only for debug builds. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +The macro assumes that: + +1. the heap being checked is a user heap + +2. checking is being done for the number of allocated cells at the current nested + level; i.e. that aCountAll is set to false + +3. the line number is the line number of this source code statement. + +4. the file name is the full path name of the file containing this source statement + +@param aCount The number of heap cells expected to be allocated at + the current nest level. + +@see User::__DbgMarkCheck() +@see __KHEAP_CHECK +} +//#define __UHEAP_CHECK(aCount) + + + + +{ +@publishedAll +@released + +Checks that the total number of allocated cells on the current thread's heap +is the same as the specified value. + +This macro is defined only for debug builds. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +@param aCount The total number of heap cells expected to be allocated. + +@see User::__DbgMarkCheck() +@see __KHEAP_CHECKALL +} +//#define __UHEAP_CHECKALL(aCount) + + + + +{ +@publishedAll +@released + +Marks the end of checking the current thread's heap. + +The macro expects zero heap cells to remain allocated at the current nest +level. This macro is defined only for debug builds. + +This macro must match an earlier call to __UHEAP_MARK. + +@see User::__DbgMarkEnd() +@see __UHEAP_MARK +} +//#define __UHEAP_MARKEND + + + + +{ +@publishedAll +@released + +Marks the end of checking the current thread's heap. + +The macro expects aCount heap cells to remain allocated at the current nest +level. + +This macro must match an earlier call to __UHEAP_MARK. + +@param aCount The number of heap cells expected to remain allocated at + the current nest level. + +@see User::__DbgMarkEnd() +@see __UHEAP_MARK +} +//#define __UHEAP_MARKENDC(aCount) + + + + +{ +@publishedAll +@released + +Simulates heap allocation failure for the current thread's heap. + +The failure occurs on the next call to new or any of the functions which +allocate memory from the heap. This macro is defined only for debug builds. + +@param aCount Determines when the allocation will fail. + Heap allocation fails on attempt number aCount - later + allocations will succeed. + For example, if aCount is 3, then heap allocation fails + on the 3rd attempt, but all subsequent allocations succeed. + +@see User::__DbgSetAllocFail() +} +//#define __UHEAP_FAILNEXT(aCount) + + + + +{ +@publishedAll +@released + +Simulates heap allocation failure for the current thread's heap. + +The failure occurs on subsequent calls to new or any of the functions which +allocate memory from the heap. This macro is defined only for debug builds. + +@param aType The type of failure to be simulated. +@param aValue The failure rate. + +@see User::__DbgSetAllocFail() +} +//#define __UHEAP_SETFAIL(aType,aValue) + + + + +{ +@publishedAll +@released + +Cancels simulated heap allocation failure for the current thread's heap. + +This macro is defined only for debug builds. + +@see User::__DbgSetAllocFail() +} +//#define __UHEAP_RESET + + + +{ +@publishedAll +@released + +Cancels simulated heap allocation failure for the current thread's heap. +It walks the the heap and sets the nesting level for all allocated +cells to zero. + +This macro is defined only for debug builds. +} +//#define __UHEAP_TOTAL_RESET + + + +{ +@publishedPartner +@released + +Marks the start of Kernel heap checking. + +Checking the Kernel heap is only useful when developing Kernel side code such +as device drivers and media drivers. + +This macro is defined only for debug builds. + +This macro must be matched by a corresponding call to __KHEAP_MARKEND or __KHEAP_MARKENDC. +Calls to this macro can be nested but each call must be matched by corresponding +call to __KHEAP_MARKEND or __KHEAP_MARKENDC. + +@see User::__DbgMarkStart() +@see __KHEAP_MARKEND +@see __KHEAP_MARKENDC +} +//#define __KHEAP_MARK + + + + +{ +@publishedPartner +@released + +Checks that the number of allocated cells at the current nested level of the +Kernel heap is the same as the specified value. This macro is defined only +for debug builds. Checking the Kernel heap is only useful when developing +Kernel side code such as device drivers and media drivers. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +@param aCount The number of heap cells expected to be allocated at + the current nest level. + +@see User::__DbgMarkCheck() +@see __UHEAP_CHECK +} +//#define __KHEAP_CHECK(aCount) + + + + +{ +@publishedPartner +@released + +Checks that the total number of allocated cells on the Kernel heap is the same +as the specified value. + +It is only useful when developing Kernel side code such as device drivers +and media drivers. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +This macro is defined only for debug builds. + +@param aCount The total number of heap cells expected to be allocated + +@see User::__DbgMarkCheck() +@see __UHEAP_CHECKALL +} +//#define __KHEAP_CHECKALL(aCount) + + + + +{ +@publishedPartner +@released + +Marks the end of Kernel heap checking. The macro expects zero heap cells to +remain allocated at the current nest level. + +This macro is defined only for debug builds. Checking the Kernel heap is only +useful when developing Kernel side code such as device drivers and media drivers. + +This macro must match an earlier call to __KHEAP_MARK. + +@see User::__DbgMarkEnd() +@see __KHEAP_MARK +} +//#define __KHEAP_MARKEND + + + + +{ +@publishedPartner +@released + +Marks the end of Kernel heap checking. The macro expects aCount heap cells +to remain allocated at the current nest level. + +This macro is defined only for debug builds. + +This macro must match an earlier call to __KHEAP_MARK. + +@param aCount The number of heap cells expected to remain allocated at + the current nest level. + +@see User::__DbgMarkEnd() +@see __KHEAP_MARK +} +//#define __KHEAP_MARKENDC(aCount) + + + + +{ +@publishedPartner +@released + +Simulates Kernel heap allocation failure. The failure occurs on the next call +to new or any of the functions which allocate memory from the heap. This macro +is defined only for debug builds. + +Checking the Kernel heap is only useful when developing Kernel side code such +as device drivers and media drivers. + +@param aCount The rate of failure - heap allocation fails every aCount attempt. + +@see User::__DbgSetAllocFail() +} +//#define __KHEAP_FAILNEXT(aCount) + + + + +{ +@publishedPartner +@released + +Simulates Kernel heap allocation failure. + +The failure occurs on subsequent calls to new or any of the functions which +allocate memory from this heap. + +This macro is defined only for debug builds. + +@param aType The type of failure to be simulated. +@param aValue The failure rate. + +@see User::__DbgSetAllocFail() +} +//#define __KHEAP_SETFAIL(aType,aValue) + + + + +{ +@publishedPartner +@released + +Cancels simulated Kernel heap allocation failure. + +Checking the Kernel heap is only useful when developing Kernel side code such +as device drivers and media drivers. + +This macro is defined only for debug builds. + +@see User::__DbgSetAllocFail() +} +//#define __KHEAP_RESET + + + +{ +@publishedPartner +@released + +Cancels simulated kernel heap allocation failure. +It walks the the heap and sets the nesting level for all allocated +cells to zero. + +Checking the kernel heap is only useful when developing kernel side code such +as device drivers and media drivers. + +This macro is defined only for debug builds. +} +//#define __KHEAP_TOTAL_RESET + + + +{ +@publishedAll +@released + +Marks the start of heap checking for the specific heap. + +This macro is defined only for debug builds. + +This macro must be matched by a corresponding call to __RHEAP_MARKEND or __RHEAP_MARKENDC. + +Calls to this macro can be nested but each call must be matched by corresponding +call to __RHEAP_MARKEND or __RHEAP_MARKENDC. + +@param aHeap A pointer to the specific RHeap + +@see RHeap +@see RAllocator::__DbgMarkStart() +@see __RHEAP_MARKEND +@see __RHEAP_MARKENDC +} +//#define __RHEAP_MARK(aHeap) + + + + +{ +@publishedAll +@released + +Checks that the number of allocated cells at the current nested level on the +specified heap is the same as the specified value. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. +@param aCount The number of heap cells expected to be allocated at + the current nest level. + +@see RAllocator::__DbgMarkCheck() +} +//#define __RHEAP_CHECK(aHeap,aCount) + + + + +{ +@publishedAll +@released + +Checks that the total number of allocated cells on the specified heap is the +same as the specified value. + +The macro also takes the name of the file containing this source code statement +and the line number of this source code statement; they are displayed as part +of the panic category, if the checks fail. + +This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. +@param aCount The total number of heap cells expected to be allocated. + +@see RAllocator::__DbgMarkCheck() +} +//#define __RHEAP_CHECKALL(aHeap,aCount) + + + + +{ +@publishedAll +@released + +Marks the end of heap checking for the specific heap. + +The macro expects zero heap cells to remain allocated at the current nest +level. This macro is defined only for debug builds. + +This macro must match an earlier call to __RHEAP_MARK. + +@param aHeap A pointer to the specific RHeap. + +@see RAllocator::__DbgMarkEnd() +@see __RHEAP_MARK +} +//#define __RHEAP_MARKEND(aHeap) + + + + +{ +@publishedAll +@released + +Marks the end of heap checking for the specific heap. + +The macro expects aCount heap cells to remain allocated at the current nest +level. This macro is defined only for debug builds. + +This macro must match an earlier call to __RHEAP_MARK. + +@param aHeap A pointer to the specific RHeap. +@param aCount The number of heap cells expected to remain allocated at + the current nest level + +@see RAllocator::__DbgMarkEnd() +@see __RHEAP_MARK +} +//#define __RHEAP_MARKENDC(aHeap,aCount) + + + + +{ +@publishedAll +@released + +Simulates an allocation failure for the specific heap. + +The failure occurs on the next call to new or any of the functions which allocate +memory from the heap. This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. +@param aCount The rate of failure - heap allocation fails every aCount attempt. + +@see RAllocator::__DbgSetAllocFail() +} +//#define __RHEAP_FAILNEXT(aHeap,aCount) + + + + +{ +@publishedAll +@released + +Simulates an allocation failure for the specific heap. + +The failure occurs on subsequent calls to new or any of the functions which +allocate memory from the heap. This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. +@param aType The type of failure to be simulated. +@param aValue The failure rate. + +@see RAllocator::__DbgSetAllocFail() +} +//#define __RHEAP_SETFAIL(aHeap,aType,aValue) + + + + +{ +@publishedAll +@released + +Cancels simulated allocation failure for the specific heap. + +This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. + +@see RAllocator::__DbgSetAllocFail() +} +//#define __RHEAP_RESET(aHeap) + + + +{ +@publishedAll +@released + +Cancels simulated allocation failure for the specific heap. +It walks the the heap and sets the nesting level for all allocated +cells to zero. + +This macro is defined only for debug builds. + +@param aHeap A pointer to the specific RHeap. + +@see RAllocator::__DbgSetAllocFail() +} +//#define __RHEAP_TOTAL_RESET(aHeap) + + + +{#define __DEBUGGER() +#endif + +#if defined (__WINS__)} +{ @internalTechnology } +//#define __EMULATOR_IMAGE_HEADER2(aUid0,aUid1,aUid2,aPriority,aCap0,aCap1,aSid,aVid,aVer,aFlags) TEmulatorImageHeader uid={{aUid0,aUid1,aUid2},aPriority,{aSid,aVid,{aCap0,aCap1}},0,0,aVer,aFlags}; +{ @internalTechnology } +{#define __EMULATOR_IMAGE_HEADER(aUid0,aUid1,aUid2,aPriority,aCap,aFlags) TEmulatorImageHeader uid={{aUid0,aUid1,aUid2},aPriority,{aUid2,0,{aCap,0}},0,0,0x00010000u,aFlags}; +#else +#define __EMULATOR_IMAGE_HEADER2(aUid0,aUid1,aUid2,aPriority,aCap0,aCap1,aSid,aVer,aFlags) +#define __EMULATOR_IMAGE_HEADER(aUid0,aUid1,aUid2,aPriority,aCap,aFlags) +#endif + +#if defined(__OPT__)} +{ +@internalComponent +@deprecated +} +{#define __ASSERT_OPT(c,p) (void)((c)||(p,0)) +#else +#define __ASSERT_OPT(c,p) +#endif + +#if defined(_UNICODE) +#if !defined(UNICODE) } +{ +@publishedAll +@deprecated +} +{#define UNICODE +#endif +#endif } + +//#if defined(_DEBUG) +{ +@internalComponent +@deprecated +} +{#define __DECLARE_TEST_DEBUG __DECLARE_TEST +#else +#define __DECLARE_TEST_DEBUG +#endif + + + + +#if !defined(ASSERT) } +{ +@publishedAll +@released + +Generates _ASSERT_DEBUG code that calls User::Invariant() if the specified +condition is not true. + +@param x A conditional expression which results in true or false. +} +{#define ASSERT(x) __ASSERT_DEBUG(x,User::Invariant()) +#endif + + + + +#ifndef __VALUE_IN_REGS__ } +{ +@publishedPartner +@released +} +{#define __VALUE_IN_REGS__ +#endif + + + + +#if defined(_DEBUG) } +{ +@publishedAll +@released +} +{#define __DEBUG_ONLY(x) x +#else +#define __DEBUG_ONLY(x) +#endif } + + + + +{$ifdef __KERNEL_MODE__} + +{ @internalComponent } +#define KIMPORT_C IMPORT_C + +{ @internalComponent } +#define KEXPORT_C EXPORT_C + +{ @internalComponent } +#define UIMPORT_C + +{ @internalComponent } +#define UEXPORT_C +#else +#define KIMPORT_C +#define KEXPORT_C +#define UIMPORT_C IMPORT_C +#define UEXPORT_C EXPORT_C +{$endif} + + + + +{ +@publishedAll +@released + +Asserts that a condition is true at compilation time. + +@param x Condition to assert +} +//#define __ASSERT_COMPILE(x) void __compile_time_assert(int __check[(x)?1:-1]) + +//#ifdef __REMOVE_PLATSEC_DIAGNOSTICS__ +{ +@publishedPartner +@released +} +//#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ +//#define __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ +//#endif /*__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__} +//#endif /*__REMOVE_PLATSEC_DIAGNOSTICS__} + +{ +@internalComponent +} +//static const char* const KSuppressPlatSecDiagnosticMagicValue = (const char*)1; + +//#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ +{ +@internalComponent +} +//#define __PLATSEC_DIAGNOSTIC_FILE_AND_LINE_HELPER(l) #l +{ +@internalComponent +} +//#define __PLATSEC_DIAGNOSTIC_FILE_AND_LINE_HELPER2(f,l) f "(" __PLATSEC_DIAGNOSTIC_FILE_AND_LINE_HELPER(l) ")" +{ +@publishedPartner +@released +} +//#define __PLATSEC_DIAGNOSTIC_FILE_AND_LINE __PLATSEC_DIAGNOSTIC_FILE_AND_LINE_HELPER2(__FILE__,__LINE__) + +{ +@publishedPartner +@released + +A macro that should be used to enclose a platform security diagnostic +'C' style string that can be passed to a capability checking function such +as RThread::HasCapability() and Kern::CurrentThreadHasCapability(). + +The content of the string is emitted if the capability test finds that +the capability is not present. + +The macro provides a convenient mechanism that allows the strings to +be removed from future versions of Symbian OS. + +For example: + +@code +if(!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by Hal function EDisplayHalSetState"))) + { + return KErrPermissionDenied; + } +@endcode + +In this example, the string: + +@code +Checked by Hal function EDisplayHalSetState +@endcode + +is emitted if the calling process does not have the ECapabilityPowerMgmt capability. + +@param s A C-style string. + +@see RProcess::HasCapability() +@see RThread::HasCapability() +@see RMessagePtr2::HasCapability() +@see User::CreatorHasCapability() +} +//#define __PLATSEC_DIAGNOSTIC_STRING(s) s + +{ +When this value is used in Platform Security APIs as the value for the aDiagnosticText +argument, these APIs will not emit any form of diagnostic message. +@publishedPartner +@released +} +//static const char* const KSuppressPlatSecDiagnostic = KSuppressPlatSecDiagnosticMagicValue; + +//#else /* __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ } + +//#define __PLATSEC_DIAGNOSTIC_STRING(s) NULL + +{$ifndef __KERNEL_MODE__} +//#ifndef __REMOVE_PLATSEC_DIAGNOSTICS__ +{ +When this value is used in Platform Security APIs as the value for the aDiagnostic +argument, these APIs will not emit any form of diagnostic message. +@publishedPartner +@released +} +//#define KSuppressPlatSecDiagnostic NULL, NULL + +{.$else} { __REMOVE_PLATSEC_DIAGNOSTICS__ } + +{ +When this value is used in Platform Security APIs as the value for the aDiagnostic +argument, these APIs will not emit any form of diagnostic message. +@publishedPartner +@release +} +//#define KSuppressPlatSecDiagnostic NULL + +//#endif { !__REMOVE_PLATSEC_DIAGNOSTICS__ } +{$endif} { !__KERNEL_MODE__ } +//#endif /* !__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ } + +{ + * MSVC operator new and operator new[] header guards + } +{#ifdef __PLACEMENT_NEW +#define __PLACEMENT_NEW_INLINE +#endif} { __PLACEMENT_NEW } + +{#if defined(__VC32__) && (_MSC_VER < 1300) +#define __PLACEMENT_VEC_NEW_INLINE +#endif} { version of MSVC that doesn't support overloaded operator new[] } + +{ +Calling convention qualifier for functions involving floating point +variables passed or returned by value. +@publishedAll +@released +} +{#ifndef __SOFTFP +#define __SOFTFP +#endif /* __SOFTFP } + + diff --git a/rtl/symbian/e32err.inc b/rtl/symbian/e32err.inc new file mode 100644 index 0000000000..5e8d55a2e4 --- /dev/null +++ b/rtl/symbian/e32err.inc @@ -0,0 +1,621 @@ +{%MainUnit symbian.pas} + +{ + This file is part of the Free Pascal run time library. + Copyright (c) 2007 by contributors of the Free Pascal Compiler + + This file is a pascal translation of the Symbian OS headers + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +{ e32\include\e32err.h + + Copyright (c) 1994-2001 Symbian Ltd. All rights reserved. + } + + +//#include + + + + +{ +System wide error code - no error. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrNone=0; + + + + +{ +System wide error code - item not found. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrNotFound=(-1); // Must remain set to -1 + + + + +{ +System wide error code - an error that has no specific categorisation. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrGeneral=(-2); + + + + +{ +System wide error code - indicates an operation that has been cancelled. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrCancel=(-3); + + + + +{ +System wide error code - an attempt to allocate memory has failed. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrNoMemory=(-4); + + + + +{ +System wide error code - some functionality is not supported in a given context. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. + +There may be many reasons for this; for example, a device may not support +some specific behaviour. +} +const KErrNotSupported=(-5); + + + + +{ +System wide error code - an argument is out of range. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrArgument=(-6); + + + + +{ +System wide error code - a calculation has lost precision. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. + +This error arises when converting from an internal 96-bit real representation +to a TReal32; the exponent of the internal representation is so small +that the 32-bit real cannot contain it. +} +const KErrTotalLossOfPrecision=(-7); + + + + +{ +System wide error code - an invalid handle has been passed. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. + +A function involving a resource owned by a server or the kernel has +specified an invalid handle. +} +const KErrBadHandle=(-8); + + + + +{ +System wide error code - indicates an overflow in some operation. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. + +In the context of mathematical or time/date functions, indicates a calculation +that has produced arithmetic overflow exceeding the bounds allowed by +the representation. + +In the context of data transfer, indicates that a buffer has over-filled +without being emptied soon enough. +} +const KErrOverflow=(-9); + + + + +{ +System wide error code - indicates an underflow in some operation. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. + +In the context of mathematical or time/date functions, indicates a calculation +that has produced a result smaller than the smallest magnitude of +a finite number allowed by the representation. + +In the context of data transfer, indicates that a buffer was under-filled +when data was required. +} +const KErrUnderflow=(-10); + + + + +{ +System wide error code - an object already exists. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. + +An object of some name/type is to be created, but an object of +that name/type already exists. +} +const KErrAlreadyExists=(-11); + + + + +{ +System wide error code - in the context of file operations, a path +was not found. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrPathNotFound=(-12); + + + + +{ +System wide error code - a handle refers to a thread that has died. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrDied=(-13); + + + + +{ +System wide error code - a requested resource is already in exclusive use. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrInUse=(-14); + + + + +{ +System wide error code - a client/server send/receive operation cannot run, +because the server has terminated. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrServerTerminated=(-15); + + + + +{ +System wide error code - a client/server send/receive operation cannot run, +because the server is busy handling another request. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrServerBusy=(-16); + + + + +{ +System wide error code - indicates that an operation is complete, +successfully or otherwise. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. + +This code may be used to indicate that some follow on operation can take place. +It does not necessarily indicate an error condition. +} +const KErrCompletion=(-17); + + + + +{ +System wide error code - indicates that a device required by an i/o operation +is not ready to start operations. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. + +A common reason for returning this code is because a device has not been +initialised, or has no power. +} +const KErrNotReady=(-18); + + + + +{ +System wide error code - a device is of unknown type. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrUnknown=(-19); + + + + +{ +System wide error code - indicates that some media is not formatted properly, +or links between sections of it have been corrupted. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrCorrupt=(-20); + + + + +{ +System wide error code - access to a file is denied, because the permissions on +the file do not allow the requested operation to be performed. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrAccessDenied=(-21); + + + + +{ +System wide error code - an operation cannot be performed, because the part +of the file to be read or written is locked. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrLocked=(-22); + + + + +{ +System wide error code - during a file write operation, not all the data +could be written. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrWrite=(-23); + + + + +{ +System wide error code - a volume which was to be used for a file system +operation has been dismounted. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrDisMounted=(-24); + + + + +{ +System wide error code - indicates that end of file has been reached. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. + +Note that RFile::Read() is a higher-level interface. When the end of +the file is reached, it returns zero bytes in the destination descriptor, and +a KErrNone return value. KErrEof is not used for this purpose; other error +conditions are returned only if some other error condition was indicated on +the file. +} +const KErrEof=(-25); + + + + +{ +System wide error code - a write operation cannot complete, because the disk +is full. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrDiskFull=(-26); + + + + +{ +System wide error code - a driver DLL is of the wrong type. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrBadDriver=(-27); + + + + +{ +System wide error code - a file name or other object name does not conform to +the required syntax. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrBadName=(-28); + + + + +{ +System wide error code - a communication line has failed. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrCommsLineFail=(-29); + + + + +{ +System wide error code - a frame error has occurred in +a communications operation. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrCommsFrame=(-30); + + + + +{ +System wide error code - an overrun has been detected by +a communications driver. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrCommsOverrun=(-31); + + + + +{ +System wide error code - a parity error has occurred in communications. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrCommsParity=(-32); + + + + +{ +System wide error code - an operation has timed out. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrTimedOut=(-33); + + + + +{ +System wide error code - a session could not connect. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrCouldNotConnect=(-34); + + + + +{ +System wide error code - a session could not disconnect. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrCouldNotDisconnect=(-35); + + + + +{ +System wide error code - a function could not be executed because the required +session was disconnected. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrDisconnected=(-36); + + + + +{ +System wide error code - a library entry point was not of the required type. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrBadLibraryEntryPoint=(-37); + + + + +{ +System wide error code - a non-descriptor parameter was passed by +a client interface, when a server expected a descriptor. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrBadDescriptor=(-38); + + + + +{ +System wide error code - an operation has been aborted. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrAbort=(-39); + + + + +{ +System wide error code - a number was too big. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrTooBig=(-40); + + + + +{ +System wide error code - a divide-by-zero operation has been attempted. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrDivideByZero=(-41); // Added by AnnW + + + + +{ +System wide error code - insufficient power was available to +complete an operation. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrBadPower=(-42); + + + + +{ +System wide error code - an operation on a directory has failed. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrDirFull=(-43); + + + + +{ +System wide error code - an operation cannot be performed because +the necessary hardware is not available. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrHardwareNotAvailable=(-44); + + + + +{ +System wide error code - the completion status when an outstanding +client/server message is completed because a shared session has been closed. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrSessionClosed=(-45); + + + + +{ +System wide error code - an operation cannot be performed due to +a potential security violation. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrPermissionDenied=(-46); + + + +{ +System wide error code - a requested extension function is not +supported by the object concerned. + +} +const KErrExtensionNotSupported=(-47); + + + +{ +System wide error code - a break has occurred in +a communications operation. + +A system wide error code indicates an error in the environment, or in +user input from which a program may recover. +} +const KErrCommsBreak=(-48); + diff --git a/rtl/symbian/symbian.pas b/rtl/symbian/symbian.pas index d4effc8278..436437ea63 100644 --- a/rtl/symbian/symbian.pas +++ b/rtl/symbian/symbian.pas @@ -1,14 +1,37 @@ +{ + This file is part of the Free Pascal run time library. + Copyright (c) 2007 by contributors of the Free Pascal Compiler + + Symbian OS unit that adds common types, constants and functions + for the Symbian API + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} unit symbian; {$mode objfpc}{$H+} interface +uses ctypes; + +{$include e32def.inc} +{$include e32err.inc} +{.$include e32const.inc} +{.$include e32cmn.inc} +{.$include e32std.inc} + { e32std.h header file } { User class } -procedure User_InfoPrint(); cdecl; external; +function User_InfoPrint(aString: PChar): TInt; cdecl; external; implementation diff --git a/rtl/symbian/system.pp b/rtl/symbian/system.pp index ae078443ef..291e72e509 100644 --- a/rtl/symbian/system.pp +++ b/rtl/symbian/system.pp @@ -113,6 +113,11 @@ var { include system independent routines } {$I system.inc} +{***************************************************************************** + Minimum Symbian API declarations +*****************************************************************************} +const KErrNone=0; + {***************************************************************************** Parameter Handling *****************************************************************************} @@ -181,6 +186,8 @@ begin { if we pass here there was no error } system_exit; + + Result := KErrNone; end; procedure SysInitStdIO;