diff -r 000000000000 -r dfb7c4ff071f serialserver/c32serialserver/SCOMM/CS_LOG.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/serialserver/c32serialserver/SCOMM/CS_LOG.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,431 @@ +// Copyright (c) 2003-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: +// + +#include +#include "C32LOG.H" +#include "cs_glob.h" + +#if (defined __FLOG_ACTIVE) + +#include + +template void DoWrite(TBool aStatic, const TDesC8& aSubTag, T& aBuf); + +EXPORT_C void TC32Log::Printf(TBool aStatic, const TDesC8& aSubTag, TRefByValue aFmt, ...) + { + VA_LIST list; + VA_START(list,aFmt); + Printf(aStatic, aSubTag, aFmt, list); + VA_END(list); + } + + +void TC32Log::Printf(TBool aStatic, const TDesC8& aSubTag, TRefByValue aFmt, VA_LIST& aList) + { + TBuf8 buf; + CTLSRedirector* tls = CRedirectorInTls(); + if ((tls) && tls->IsC32GlobalDataSet()) + { + CC32WorkerThread* worker = tls->C32GlobalData()->SelfWorker(); + if(worker) + { + _LIT8(KWorkerIdFormat, "W%d: "); + buf.Format(KWorkerIdFormat, worker->WorkerId()); + } + } + + TLogIgnoreOverflow8 overflowHandler; + buf.AppendFormatList(aFmt, aList, &overflowHandler); + DoWrite(aStatic, aSubTag, buf); + } + + + + +EXPORT_C void TC32Log::Printf(TBool aStatic, const TDesC8& aSubTag, TRefByValue aFmt, ...) + { + VA_LIST list; + VA_START(list,aFmt); + Printf(aStatic, aSubTag, aFmt, list); + VA_END(list); + } + + + + +void TC32Log::Printf(TBool aStatic, const TDesC8& aSubTag, TRefByValue aFmt, VA_LIST& aList) +/** +Write a mulitple argument list to the log, trapping and ignoring any leave + +*/ + { + TBuf buf; + CTLSRedirector* tls = CRedirectorInTls(); + if ((tls) && tls->IsC32GlobalDataSet()) + { + CC32WorkerThread* worker = tls->C32GlobalData()->SelfWorker(); + if(worker) + { + _LIT(KWorkerIdFormat, "W%d: "); + buf.Format(KWorkerIdFormat, worker->WorkerId()); + } + } + + TLogIgnoreOverflow16 overflowHandler; + buf.AppendFormatList(aFmt, aList, &overflowHandler); + DoWrite(aStatic, aSubTag, buf); + } + +template void DoWrite(TBool aStatic, const TDesC8& aSubTag, T& aBuf) + { + if(!aBuf.Length()) + return; + + if(aStatic) + { + __FLOG_STATIC_VA ((KC32SubSystem, aSubTag, aBuf)); + } + else + { + CCFLogIf::Write(KC32SubSystem, aSubTag, aBuf); + } + } + + +_LIT8(KLitCommAccessExclusive, "ECommExclusive"); +_LIT8(KLitCommAccessShared, "ECommShared"); +_LIT8(KLitCommAccessPreemptable, "ECommPreemptable"); +_LIT8(KLitCommAccessUnsupported, "**Unsupported**"); + + + +/** +Returns a string for a comm access mode + +@param aMode Comm Access Mode +@return String name representation of aMode +*/ +const TDesC8& TC32Log::CommAccessStr(const TCommAccess& aMode) + { + switch(aMode) + { + case ECommExclusive: + return KLitCommAccessExclusive; + case ECommShared: + return KLitCommAccessShared; + case ECommPreemptable: + return KLitCommAccessPreemptable; + default: + return KLitCommAccessUnsupported; + } + } + +_LIT(KLitCommAccessExclusive16, "ECommExclusive"); +_LIT(KLitCommAccessShared16, "ECommShared"); +_LIT(KLitCommAccessPreemptable16, "ECommPreemptable"); +_LIT(KLitCommAccessUnsupported16, "**Unsupported**"); + + +const TDesC& TC32Log::CommAccessStr16(const TCommAccess& aMode) +// in some cases it is nice to be able to have the mode with the name of the module/port. +// However, to get it onto one log line without fuss the whole log string needs to be 16-bits +// since the module/port is a TDesC, so instead we provide a 16-bit version of this function. + { + switch(aMode) + { + case ECommExclusive: + return KLitCommAccessExclusive16; + case ECommShared: + return KLitCommAccessShared16; + case ECommPreemptable: + return KLitCommAccessPreemptable16; + default: + return KLitCommAccessUnsupported16; + } + } + + +_LIT8(KLitIntCommExclusive, "EIntCommExclusive"); +_LIT8(KLitIntCommShared, "EIntCommShared"); +_LIT8(KLitIntCommPreemptable, "EIntCommPreemptable"); +_LIT8(KLitIntCommWaitUntilAvailable,"EIntCommWaitUntilAvailable"); +_LIT8(KLitIntCommUnsupported, "**Unsupported**"); + + + +/** +Returns a string for a internal comm access mode + +@param aMode Internal Comm Access Mode +@return readable string for aMode +*/ +const TDesC8& TC32Log::InternalCommAccessStr(TInternalCommAccess aMode) + { + switch(aMode) + { + case EIntCommExclusive: + return KLitIntCommExclusive; + case EIntCommShared: + return KLitIntCommShared; + case EIntCommPreemptable: + return KLitIntCommPreemptable; + case EIntCommWaitUntilAvailable: + return KLitIntCommWaitUntilAvailable; + default: + return KLitIntCommUnsupported; + } + } + + + +_LIT8(KLitCommRoleDTE, "ECommRoleDTE"); +_LIT8(KLitCommRoleDCE, "ECommRoleDCE"); +_LIT8(KLitCommRoleUnsupported, "**Unsupported**"); + + +/** +Returns a string for a comm role + +@param aRole Comm Role +@return readable string for aRole +*/ +const TDesC8& TC32Log::CommRoleStr(TCommRole aRole) + { + switch(aRole) + { + case ECommRoleDTE: + return KLitCommRoleDTE; + case ECommRoleDCE: + return KLitCommRoleDCE; + default: + return KLitCommRoleUnsupported; + } + } + + +_LIT(KLitCommRoleDTE16, "ECommRoleDTE"); +_LIT(KLitCommRoleDCE16, "ECommRoleDCE"); +_LIT(KLitCommRoleUnsupported16, "**Unsupported**"); + + +/** +Returns a string for a comm role + +@param aRole Comm Role +@return readable string for aRole +*/ +const TDesC& TC32Log::CommRoleStr16(TCommRole aRole) + { + switch(aRole) + { + case ECommRoleDTE: + return KLitCommRoleDTE16; + case ECommRoleDCE: + return KLitCommRoleDCE16; + default: + return KLitCommRoleUnsupported16; + } + } + + +_LIT8(KLitCommLoadCommModule,"ECommLoadCommModule"); +_LIT8(KLitCommCloseCommModule,"ECommCloseCommModule"); +_LIT8(KLitCommPortInfo, "ECommPortInfo"); +_LIT8(KLitCommPortInfoByName,"ECommPortInfoByName"); +_LIT8(KLitCommPortInfoByNumber,"ECommPortInfoByNumber"); +_LIT8(KLitCommNumPorts,"ECommNumPorts"); + +_LIT8(KLitCommStartServerThread,"ECommStartServerThread"); +_LIT8(KLitCommOpen,"ECommOpen"); +_LIT8(KLitCommRead,"ECommRead"); +_LIT8(KLitCommReadCancel,"ECommReadCancel"); +_LIT8(KLitCommQueryReceiveBuffer,"ECommQueryReceiveBuffer"); + +_LIT8(KLitCommResetBuffers,"ECommResetBuffers"); +_LIT8(KLitCommWrite,"ECommWrite"); +_LIT8(KLitCommWriteCancel,"ECommWriteCancel"); +_LIT8(KLitCommBreak,"ECommBreak"); +_LIT8(KLitCommBreakCancel,"ECommBreakCancel"); +_LIT8(KLitCommCancel,"ECommCancel"); +_LIT8(KLitCommConfig,"ECommConfig"); +_LIT8(KLitCommSetConfig,"ECommSetConfig"); +_LIT8(KLitCommCaps,"ECommCaps"); +_LIT8(KLitCommSetMode,"ECommSetMode"); + +_LIT8(KLitCommGetMode,"ECommGetMode"); +_LIT8(KLitCommSignals,"ECommSignals"); +_LIT8(KLitCommSetSignalsToMark,"ECommSetSignalsToMark"); +_LIT8(KLitCommSetSignalsToSpace,"ECommSetSignalsToSpace"); +_LIT8(KLitCommReceiveBufferLength,"ECommReceiveBufferLength"); +_LIT8(KLitCommSetReceiveBufferLength,"ECommSetReceiveBufferLength"); +_LIT8(KLitCommClose,"ECommClose"); +_LIT8(KLitCommDbgMarkHeap,"ECommDbgMarkHeap"); +_LIT8(KLitCommDbgCheckHeap,"ECommDbgCheckHeap"); +_LIT8(KLitCommDbgMarkEnd,"ECommDbgMarkEnd"); + +_LIT8(KLitCommDbgFailNext,"ECommDbgFailNext"); +_LIT8(KLitCommDbgSetDebugPrintMask,"ECommDbgSetDebugPrintMask"); +_LIT8(KLitCommDbgDoDumpDebugInfo,"ECommDbgDoDumpDebugInfo"); + +_LIT8(KLitCommGetRole,"ECommGetRole"); +_LIT8(KLitCommNotifySignals,"ECommNotifySignals"); +_LIT8(KLitCommNotifySignalsCancel,"ECommNotifySignalsCancel"); +_LIT8(KLitCommNotifyFlowControl,"ECommNotifyFlowControl"); +_LIT8(KLitCommNotifyFlowControlCancel,"ECommNotifyFlowControlCancel"); +_LIT8(KLitCommGetFlowControl,"ECommGetFlowControl"); +_LIT8(KLitCommNotifyConfigChange,"ECommNotifyConfigChange"); + +_LIT8(KLitCommNotifyConfigChangeCancel,"ECommNotifyConfigChangeCancel"); +_LIT8(KLitCommNotifyBreak,"ECommNotifyBreak"); +_LIT8(KLitCommNotifyBreakCancel,"ECommNotifyBreakCancel"); +_LIT8(KLitCommNotifyDataAvailable,"ECommNotifyDataAvailable"); +_LIT8(KLitCommNotifyDataAvailableCancel,"ECommNotifyDataAvailableCancel"); +_LIT8(KLitCommNotifyOutputEmpty,"ECommNotifyOutputEmpty"); +_LIT8(KLitCommNotifyOutputEmptyCancel,"ECommNotifyOutputEmptyCancel"); + +_LIT8(KLitCommSetAccess,"ECommSetAccess"); +_LIT8(KLitCommDebugState,"ECommDebugState"); +_LIT8(KLitCommOpenWhenAvailable,"ECommOpenWhenAvailable"); + +_LIT8(KLitCommReqUnsupported, "**Unsupported**"); + +/** +Returns a string for C32 IPC Requests. + +@param aIPC IPC code +@return readable string for IPC request name +*/ +const TDesC8& TC32Log::C32RequestStr(TInt aIPC) + { + switch(aIPC) + { + case ECommLoadCommModule: + return KLitCommLoadCommModule; + case ECommCloseCommModule: + return KLitCommCloseCommModule; + case ECommPortInfo: + return KLitCommPortInfo; + case ECommPortInfoByName: + return KLitCommPortInfoByName; + case ECommPortInfoByNumber: + return KLitCommPortInfoByNumber; + case ECommNumPorts: + return KLitCommNumPorts; + case ECommStartServerThread: + return KLitCommStartServerThread; + case ECommOpen: + return KLitCommOpen; + case ECommRead: + return KLitCommRead; + case ECommReadCancel: + return KLitCommReadCancel; + case ECommQueryReceiveBuffer: + return KLitCommQueryReceiveBuffer; + case ECommResetBuffers: + return KLitCommResetBuffers; + case ECommWrite: + return KLitCommWrite; + case ECommWriteCancel: + return KLitCommWriteCancel; + case ECommBreak: + return KLitCommBreak; + case ECommBreakCancel: + return KLitCommBreakCancel; + case ECommCancel: + return KLitCommCancel; + case ECommConfig: + return KLitCommConfig; + case ECommSetConfig: + return KLitCommSetConfig; + case ECommCaps: + return KLitCommCaps; + case ECommSetMode: + return KLitCommSetMode; + case ECommGetMode: + return KLitCommGetMode; + case ECommSignals: + return KLitCommSignals; + case ECommSetSignalsToMark: + return KLitCommSetSignalsToMark; + case ECommSetSignalsToSpace: + return KLitCommSetSignalsToSpace; + case ECommReceiveBufferLength: + return KLitCommReceiveBufferLength; + case ECommSetReceiveBufferLength: + return KLitCommSetReceiveBufferLength; + case ECommClose: + return KLitCommClose; + case ECommDbgMarkHeap: + return KLitCommDbgMarkHeap; + case ECommDbgCheckHeap: + return KLitCommDbgCheckHeap; + case ECommDbgMarkEnd: + return KLitCommDbgMarkEnd; + case ECommDbgFailNext: + return KLitCommDbgFailNext; + case ECommDbgSetDebugPrintMask: + return KLitCommDbgSetDebugPrintMask; + case ECommDbgDoDumpDebugInfo: + return KLitCommDbgDoDumpDebugInfo; + case ECommGetRole: + return KLitCommGetRole; + case ECommNotifySignals: + return KLitCommNotifySignals; + case ECommNotifySignalsCancel: + return KLitCommNotifySignalsCancel; + case ECommNotifyFlowControl: + return KLitCommNotifyFlowControl; + case ECommNotifyFlowControlCancel: + return KLitCommNotifyFlowControlCancel; + case ECommGetFlowControl: + return KLitCommGetFlowControl; + case ECommNotifyConfigChange: + return KLitCommNotifyConfigChange; + case ECommNotifyConfigChangeCancel: + return KLitCommNotifyConfigChangeCancel; + case ECommNotifyBreak: + return KLitCommNotifyBreak; + case ECommNotifyBreakCancel: + return KLitCommNotifyBreakCancel; + case ECommNotifyDataAvailable: + return KLitCommNotifyDataAvailable; + case ECommNotifyDataAvailableCancel: + return KLitCommNotifyDataAvailableCancel; + case ECommNotifyOutputEmpty: + return KLitCommNotifyOutputEmpty; + case ECommNotifyOutputEmptyCancel: + return KLitCommNotifyOutputEmptyCancel; + case ECommSetAccess: + return KLitCommSetAccess; + case ECommDebugState: + return KLitCommDebugState; + case ECommOpenWhenAvailable: + return KLitCommOpenWhenAvailable; + default: + return KLitCommReqUnsupported; + } + } +#else +EXPORT_C void TC32Log::Printf(TBool /* aStatic */, const TDesC8& /* aSubTag */, TRefByValue /* aFmt */, ...) + { + + } +EXPORT_C void TC32Log::Printf(TBool /* aStatic */, const TDesC8& /* aSubTag */, TRefByValue /* aFmt */, ...) + { + + } + +#endif // __FLOG_ACTIVE +