diff -r f5050f1da672 -r 04becd199f91 javauis/inc/jdebug.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/inc/jdebug.h	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,578 @@
+/*
+* 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
+
+#define DEBUG_LOG_ONLY( code ) code
+#define DEBUG_ONLY( code ) code
+
+// The COMPILE_ASSERT macro is useful for ensuring that number values
+// defined in Java retain the same values as their native counterparts,
+// for example in the case of error codes
+template <TBool> struct ASSERTION_FAILURE;
+TEMPLATE_SPECIALIZATION struct ASSERTION_FAILURE<ETrue> {};
+template <TInt> struct __assertion_test;
+#define COMPILE_ASSERT( B ) void __compile_assert(::__assertion_test<sizeof(::ASSERTION_FAILURE<(B)>)>)
+#define OOM_DEBUG_LOOP_START TInt error = KErrNoMemory; for( TInt fail = 1; error == KErrNoMemory; fail++ ) { DEBUG_INT( "create connection OOM loop: %d", fail );  __UHEAP_FAILNEXT(fail); __UHEAP_MARK;
+#define OOM_DEBUG_LOOP_END __UHEAP_MARKEND; } __UHEAP_SETFAIL(RHeap::ENone,0);
+
+#else
+
+/** Code inside the brackets is only for debug or for logging in release build  */
+#if defined(JAVA_RDEBUG) || defined(JAVA_PRINTF) || defined (JAVA_PROFILE)
+#define DEBUG_LOG_ONLY( code ) code
+#else
+#define DEBUG_LOG_ONLY( code )
+#endif
+
+/** Marks the code inside the brackets as being for debug
+builds only. */
+#define DEBUG_ONLY( code )
+
+/** Asserts that the code inside the brackets must be true at
+compile time, otherwise compilation fails.
+
+This macro is useful for ensuring that numeric values defined in
+Java retain the same values as their native counterparts, for
+example in the case of error codes. */
+#define COMPILE_ASSERT( B )
+
+/** Marks the start of out-of-memory testing.
+
+This and OOM_DEBUG_LOOP_END are used to test that all heap memory
+allocated in the code block enclosed by the two macros is deallocated.
+The code block is called in a loop, and heap allocation failure is
+simulated each time around. If the code fails the test, a panic occurs. */
+#define OOM_DEBUG_LOOP_START
+/** Marks the end of out-of-memory testing. */
+#define OOM_DEBUG_LOOP_END
+
+#endif // #ifdef _DEBUG
+
+#endif // JDEBUG_H
+
+