diff -r 3104fc151679 -r 9a48e301e94b uiservicetab/inc/uiservicetabtracer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiservicetab/inc/uiservicetabtracer.h Wed Sep 01 12:33:36 2010 +0100 @@ -0,0 +1,425 @@ +/* +* Copyright (c) 2008 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: trace logs + * +*/ + +#ifndef UISERVICETABTRACER_H +#define UISERVICETABTRACER_H + +#include +#include +#include "vimpstbuilddefinitions.h" + +#ifdef CHAT_ENABLE_DEBUG_PRINT + +// -------------------------------------------------------------------------- +// Define tracer logging method +// 0 = Logging off +// 1 = Log to RDebug +// 2 = Log to file (RFileLogger) +// -------------------------------------------------------------------------- +// + +#ifdef __WINS__ + #ifdef _DEBUG + #define TRACER_LOG_METHOD 1 // for WINS UDEB + #else + #define TRACER_LOG_METHOD 0 // for WINS UREL + #endif +#else + #ifdef _DEBUG + #define TRACER_LOG_METHOD 2 // for Armv5 UDEB + #else + #define TRACER_LOG_METHOD 0 // for Armv5 UREL + #endif +#endif + +#endif + +// -------------------------------------------------------------------------- +// Whether to use TRAP_INSTRUMENTATIONs to +// log trapped leaves +// -------------------------------------------------------------------------- +// +#define TRACE_TRAPS +//============================================================================ + +// Logging off, define empty macros and skip all the rest +#if TRACER_LOG_METHOD == 0 + +#define TRACER(func) +#define TRACER_AUTO +#define TRACER_RET(func,format) +#define TRACER_AUTO_RET(format) +#define TRACER_LEAVE(func) +#define TRACER_AUTO_LEAVE +#define TRACE(args...) +#define TRACE8(args...) +#define TRACER_TO16(a,b) +#define TRACER_TO8(a,b) +#define TRACER_CLOSELOG + +#else // Logging on + +// -------------------------------------------------------------------------- +// Change these to modify line syntax +// -------------------------------------------------------------------------- +// +_LIT( KLogBase, "UiServiceTab %S(%d): %S"); +_LIT( KLogEnter, "UiServiceTab %S: ENTER" ); +_LIT( KLogExit, "UiServiceTab %S: EXIT" ); +_LIT( KLogLeave, "UiServiceTab %S: LEAVE!" ); +_LIT( KLogTrappedLeave, "UiServiceTab %S(%d): TRAPPED LEAVE, code %d!" ); +_LIT( KLogExitRet, "UiServiceTab %S: EXIT, Returning " ); +_LIT( KLogDir, "UiServiceTab" ); +_LIT( KLogFile, "UiServiceTab.log" ); + +#define TRACER_PARAMS_LENGTH 200 + +// -------------------------------------------------------------------------- +// Macro to print only function leaves (not entries or exits). +// Example: TRACER_LEAVE( "CMyClass::MyFunction" ); +// -------------------------------------------------------------------------- +// +#define TRACER_LEAVE(func) TTracer function_tracer( _S(func), _S(""), EFalse ) + +// -------------------------------------------------------------------------- +// Same as above, except that function name is generated automatically +// Example: TRACER_AUTO_LEAVE; +// -------------------------------------------------------------------------- +// +#define TRACER_AUTO_LEAVE TTracer \ + function_tracer( ((const TText8*)__PRETTY_FUNCTION__), _S(""), EFalse ) + +// -------------------------------------------------------------------------- +// Macro to print function entry, exit and leave. +// Example: TRACER( "CMyClass::MyFunction" ); +// -------------------------------------------------------------------------- +// +#define TRACER(func) TTracer function_tracer( _S(func), _S(""), ETrue ) + +// -------------------------------------------------------------------------- +// Same as above, except that function name is generated automatically +// Example: TRACER_AUTO; +// -------------------------------------------------------------------------- +// +#define TRACER_AUTO \ + TTracer function_tracer \ + ( ((const TText8*)__PRETTY_FUNCTION__), _S(""), ETrue ) + +// -------------------------------------------------------------------------- +// Macro to print function return value in addition to entry, exit +// and leave conditions. Second parameter is a formatting string used +// to print the return value Example to print an integer return value: +// TRACER_RET("CMyclass::MyFunction", "%d"); +// -------------------------------------------------------------------------- +// +#define TRACER_RET(func,format) \ + TTracer function_tracer( _S(func), _S(format), ETrue ) + +// -------------------------------------------------------------------------- +// Same as above, except that function name is generated automatically +// Example: TRACER_AUTO_RET( "%d" ); +// -------------------------------------------------------------------------- +// +#define TRACER_AUTO_RET(format) \ + TTracer function_tracer \ + ( ((const TText8*)__PRETTY_FUNCTION__), _S(format), ETrue ) + +// -------------------------------------------------------------------------- +// Macro to print custom msg with any number of parameters +// Either TRACER, TRACER_RET or TRACER_LEAVE +// must be called before in same scope +// It's is assumed that descriptor (pointer) parameters are 16-bit +// NOTE: It is also assumed that parameter values +// add no more than TRACE_PARAMS_LENGTH to the traced string +// -------------------------------------------------------------------------- +// +#define TRACE( args... ) function_tracer.trace( __LINE__, ## args ) + +// -------------------------------------------------------------------------- +// Macro to print custom msg with any number of parameters +// Either TRACER, TRACER_RET or TRACER_LEAVE +// must be called before in same scope +// It's is assumed that descriptor (pointer) parameters are 8-bit +// NOTE: It is also assumed that parameter values +// add no more than TRACE_PARAMS_LENGTH to the traced string +// -------------------------------------------------------------------------- +// +#define TRACE8( args... ) function_tracer.trace8(__LINE__, ## args ) + +// -------------------------------------------------------------------------- +// Just to quickly convert descriptors if needed +// -------------------------------------------------------------------------- +// +#define DESCRIPTOR_LENGTH 100 +#define TRACER_TO16( desc8, desc16 ) \ + TBuf desc16;desc16.Copy(desc8) +#define TRACER_TO8( desc16, desc8 ) \ + TBuf8 desc8;desc8.Copy(desc16) + +#ifdef TRACE_TRAPS +#undef TRAP_INSTRUMENTATION_LEAVE +#define TRAP_INSTRUMENTATION_LEAVE(aResult) \ + TTracer::static_trace( ((const TText8*)__PRETTY_FUNCTION__), \ + __LINE__, aResult ) +#endif + + +#if TRACER_LOG_METHOD == 1 // Print to RDebug + +#include + +#define TRACER_PRINT(a) RDebug::Print(a,&iFunc); +#define TRACER_PRINT_BASE(a,b,c) RDebug::Print(a,&iFunc, b, c); +#define TRACER_PRINT_RET(a,b) RDebug::Print(a,&iFunc,b); +#define TRACER_PRINT_STATIC(a, b, c,d ) \ + RDebug::Print(a, b, c, d); + +#elif TRACER_LOG_METHOD == 2 // Print to file + + // needs flogger.lib as DEBUGLIBRARY + +// -------------------------------------------------------------------------- +// Log directory under C:\logs +// -------------------------------------------------------------------------- +// +//_LIT( KLogDir, "MeCo" ); + +// -------------------------------------------------------------------------- +// Log filename in log directory +// -------------------------------------------------------------------------- +// +//_LIT( KLogFile, "MeCo.log" ); +#define TRACER_PRINT(a) RFileLogger::WriteFormat(KLogDir, \ + KLogFile,EFileLoggingModeAppend,a,&iFunc); +#define TRACER_PRINT_BASE(a,b,c) RFileLogger::WriteFormat(KLogDir, \ + KLogFile,EFileLoggingModeAppend,a,&iFunc,b,c); +#define TRACER_PRINT_RET(a,b) RFileLogger::WriteFormat(KLogDir, \ + KLogFile,EFileLoggingModeAppend,a,&iFunc,b); +#define TRACER_PRINT_STATIC(a,b,c,d) \ + RFileLogger::WriteFormat(KLogDir, \ + KLogFile,EFileLoggingModeAppend,a,b,c,d); + +#endif + + +/** + * Simple tracer class that logs function enter, exit or leave + */ +class TTracer : public CBase + { +private: + + /** + * Simple helper method to just return if NULL + */ + template static void ReturnIfNull(T* aNy) + { if ( !aNy ) return; } + +public: + /** + * inline constructor to write log of entering a function + */ + TTracer( const TText* aFunc, + const TText* aRetFormat, + TBool aPrintEnter) : + iFunc( aFunc), + iRetFormat( aRetFormat ), + iPrintEnterAndExit( aPrintEnter) + { + iFuncBuf = NULL; + //iLogger.Connect(); + //iLogger.CreateLog(KLogDir, KLogFile, mode); + if ( iPrintEnterAndExit ) + { + TRACER_PRINT( KLogEnter ); + } + } + + /** + * inline constructor to write log of entering a function (8-bit) + */ + TTracer( const TText8* aFunc, + const TText* aRetFormat, + TBool aPrintEnter) : + iRetFormat( aRetFormat ), + iPrintEnterAndExit( aPrintEnter ) + { + TInt len = User::StringLength ((const unsigned char*)aFunc ); + HBufC8* temp = HBufC8::New( len ); + ReturnIfNull( temp ); + *temp = (const TUint8*)aFunc; + iFuncBuf = HBufC::NewL( len ); + //iLogger.Connect(); + //iLogger.CreateLog(KLogDir, KLogFile, EFileLoggingModeAppend); + if ( iFuncBuf ) + { + iFuncBuf->Des().Copy( *temp ); + iFunc.Set( *iFuncBuf ); + if ( iPrintEnterAndExit ) + { + TRACER_PRINT( KLogEnter ); + } + } + delete temp; + } + + + /** + * inline destructor to write log of exiting a function + * normally or with a leave + */ + ~TTracer( ) + { + if ( std::uncaught_exception ( ) ) // Leave is an exception + { + // The function exited with a leave + TRACER_PRINT( KLogLeave ); + } + else + { + // The function exited normally + if ( iPrintEnterAndExit ) + { + if ( iRetFormat.Length ( )== 0 ) + { + TRACER_PRINT( KLogExit ); + } + else + { + // Log the return value +#ifdef __WINS__ + TInt32 retVal = 0; + + // The assembly bit. This needs to be reimplemented + // for every target. + _asm( mov retVal, ebx ); + + TBuf<100> format( KLogExitRet ); + format.Append( iRetFormat ); + TRACER_PRINT_RET( format, retVal ); +#else + // ARM assembler to get return value + // could be implemented here.. + TRACER_PRINT( KLogExit ); +#endif + } + } + } + //iLogger.Close(); + delete iFuncBuf; + } + +public: + + /** + * Trace method that assumes 16-bit descriptor parameters + */ + void trace( TInt aLine, const char* aMsg, ... ) + { + ReturnIfNull( iFunc.Ptr() ); + TInt len = User::StringLength ((const unsigned char*)aMsg ); + TPtrC8 msg( (const unsigned char*)aMsg, len ); + HBufC* format = HBufC::New( len ); + ReturnIfNull( format ); + format->Des().Copy( msg ); + HBufC* result = HBufC::New( len + TRACER_PARAMS_LENGTH ); + if ( result ) + { + VA_LIST list; + VA_START( list, aMsg ); + result->Des().FormatList( *format, list ); + VA_END(list); + TRACER_PRINT_BASE(KLogBase, aLine, result ); + } + delete format; + delete result; + } + + /** + * Trace method that assumes 8-bit descriptor parameters + */ + void trace8(TInt aLine, const char* aMsg, ... ) + { + ReturnIfNull( iFunc.Ptr() ); + TInt len = User::StringLength ((const unsigned char*)aMsg ); + TPtrC8 msg( (const unsigned char*)aMsg, len ); + HBufC8* result8 = HBufC8::New( len + TRACER_PARAMS_LENGTH ); + ReturnIfNull( result8 ); + VA_LIST list; + VA_START( list, aMsg ); + result8->Des().FormatList( msg, list ); + VA_END(list); + HBufC* result16 = HBufC::New( result8->Length() ); + if ( result16 ) + { + result16->Des().Copy( *result8 ); + TRACER_PRINT_BASE( KLogBase, aLine, result16 ); + } + delete result8; + delete result16; + } + + static void static_trace( const TText8* aFunc, + TInt aLine, + TInt aResult ) + { + TInt len = User::StringLength ((const unsigned char*)aFunc ); + HBufC8* temp = HBufC8::New( len ); + ReturnIfNull( temp ); + *temp = (const TUint8*)aFunc; + HBufC* funcBuf = HBufC::NewL( len ); + if ( funcBuf ) + { + funcBuf->Des().Copy( *temp ); + TRACER_PRINT_STATIC( + KLogTrappedLeave, funcBuf, aLine, aResult ); + } + delete temp; + delete funcBuf; + } +public: + + /** + * Pointer descriptor to function signature that is to be logged. + */ + TPtrC iFunc; + //RFileLogger iLogger; + +private: + + + /** + * Formatting string used to print the function return value + */ + TPtrC iRetFormat; + + /** + * If true, method enters and exits are printed + */ + TBool iPrintEnterAndExit; + + /** + * Buffer to store function name when needed + */ + HBufC* iFuncBuf; + }; + +#endif // TRACER_LOG_METHOD != 0 && CHAT_ENABLE_DEBUG_PRINT + +#endif // UISERVICETABTRACER_H + +// End of file