diff -r 000000000000 -r 29b1cd4cb562 bluetooth/btlogger/generic/public/logger.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bluetooth/btlogger/generic/public/logger.h Fri Jan 15 08:13:17 2010 +0200 @@ -0,0 +1,282 @@ +// Copyright (c) 2005-2009 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 + @internalTechnology +*/ + + +#ifndef LOGGER_H +#define LOGGER_H + +// Enable __UREL_RDEBUG_PRINT to allow method entry / exit logging to +// be output for UREL builds through epocwind.out (for emulator) and +// the debugport for hardware. +//#define __UREL_RDEBUG_PRINT + +#include +#include +#include // standard component string definitions + +// Control function entry and exit logging using a compile-time switch. +#ifndef __FLOG_NO_FUNC // Declare this macro in an mmp file to disable function logging +#define __LOG_FUNCTIONS__ +#endif + +class TFunctionLogger; + +#ifdef __FLOG_ACTIVE +#define IF_FLOGGING(a) a +#else +#define IF_FLOGGING(a) +#endif + +// Undefine if defined by comms-infras +#ifdef LOG +#undef LOG +#endif + +// Undefine if defined by comms-infras +#ifdef FLOG +#undef FLOG +#endif + +_LIT8(KDefaultLogFile, "BT"); + +#ifdef __FLOG_ACTIVE +#define CONNECT_LOGGER static_cast(CBtLog::Connect()); +#define CLOSE_LOGGER CBtLog::Close(); +#define LEAVEIFERRORL(a) VerboseLeaveIfErrorL(KLogComponent, __FILE__, __LINE__, a) +#define LEAVEL(a) VerboseLeaveL(KLogComponent, __FILE__, __LINE__, a) +#define PANIC(CAT, CODE) VerbosePanic(KLogComponent, __FILE__, __LINE__, CODE, (TText8*)#CODE, CAT) +#define PANIC_MSG(msg, cat, code) VerboseMsgPanic(KLogComponent, __FILE__, __LINE__, msg, cat, code); +#define FLOG(a) CBtLog::Write(KDefaultLogFile, a); + +#define FTRACE(a) {a;} +#define LOG(text) CBtLog::Write(KLogComponent, text); +#define LOG1(text, a) CBtLog::WriteFormat(KLogComponent, text, a); +#define LOG2(text, a, b) CBtLog::WriteFormat(KLogComponent, text, a, b); +#define LOG3(text, a, b, c) CBtLog::WriteFormat(KLogComponent, text, a, b, c); +#define LOG4(text, a, b, c, d) CBtLog::WriteFormat(KLogComponent, text, a, b, c, d); +#define LOG5(text, a, b, c, d, e) CBtLog::WriteFormat(KLogComponent, text, a, b, c, d, e); +#define LOG6(text, a, b, c, d, e, f) CBtLog::WriteFormat(KLogComponent, text, a, b, c, d, e, f); +#define LOGHEXDESC(desc) CBtLog::HexDump(KLogComponent, 0, 0, desc.Ptr() , desc.Length()); +#define LOGHEXRAW(data, len) CBtLog::HexDump(KLogComponent, 0, 0, data, len); +#define FLOGIFERR(var,text) { if (KErrNone!=var) {CBtLog::Write(KLogComponent, text);}} +#define DUMPFRAME(text) {LOG(text);TInt _lctr = this->Length();if(_lctr){for(TInt _ictr = 0; _ictr < _lctr; ++_ictr){LOG2(_L8("....[%d] = %02x"),_ictr,this->First()->Ptr()[_ictr]);}}} +#define LOG_BT(aa, bb) {TBuf8<20> addr1; addr1.Format(_L8("%02x:%02x:%02x:%02x:%02x:%02x"), bb[0], bb[1], bb[2], bb[3], bb[4], bb[5]); LOG1(aa, &addr1); } +#else +#define CONNECT_LOGGER +#define CLOSE_LOGGER +#define LEAVEIFERRORL(a) static_cast(User::LeaveIfError(a)) +#define LEAVEL(a) User::Leave(a) +#define PANIC(CAT, CODE) User::Panic(CAT, CODE) +#define PANIC_MSG(msg, cat, code) msg.Panic(cat, code); +#define FLOG(a) +#define FTRACE(a) +#define LOG(text) +#define LOG1(text, a) +#define LOG2(text, a, b) +#define LOG3(text, a, b, c) +#define LOG4(text, a, b, c, d) +#define LOG5(text, a, b, c, d, e) +#define LOG6(text, a, b, c, d, e, f) +#define LOGHEXDESC(desc) +#define LOGHEXRAW(data, len) +#define FLOGIFERR(var,text) {var=var;} +#define DUMPFRAME(text) +#define LOG_BT(aa, bb) +#endif // __FLOG_ACTIVE + +#define FORCED_LOG_FUNC TFunctionLogger __instrument(KLogComponent, TPtrC8((TUint8*)__PRETTY_FUNCTION__), (TAny*)this); +#define FORCED_LOG_STATIC_FUNC TStaticFunctionLogger __instrument(KLogComponent, TPtrC8((TUint8*)__PRETTY_FUNCTION__)); + +#if ( defined __FLOG_ACTIVE && defined __LOG_FUNCTIONS__ ) +#define LOG_LINE CBtLog::Write(KLogComponent, KNullDesC8()); +#define LOG_FUNC FORCED_LOG_FUNC +#define LOG_STATIC_FUNC FORCED_LOG_STATIC_FUNC +#else +#if ( defined __UREL_RDEBUG_PRINT && !defined _DEBUG ) +#include +_LIT8(KLogComponent, "RDebugOutput"); +#define LOG_LINE RDebug::Printf("%S", &KLogComponent()); +#define LOG_FUNC FORCED_LOG_FUNC +#define LOG_STATIC_FUNC FORCED_LOG_STATIC_FUNC +#else +#define LOG_LINE +#define LOG_FUNC +#define LOG_STATIC_FUNC +#endif +#endif + +inline void __BTDEBUGGER() +// needed to call __DEBUGGER inside an __ASSERT + { + __DEBUGGER() + } + +// Logs the TBTDevAddr x. +#define LOGBTDEVADDR(x) LOG6(_L8("\t" #x " = 0x%02x%02x%02x%02x%02x%02x"),x[0],x[1],x[2],x[3],x[4],x[5]) + + +// For internal programming errors we want a macro which uses a file-specific +// panic category and __LINE__ as the panic code. +// To make this non-standard pattern as helpful to users as possible, we +// append ' line#' to the category. That means we first have to check that the +// category is 10 characters long or less, so that the whole thing is legible +// when it appears to users (panic categories are truncated to 16 characters). + +// We want a 10-character string (but allow for the NULL terminator). +#define PANICCATEGORY(aaa) __ASSERT_COMPILE(sizeof(L##aaa)/2 <= 11); _LIT(KMungedPanicCat, aaa) + +// A handy panic-self macro- the category is whatever has been declared with +// BTPANICCATEGORY, with " line#" appended. The panic code is the line number. +#define PANIC_LINENUM \ + { \ + _LIT(KLnNo, " line#"); \ + TBuf cat = KMungedPanicCat(); \ + cat.Append(KLnNo()); \ + PANIC(cat, __LINE__); \ + } + +// A handy assertion macro that panics with a locally-defined panic category +// and the line number. +#define ASSERT_ALWAYS(a) \ + { \ + if ( !(a) ) \ + { \ + PANIC_LINENUM; \ + } \ + } + +#ifdef _DEBUG +#define ASSERT_DEBUG(a) ASSERT_ALWAYS(a) +#define DEBUG_PANIC_LINENUM PANIC_LINENUM +#else +#define ASSERT_DEBUG(a) +#define DEBUG_PANIC_LINENUM +#endif // _DEBUG + +// Undefine the e32def.h-defined ASSERT macro to make sure no-one uses it. +// Use the more informative ASSERT_DEBUG (defined above) or the vanilla +// __ASSERT_DEBUG instead! +// #undef ASSERT + + +NONSHARABLE_CLASS(CBtLog) : public CBase + { +public: + IMPORT_C static TInt Connect(); + IMPORT_C static void Close(); + + IMPORT_C static void Write(const TDesC8& aCmpt, const TDesC8& aText); + IMPORT_C static void WriteFormat(const TDesC8& aCmpt, TRefByValue aFmt, ...); + IMPORT_C static void WriteFormat(const TDesC8& aCmpt, TRefByValue aFmt, VA_LIST& aList); + IMPORT_C static void Write(const TDesC8& aCmpt, const TDesC16& aText); + IMPORT_C static void WriteFormat(const TDesC8& aCmpt, TRefByValue aFmt, ...); + IMPORT_C static void WriteFormat(const TDesC8& aCmpt, TRefByValue aFmt, VA_LIST& aList); + IMPORT_C static void HexDump(const TDesC8& aCmpt, const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen); + }; + + +#ifndef NO_FPRINT +inline void FPrint(const TRefByValue IF_FLOGGING(aFmt), ...) + { +#ifdef __FLOG_ACTIVE + VA_LIST list; + VA_START(list,aFmt); + CBtLog::WriteFormat(KDefaultLogFile, aFmt, list); +#endif + } +#endif + + +#ifndef NO_FHEX_PTR +inline void FHex(const TUint8* IF_FLOGGING(aPtr), TInt IF_FLOGGING(aLen)) + { +#ifdef __FLOG_ACTIVE + CBtLog::HexDump(KDefaultLogFile, 0, 0, aPtr, aLen); +#endif + } +#endif + + +#ifndef NO_FHEX_DESC +inline void FHex(const TDesC8& IF_FLOGGING(aDes)) + { +#ifdef __FLOG_ACTIVE + FHex(aDes.Ptr(), aDes.Length()); +#endif + } +#endif + + +IMPORT_C void VerboseLeaveIfErrorL(const TDesC8& aCpt, + char* aFile, + TInt aLine, + TInt aReason); + +IMPORT_C void VerboseLeaveL(const TDesC8& aCpt, + char* aFile, + TInt aLine, + TInt aReason); + +IMPORT_C void VerboseMsgPanic(const TDesC8& aCpt, + char* aFile, + TInt aLine, + const RMessage2& aMsg, + const TDesC& aCat, + TInt aPanicCode); + + +IMPORT_C void VerbosePanic(const TDesC8& aCpt, + char* aFile, + TInt aLine, + TInt aPanicCode, + TText8* aPanicName, + const TDesC& aPanicCategory); + +static const TInt KMaxIndent = 60; + +NONSHARABLE_CLASS(TLoggerBase) + { +protected: + TUint PreIncrementIndent(); + TUint PostDecrementIndent(); + TUint Indent(); + +protected: + TBuf8 iIndentBuf; + TPtrC8 iCpt; + TPtrC8 iString; + }; + +NONSHARABLE_CLASS(TFunctionLogger) : public TLoggerBase + { +public: + IMPORT_C TFunctionLogger(const TDesC8& aCpt, const TDesC8& aString, TAny* aThis); + IMPORT_C ~TFunctionLogger(); + }; + +NONSHARABLE_CLASS(TStaticFunctionLogger) : public TLoggerBase + { +public: + IMPORT_C TStaticFunctionLogger(const TDesC8& aCpt, const TDesC8& aString); + IMPORT_C ~TStaticFunctionLogger(); + }; + +#endif // LOGGER_H +