--- /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 <e32std.h>
+#include "C32LOG.H"
+#include "cs_glob.h"
+
+#if (defined __FLOG_ACTIVE)
+
+#include <cflog.h>
+
+template <class T> void DoWrite(TBool aStatic, const TDesC8& aSubTag, T& aBuf);
+
+EXPORT_C void TC32Log::Printf(TBool aStatic, const TDesC8& aSubTag, TRefByValue<const TDesC8> 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<const TDesC8> aFmt, VA_LIST& aList)
+ {
+ TBuf8<KLogBufferSize> 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<TDes8>(aStatic, aSubTag, buf);
+ }
+
+
+
+
+EXPORT_C void TC32Log::Printf(TBool aStatic, const TDesC8& aSubTag, TRefByValue<const TDesC> 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<const TDesC> aFmt, VA_LIST& aList)
+/**
+Write a mulitple argument list to the log, trapping and ignoring any leave
+
+*/
+ {
+ TBuf<KLogBufferSize> 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<TDes>(aStatic, aSubTag, buf);
+ }
+
+template <class T> 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<const TDesC> /* aFmt */, ...)
+ {
+
+ }
+EXPORT_C void TC32Log::Printf(TBool /* aStatic */, const TDesC8& /* aSubTag */, TRefByValue<const TDesC8> /* aFmt */, ...)
+ {
+
+ }
+
+#endif // __FLOG_ACTIVE
+