/*

* Copyright (c) 2002 - 2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

*/

/**

@file

@publishedPartner

@released

This header file contains three macros for outputing logs to a number of

different locations.

There are three macros:

JAVA_RDEBUG

    enables logging to the serial port.

JAVA_FILELOG

    writes a log to c:\logs\java\midp.txt if the directory exists.

JAVA_PRINTF

    enables printf logging.

The default behaviour for UDEB builds is to have only JAVA_FILELOG enabled.

To enable UREL file logging, the ifdef clause surrounding JAVA_FILELOG must

be removed, and one of the

/j2me/vms/extensions/src/epoc/native/util/include/enable_flogger*.bat files

must be executed before attempting to build  These batch files modify the

flogger include to be a standard library rather than a debuglibrary.

Please see /j2me/vms/extensions/src/epoc/native/util/include/readme.txt for

more details.

 */

#ifndef JDEBUG_H

#define JDEBUG_H

//////////////////////////////////////////////////////////////////////////////

// Customisation should only be required in the below section               //

//#define JAVA_RDEBUG

//#define JAVA_PRINTF

//#define JAVA_PROFILE

#ifdef _DEBUG // only on UDEB builds

#define JAVA_FILELOG

#endif

// Customisation should only be required in the above section               //

//////////////////////////////////////////////////////////////////////////////

#include <e32std.h>

// Debugging headers

#if defined (JAVA_RDEBUG) || defined (JAVA_PROFILE)

#include <e32svr.h>

#endif

#ifdef JAVA_FILELOG

#include <flogger.h>

#endif

#ifdef JAVA_PRINTF

#include <libc/stdio.h>

#endif

// Strings for flogger directory and file names

_LIT(KLogDirectory, "java\\full");

_LIT(KLogFileName, "midplegacy.log");

/**

Custom Component Logging

Add extra component literals here to use in components.

To add component logging into the main log change the

"<component>.txt" to "midp.txt"

*/

/**

To force all logging into main log file (midp.txt)

uncomment the following line */

//#define ONE_LOG

#if defined(JAVA_RDEBUG) || defined(JAVA_PRINTF) || defined(JAVA_FILELOG) || defined (JAVA_PROFILE)

// to fix compiler warnings

inline void Dummy(TBool /*aBool*/)

{

}

inline void Dummy(const TDesC& /*aComponentLogName*/)

{

}

//Splits the logging into multiple files , aComponentLogName is the log file associated

//with specific components eg

//http.txt will go into \logs\java\http.txt

inline void Debug(const TDesC& aComponentLogName,  const TDesC& aMsg, const TBool aBool)

{

#ifdef JAVA_FILELOG

    // Print to log file

#ifdef ONE_LOG

    const TDesC& ignore = aComponentLogName;

    RFileLogger::Write(KLogDirectory, KLogFileName, EFileLoggingModeAppend, aMsg);

#else

    RFileLogger::Write(KLogDirectory, aComponentLogName, EFileLoggingModeAppend, aMsg);

#endif

    Dummy(aBool);

#endif

#ifdef JAVA_PRINTF

    {

        if (aBool)

        {

            // Print to standard out

            TBuf8<0x100> msg;

            msg.Copy(aMsg);

            printf("C_DEBUG: ");

            const char* msgPtr = reinterpret_cast<const char*>(msg.PtrZ());

            printf(msgPtr);

            printf("\n");

        }

    }

#endif

#ifdef JAVA_RDEBUG

    // Print to debugger (WINS only)

    RDebug::Print(aMsg);

    Dummy(aComponentLogName);

    Dummy(aBool);

#endif

}

_LIT(KJavaProfile , "Java_profile:: low: %u , high: %u :%S");

#ifdef JAVA_PROFILE

inline void DebugProfile(const TDesC& aMsg)

{

    TTime time;

    time.UniversalTime();

    RDebug::Print(KJavaProfile , I64LOW(time.Int64()), I64HIGH(time.Int64()), &aMsg);

}

#else

inline void DebugProfile(const TDesC&)

{

}

#endif

inline void DebugString(const TDesC& aComponentLogName, const TDesC& aMsg, const TDesC& aString, const TBool aBool)

{

    // Print to log file

#ifdef JAVA_FILELOG

#ifdef ONE_LOG

    const TDesC& ignore = aComponentLogName;

    RFileLogger::WriteFormat(KLogDirectory, KLogFileName, EFileLoggingModeAppend, aMsg, &aString);

#else

    RFileLogger::WriteFormat(KLogDirectory, aComponentLogName, EFileLoggingModeAppend, aMsg, &aString);

#endif

    Dummy(aBool);

#endif

#ifdef JAVA_PRINTF

    // Locally scope the code because temporary variables are defined and inlined

    {

        if (aBool)

        {

            // Print to standard out

            TBuf8<0x100> msg;

            msg.Copy(aMsg);

            printf("C_DEBUG: ");

            const char* msgPtr = reinterpret_cast<const char*>(msg.PtrZ());

            TBuf8<0x100> tmpString(0xFF);

            tmpString.Copy(aString.Left(0xFF));

            printf(msgPtr);

            printf("tring:\"%s\"\n", tmpString.PtrZ());

        }

    }

#endif

#ifdef JAVA_RDEBUG

    // Print to debugger (WINS only)

    RDebug::Print(aMsg, &aString);

    Dummy(aComponentLogName);

    Dummy(aBool);

#endif

}

inline void DebugInt(const TDesC& aComponentLogName, const TDesC& aMsg, TInt aNum, const TBool aBool)

{

    // Print to log file

#ifdef JAVA_FILELOG

#ifdef ONE_LOG

    const TDesC& ignore = aComponentLogName;

    RFileLogger::WriteFormat(KLogDirectory, KLogFileName, EFileLoggingModeAppend, aMsg, aNum);

#else

    RFileLogger::WriteFormat(KLogDirectory, aComponentLogName, EFileLoggingModeAppend, aMsg, aNum);

#endif

    Dummy(aBool);

#endif

#ifdef JAVA_PRINTF

    {

        if (aBool)

        {

            // Print to standard out

            TBuf8<0x100> msg;

            msg.Copy(aMsg);

            printf("C_DEBUG: ");

            const char* msgPtr = reinterpret_cast<const char*>(msg.PtrZ());

            printf(msgPtr, aNum);

            printf("\n");

        }

    }

#endif

#ifdef JAVA_RDEBUG

    // Print to debugger (WINS only)

    RDebug::Print(aMsg, aNum);

    Dummy(aComponentLogName);

    Dummy(aBool);

#endif

}

inline void DebugInt2(const TDesC& aComponentLogName, const TDesC& aMsg, TInt aNum, TInt aNum2, const TBool aBool)

{

    // Print to log file

#ifdef JAVA_FILELOG

#ifdef ONE_LOG

    const TDesC& ignore = aComponentLogName;

    RFileLogger::WriteFormat(KLogDirectory, KLogFileName, EFileLoggingModeAppend,

                             aMsg, aNum, aNum2);

#else

    RFileLogger::WriteFormat(KLogDirectory, aComponentLogName, EFileLoggingModeAppend,

                             aMsg, aNum, aNum2);

#endif

    Dummy(aBool);

#endif

#ifdef JAVA_PRINTF

    {

        if (aBool)

        {

            // Print to standard out

            TBuf8<0x100> msg;

            msg.Copy(aMsg);

            printf("C_DEBUG: ");

            const char* msgPtr = reinterpret_cast<const char*>(msg.PtrZ());

            printf(msgPtr, aNum, aNum2);

            printf("\n");

        }

    }

#endif

#ifdef JAVA_RDEBUG

    // Print to debugger (WINS only)

    RDebug::Print(aMsg, aNum, aNum2);

    Dummy(aComponentLogName);

    Dummy(aBool);

#endif

}

inline void DebugInt3(const TDesC& aComponentLogName, const TDesC& aMsg, TInt aNum, TInt aNum2, TInt aNum3, const TBool aBool)

{

    // Print to log file

#ifdef JAVA_FILELOG

#ifdef ONE_LOG

    const TDesC& ignore = aComponentLogName;

    RFileLogger::WriteFormat(KLogDirectory, KLogFileName, EFileLoggingModeAppend,

                             aMsg, aNum, aNum2, aNum3);

#else

    RFileLogger::WriteFormat(KLogDirectory, aComponentLogName, EFileLoggingModeAppend,

                             aMsg, aNum, aNum2, aNum3);

#endif

    Dummy(aBool);

#endif

#ifdef JAVA_PRINTF

    {

        if (aBool)

        {

            // Print to standard out

            TBuf8<0x100> msg;

            msg.Copy(aMsg);

            printf("C_DEBUG: ");

            const char* msgPtr = reinterpret_cast<const char*>(msg.PtrZ());

            printf(msgPtr, aNum, aNum2, aNum3);

            printf("\n");

        }

    }

#endif

#ifdef JAVA_RDEBUG

    // Print to debugger (WINS only)

    RDebug::Print(aMsg, aNum, aNum2, aNum3);

    Dummy(aComponentLogName);

    Dummy(aBool);

#endif

}

inline void DebugInt4(const TDesC& aComponentLogName, const TDesC& aMsg, TInt aNum, TInt aNum2, TInt aNum3, TInt aNum4, const TBool aBool)

{

    // Print to log file

#ifdef JAVA_FILELOG

#ifdef ONE_LOG

    const TDesC& ignore = aComponentLogName;

    RFileLogger::WriteFormat(KLogDirectory, KLogFileName, EFileLoggingModeAppend,

                             aMsg, aNum, aNum2, aNum3, aNum4);

#else

    RFileLogger::WriteFormat(KLogDirectory, aComponentLogName, EFileLoggingModeAppend,

                             aMsg, aNum, aNum2, aNum3, aNum4);

#endif

    Dummy(aBool);

#endif

#ifdef JAVA_PRINTF

    {

        if (aBool)

        {

            // Print to standard out

            TBuf8<0x100> msg;

            msg.Copy(aMsg);

            printf("C_DEBUG: ");

            const char* msgPtr = reinterpret_cast<const char*>(msg.PtrZ());

            printf(msgPtr, aNum, aNum2, aNum3, aNum4);

            printf("\n");

        }

    }

#endif

#ifdef JAVA_RDEBUG

    // Print to debugger (WINS only)

    RDebug::Print(aMsg, aNum, aNum2, aNum3, aNum4);

    Dummy(aComponentLogName);

    Dummy(aBool);

#endif

}

inline void DebugString8(const TDesC& aComponentLogName, const TDesC& aMsg, const TDesC8& aString, const TBool aBool)

{

    TRAPD(error,

          HBufC16* expandedMessage = HBufC16::NewLC(aString.Length());

          expandedMessage->Des().Copy(aString);

          DebugString(aComponentLogName,aMsg, *expandedMessage, aBool);

          CleanupStack::PopAndDestroy(expandedMessage);

         )

    if (error != KErrNone)

    {

        _LIT(KError, "jdebug.h: Error expanding 8 bit String");

        DebugString(aComponentLogName, aMsg, KError, aBool);

        _LIT(KMsg, "jdebug.h: Error=%D Length=%D");

        DebugInt2(aComponentLogName, KMsg, error, aString.Length(), aBool);

    }

}

inline void DebugAssert(TBool aCondition, const TDesC& aMsg)

{

    if (!aCondition)

    {

        DebugString(KLogFileName, _L("ASSERT: %S"), aMsg, ETrue);

        ASSERT(EFalse);

    }

}

// these macros are documented below.

#define DEBUG( msg ) Debug( KLogFileName, _L( msg ), ETrue)

#define DEBUGCOMP( comp, msg ) Debug( comp, _L( msg ), ETrue)

#define DEBUG_ASSERT( condition, msg ) DebugAssert( condition, _L( msg ) )

#define DEBUG_STR( msg, string ) DebugString( KLogFileName, _L( msg ), string, ETrue )

#define DEBUGCOMP_STR( comp, msg, string ) DebugString( comp , _L( msg ), string, ETrue )

#define DEBUG_STR8( msg, string ) DebugString8( KLogFileName, _L( msg ), string, ETrue )

#define DEBUGCOMP_STR8( comp, msg, string ) DebugString8( comp, _L( msg ), string, ETrue )

#define DEBUG_INT( msg, num ) DebugInt( KLogFileName, _L( msg ), num, ETrue )

#define DEBUGCOMP_INT( comp, msg, num ) DebugInt( comp , _L( msg ), num, ETrue )

#define DEBUG_INT2( msg, num, num2 ) DebugInt2( KLogFileName, _L( msg ), num, num2, ETrue )

#define DEBUGCOMP_INT2( comp, msg, num, num2 ) DebugInt2( comp, _L( msg ), num, num2, ETrue )

#define DEBUG_INT3( msg, num, num2, num3 ) DebugInt3( KLogFileName, _L( msg ), num, num2, num3, ETrue )

#define DEBUGCOMP_INT3( comp, msg, num, num2, num3 ) DebugInt3( comp , _L( msg ), num, num2, num3, ETrue )

#define DEBUG_INT4( msg, num, num2, num3, num4 ) DebugInt4( KLogFileName, _L( msg ), num, num2, num3, num4, ETrue )

#define DEBUGCOMP_INT4( comp, msg, num, num2, num3, num4 ) DebugInt4( comp , _L( msg ), num, num2, num3, num4, ETrue )

#define DEBUG_ERR( msg, num ) if ( num < KErrNone ) DebugInt( KLogFileName, _L( msg ), num, ETrue )

#define DEBUG_PROFILE(msg) DebugProfile(_L( msg ))

// don't print to standard out

#define DEBUG_NOSTDLIB( msg) Debug( KLogFileName, _L( msg ), EFalse )

#define DEBUG_STR_NOSTDLIB( msg, string ) DebugString( KLogFileName, _L( msg ), string, EFalse )

#define DEBUG_STR8_NOSTDLIB( msg, string ) DebugString8( KLogFileName, _L( msg ), string, EFalse )

#define DEBUG_INT_NOSTDLIB( msg, num, abool ) DebugInt( KLogFileName, _L( msg ), num, EFalse )

#define DEBUG_INT2_NOSTDLIB( msg, num, num2 ) DebugInt2( KLogFileName, _L( msg ), num, num2, EFalse )

#define DEBUG_INT3_NOSTDLIB( msg, num, num2, num3 ) DebugInt3( KLogFileName, _L( msg ), num, num2, num3, EFalse )

#define DEBUG_INT4_NOSTDLIB( msg, num, num2, num3, num4 ) DebugInt4( KLogFileName, _L( msg ), num, num2, num3, num4, EFalse )

#define DEBUG_ERR_NOSTDLIB( msg, num, ETrue ) if ( num < KErrNone ) DebugInt( KLogFileName, _L( msg ), num, EFalse )

#else // #if defined(JAVA_RDEBUG) || defined(JAVA_PRINTF) || defined(JAVA_FILELOG)

/** Prints a message. */

#define DEBUG( msg )

/** comp specifies a file to put logging in eg http.txt == \logs\java\http.txt

* Literal is defined at top of this file eg KLogFileHttp */

#define DEBUGCOMP( comp, msg )

/** Tests the specified condition, and if it evaluates to

false, prints the message, preceded by the string "ASSERT: "

and raises a USER 0 panic. */

#define DEBUG_ASSERT( condition, msg )

/** Prints a message with a string argument.

Use a %S format character in the message to specify where the

string should be inserted. */

#define DEBUG_STR( msg, string )

/** comp specifies a file to put logging in eg http.txt == \logs\java\http.txt */

/* Literal is defined at top of this file eg KLogFileHttp */

#define DEBUGCOMP_STR( comp, msg, string )

/** Prints a message with a 8 bit string argument.

Use a %S format character in the message to specify where the

string should be inserted. */

#define DEBUG_STR8( msg, string )

/** comp specifies a file to put logging in eg http.txt == \logs\java\http.txt */

/* Literal is defined at top of this file eg KLogFileHttp */

#define DEBUGCOMP_STR8( comp, msg, string )

/** Prints a message with an integer argument.

Use a %D format character in the message to specify where the

integer should be inserted. */

#define DEBUG_INT( msg, num )

/** comp specifies a fire to put logging in eg http.txt == \logs\java\http.txt */

/* Literal is defined at top of this file eg KLogFileHttp */

#define DEBUGCOMP_INT( comp, msg, num )

/** Prints a message with two integer arguments.

Use %D format characters in the message to specify where the

integers should be inserted. */

#define DEBUG_INT2( msg, num, num2 )

/** comp specifies a file to put logging in eg http.txt == \logs\java\http.txt */

/* Literal is defined at top of this file eg KLogFileHttp */

#define DEBUGCOMP_INT2( comp, msg, num, num2 )

/** Prints a message with three integer arguments.

Use %D format characters in the message to specify where the

integers should be inserted. */

#define DEBUG_INT3( msg, num, num2, num3 )

/** comp specifies a fire to put logging in eg http.txt == \logs\java\http.txt */

/* Literal is defined at top of this file eg KLogFileHttp */

#define DEBUGCOMP_INT3( comp, msg, num, num2, num3 )

/** Prints a message with four integer arguments.

Use %D format characters in the message to specify where the

integers should be inserted. */

#define DEBUG_INT4( msg, num, num2, num3, num4 )

/** comp specifies a fire to put logging in eg http.txt == \logs\java\http.txt */

/* Literal is defined at top of this file eg KLogFileHttp */

#define DEBUGCOMP_INT4( comp, msg, num, num2, num3, num4 )

/** Prints a message with an integer error code argument.

Use a %D format character in the message to specify where the

error code should be inserted.

Note that a message is only printed if the integer value is

negative. */

#define DEBUG_ERR( msg, num )

/** Prints msg plus the utc time in milliseconds to allow profiling via RDebug::Print. */

#define DEBUG_PROFILE(msg)

/** Prints a message.

This is the same as DEBUG except the message is not printed

to the standard output. */

#define DEBUG_NOSTDLIB( msg )

/** Prints a message with a string argument.

This is the same as DEBUG_STR except the message is not

printed to the standard output. */

#define DEBUG_STR_NOSTDLIB( msg, string )

/** Prints a message with a string argument.

This is the same as DEBUG_STR except the message is not

printed to the standard output. */

#define DEBUG_STR8_NOSTDLIB( msg, string )

/** Prints a message with an integer argument.

This is the same as DEBUG_INT except the message is not

printed to the standard output. */

#define DEBUG_INT_NOSTDLIB( msg, num )

/** Prints a message with two integer arguments.

This is the same as DEBUG_INT2 except the message is not

printed to the standard output. */

#define DEBUG_INT2_NOSTDLIB( msg, num, num2 )

/** Prints a message with three integer arguments.

This is the same as DEBUG_INT3 except the message is not

printed to the standard output. */

#define DEBUG_INT3_NOSTDLIB( msg, num, num2, num3 )

/** Prints a message with four integer arguments.

This is the same as DEBUG_INT4 except the message is not

printed to the standard output. */

#define DEBUG_INT4_NOSTDLIB( msg, num, num2, num3, num4 )

/** Prints a message with an integer error code argument.

This is the same as DEBUG_ERR except the message is not

printed to the standard output. */

#define DEBUG_ERR_NOSTDLIB( msg, num )

#endif // #if defined(JAVA_RDEBUG) || defined(JAVA_PRINTF) || defined(JAVA_FILELOG)

#ifdef _DEBUG