/*

* 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:  Logging behavior

*

*/

#ifndef TSLOGUTILS_H

#define TSLOGUTILS_H

/**

 * NOTE: This file contains the logic related to logging. Change only if you

 * know what you're doing.

 */

#ifdef _DEBUG

#include <e32debug.h>

#include <e32std.h>

static const TUint TSLOGERR   = 2;  /**< Used to create an error message */

// These macros are real macros, that should be used. For temporary purposes, these

// are left out and the logging is done by simple entry logging

#define _TSLOG_UNCONTROLLED_INPUT_MSG  L"%s%d[%x:%x:%x]>%s UNCONTROLLED ENTRY!"

#define _TSLOG_MULTIPLE_ENTRY_MSG      L"%s%d[%x:%x:%x]%s  ADDITIONAL ENTRY!"

#define _TSLOG_UNCONTROLLER_EXIT_MSG   L"%s%d[%x:%x:%x]<%s UNCONTROLLED EXIT!"

#define _TSLOG_MULTIPLE_EXIT_MSG       L"%s%d[%x:%x:%x]%s  ADDITIONAL EXIT!"

#define _TSLOG_TRAP_HARNESS_ENTRY      L"_D%d[%x:%x:%x]TraceFramework: Entering trap harness"

#define _TSLOG_TRAP_HARNESS_EXIT       L"_D%d[%x:%x:%x]TraceFramework: Exiting trap harness"

#define _TSLOG_TRAP_HARNESS_LEAVE      L"_D%d[%x:%x:%x]TraceFramework: ---------- LEAVE OCCURRED !!! ---------- "

#define _TSLOG_API_PREFIX              L"_A"

#define _TSLOG_LOCAL_PREFIX            L"_L"

/**

* @file 

* trace_utils.h contains definitions needed for advanced tracing features.

* Tracing can be customized using the following compile time flags:

* - <b>_DEBUG</b>

*   - With this flag undefined, all traces are disabled

* - <b>__KERNEL_MODE__</b>

*   - if kernel mode flag is defined, kernel macro variants are used (no unicode or shared heap related stuff, faster)

* - <b>DISABLE_SYNTAX_CHECK</b>

*   - If this flag is defined, runtime syntax checking features are disabled from traces

*/

#ifndef DISABLE_SYNTAX_CHECK

    #define _MARK_ENTRY() _dc.inOk=ETrue

    #define _DOINCHK() _dc.DoInChk()

    #define _CHK_MULTIIN() _dc.ChkMultiIn()

    #define _CHK_MULTIOUT() _dc.ChkMultiOut()

    #define _MARK_EXIT() _dc.outOk=ETrue

#else

    #define _MARK_ENTRY()

    #define _DOINCHK()

    #define _CHK_MULTIIN()

    #define _CHK_MULTIOUT()

    #define _MARK_EXIT()

#endif // DISABLE_SYNTAX_CHECK

/** For tracing */

#ifdef _TSLOG_RDEBUG

    #define _IT(a) (TPtrC((const TText *)(a)))

    #define _TSLOGPRINTER RDebug::Print        

/** For filedebug */

#else   // _TSLOG_RDEBUG

    /** Includes */

    #include <e32base.h>

    #include <e32std.h>

    #include <e32def.h>

    #include <e32svr.h>

// both of headers defines KLogBufferSize

#ifndef __COMMSDEBUGUTILITY_H__

    #include <flogger.h>

#endif

    #define _IT(a) KTsLogPath, KTsLogFile, EFileLoggingModeAppend, (TPtrC((const TText *)(a)))    

    #define _TSLOGPRINTER RFileLogger::WriteFormat    

#endif // _TSLOG_RDEBUG    

class _TTsLogContext

    {

    public:

        _TTsLogContext(

            const TText* _fn, 

            const TUint _id, 

            const TUint _vis, 

            const TUint _addr, 

            const TUint _thdId, 

            const TUint _category=0 )

            : 

            iFn(_fn), 

            iId(_id), 

            iApi((TBool)_vis), 

            iAddr(_addr), 

            iThdId(_thdId), 

            iVis((_vis == 0 ? (TText*)_TSLOG_API_PREFIX : (TText*)_TSLOG_LOCAL_PREFIX)),

            iCategory(_category)            

        #ifndef DISABLE_SYNTAX_CHECK

            ,outOk(EFalse), inOk(EFalse)

        #endif

            {

            }

        ~_TTsLogContext() 

            {

            #ifndef DISABLE_SYNTAX_CHECK

                do

                    {                   

                    DoInChk();

                    if (!outOk)

                        {

                        _TSLOGPRINTER(_IT(_TSLOG_UNCONTROLLER_EXIT_MSG), iVis, iCategory, iId, iThdId, iAddr, iFn);

                        }

                    } while (0);

            #endif // DISABLE_SYNTAX_CHECK

            }

        const TText* iFn;

        const TUint iId;

        const TText* iVis;

        const TUint iAddr;

        const TInt iThdId;

        const TBool iApi;

        const TUint iCategory;

        #ifndef DISABLE_SYNTAX_CHECK

            inline void DoInChk()

                {

                if (!inOk)

                    {

                    _TSLOGPRINTER(_IT(_TSLOG_UNCONTROLLED_INPUT_MSG), iVis, iCategory, iId, iThdId, iAddr, iFn);

                    inOk = ETrue;

                    }

                }

            inline void ChkMultiIn()

                {

                if (inOk)

                    {

                    _TSLOGPRINTER(_IT(_TSLOG_MULTIPLE_ENTRY_MSG), iVis, iCategory, iId, iThdId, iAddr, iFn);                

                    }

                }

            inline void ChkMultiOut()

                {

                if (outOk)

                    {           

                    _TSLOGPRINTER(_IT(_TSLOG_MULTIPLE_EXIT_MSG), iVis, iCategory, iId, iThdId, iAddr, iFn);                                        

                    }

                }

            TBool inOk;

            TBool outOk;

        #endif // DISABLE_SYNTAX_CHECK

    };

class _TTsLogTrapHandler: public TTrapHandler

    {

    public:

        _TTsLogTrapHandler(_TTsLogContext& _context) : _dc( _context ) 

            {

            RThread me;

            iThdId = (TInt)me.Id();

            }

    	void Trap() 

    	    {

    	    _TSLOGPRINTER(_IT(_TSLOG_TRAP_HARNESS_ENTRY), 0, TSLOGERR, iThdId, this);

    	    oldHandler->Trap();

    	    } 

    	void UnTrap()

    	    {

    	    _TSLOGPRINTER(_IT(_TSLOG_TRAP_HARNESS_EXIT), 0, TSLOGERR, iThdId, this);

    	    oldHandler->UnTrap();

    	    }	

    	void Leave(TInt aValue)

    	    {

    	    _TSLOGPRINTER(_IT(_TSLOG_TRAP_HARNESS_LEAVE), 0, TSLOGERR, iThdId, this);

    	    oldHandler->Leave(aValue);

    	    }	

    	TTrapHandler* oldHandler;

    private:

        _TTsLogContext& _dc;

        TInt iThdId;

    };

#endif // _DEBUG    

#endif // TSLOGUTILS_H