// Copyright (c) 2007-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 <cassert>

#include <iostream>

#include <iomanip>

#include <sstream>

#include "e32btrace.h"

#include "utraceframe.h"

#include "util.h"

#include "eventoutputhandler.h"

#include "logevents\traceeventbase.h"

#include "utracedecoderapp.h"

CTraceEventBase::CTraceEventBase(const CMultiPartFrameCollection& aFrames, MEventOutputHandler& aOutputHandler)

    : iOutputHandler(aOutputHandler)

    {

    CUTraceFrame* currentFrame = aFrames.at(0);

    Initialise(*currentFrame); 

    // Initialise copied the data from the first frame so now we continue from the next frame

    unsigned int offset = currentFrame->DataLength();

    unsigned int i;

    for (i=1; i<aFrames.size(); i++)

        {

        currentFrame = aFrames.at(i);

        assert(offset + currentFrame->DataLength() <= iDataLength);

        memcpy(iData + offset, currentFrame->Data(), currentFrame->DataLength());

        offset += currentFrame->DataLength();

        }

    }

CTraceEventBase::CTraceEventBase(const CUTraceFrame& aFrame, MEventOutputHandler& aOutputHandler)

    : iOutputHandler(aOutputHandler)

    {

    Initialise(aFrame);

    }

void CTraceEventBase::Initialise(const CUTraceFrame& aFrame)

    {

    iPrefix = "";

    iFlags = 0;

    iPrimaryFilter = 0;

    iSecondaryFilter = 0;

    iSubCategory = 0;

    iArg1 = 0;

    iHeader2 = 0;

    iTimestamp1 = 0;

    iTimestamp2 = 0;

    iContext = 0;

    iProgramCounter = 0;

    iExtra = 0;

    iData = NULL;

    iDataLength = 0;

    iData = new unsigned char[aFrame.DataFullLength() + 4];

    memset(iData, 0, aFrame.DataFullLength() + 4);

    iFlags = aFrame.Flags();

    iPrimaryFilter = aFrame.PrimaryFilter();

    //iSecondaryFilter = aFrame.SecondaryFilter();

    iSubCategory = aFrame.SubCategory();

    iArg1 = aFrame.Arg1();

    if (Header2Present())

        {

        iHeader2 = aFrame.Header2();

        }

    if (Timestamp1Present())

        {

        iTimestamp1 = aFrame.Timestamp1();

        }

    if (Timestamp2Present())

        {

        iTimestamp2 = aFrame.Timestamp2();

        }

    if (ContextIdPresent())

        {

        iContext = aFrame.ContextId() | aFrame.ContextType();

        }

    if (PcPresent())

        {

        iProgramCounter = aFrame.ProgramCounter();

        }

    if (ExtraPresent())

        {

        iExtra = aFrame.Extra();

        }

    iDataLength = aFrame.DataFullLength();

    memcpy(iData, aFrame.Data(), aFrame.DataLength());

    iEventEntryNumber = aFrame.EventEntryNumber();

    }

CTraceEventBase::~CTraceEventBase()

    {

    delete [] iData;

    }

unsigned char* CTraceEventBase::Data() const

    {

    return iData;

    }

unsigned int CTraceEventBase::DataLength() const

    {

    return iDataLength;

    }

unsigned int CTraceEventBase::Flags() const

    {

    return iFlags;

    }

unsigned int CTraceEventBase::PrimaryFilter() const

    {

    return iPrimaryFilter;

    }

unsigned int CTraceEventBase::SecondaryFilter() const

    {

    // TODO:

    std::cerr << "Error: CUTraceFrame::SecondaryFilter() not implemented" << std::endl;

    assert(0);

	return iSecondaryFilter;

    }

unsigned int CTraceEventBase::SubCategory() const

    {

    return iSubCategory;

    }

bool CTraceEventBase::Header2Present() const

    {

    return (iFlags & BTrace::EHeader2Present) == BTrace::EHeader2Present;

    }

bool CTraceEventBase::Timestamp1Present() const

    {

    return (iFlags & BTrace::ETimestampPresent) == BTrace::ETimestampPresent;

    }

bool CTraceEventBase::Timestamp2Present() const

    {

    return (iFlags & BTrace::ETimestamp2Present) == BTrace::ETimestamp2Present;

    }

bool CTraceEventBase::ContextIdPresent() const

    {

    return (iFlags & BTrace::EContextIdPresent) == BTrace::EContextIdPresent;

    }

bool CTraceEventBase::PcPresent() const

    {

    return (iFlags & BTrace::EPcPresent) == BTrace::EPcPresent;

    }

bool CTraceEventBase::ExtraPresent() const

    {

    return (iFlags & BTrace::EExtraPresent) == BTrace::EExtraPresent;

    }

unsigned int CTraceEventBase::Header2() const

    {

    if (Header2Present())

        {

        return iHeader2;

	    }

#ifdef _DEBUG

    assert(0); // Test for presence - don't call this method blindly

#endif

    std::cerr << "Error: CTraceEventBase::Header2() called out of context" << std::endl;

    return 0;

    }

unsigned int CTraceEventBase::Timestamp1() const

    {

	if (Timestamp1Present())

        {

        return iTimestamp1;

	    }

#ifdef _DEBUG

    assert(0); // Test for presence - don't call this method blindly

#endif

    std::cerr << "Error: CTraceEventBase::Timestamp1() called out of context" << std::endl;

    return 0;

    }

unsigned int CTraceEventBase::Timestamp2() const

    {

    if (Timestamp2Present())

	    {

        return iTimestamp2;

	    }

#ifdef _DEBUG

    assert(0); // Test for presence - don't call this method blindly

#endif

    std::cerr << "Error: CTraceEventBase::Timestamp2() called out of context" << std::endl;

    return 0;

    }

unsigned int CTraceEventBase::ContextType() const

    {

    if (ContextIdPresent())

        {

        return iContext & (3UL);

        }

    #ifdef _DEBUG

    assert(0); // Test for presence - don't call this method blindly

#endif

    std::cerr << "Error: CTraceEventBase::ContextType() called out of context" << std::endl;

    return 0;

    }

unsigned int CTraceEventBase::ContextId() const

    {

    if (ContextIdPresent())

	    {

        return iContext & (~3UL);

	    }

#ifdef _DEBUG

    assert(0); // Test for presence - don't call this method blindly

#endif

    std::cerr << "Error: CTraceEventBase::ContextId() called out of context" << std::endl;

    return 0;

    }

unsigned int CTraceEventBase::ProgramCounter() const

    {

    if (PcPresent())

        {

        return iProgramCounter;

	    }

#ifdef _DEBUG

    assert(0); // Test for presence - don't call this method blindly

#endif

    std::cerr << "Error: CTraceEventBase::ProgramCounter() called out of context" << std::endl;

    return 0;

    }

unsigned int CTraceEventBase::Extra() const

    {

    if (ExtraPresent())

	    {

        return iExtra;

	    }

#ifdef _DEBUG

    assert(0); // Test for presence - don't call this method blindly

#endif

    std::cerr << "Error: CTraceEventBase::Extra() called out of context" << std::endl;

    return 0;

    }

unsigned int CTraceEventBase::Arg1() const

    {

    return iArg1;

    }

unsigned int CTraceEventBase::EventEntryNumber() const

    {

    return iEventEntryNumber;

    }

void CTraceEventBase::WriteContextInfo(std::ostream& aOutput) const

    {

    unsigned int contextId = 0;

    unsigned int ts1 = 0;

    unsigned int ts2 = 0;

    if (ContextIdPresent())

        {

        contextId = ContextId();

        }

    if (Timestamp1Present())

        {

        ts1 = Timestamp1();

        }

    if (Timestamp2Present())

        {

        ts2 = Timestamp2();

        }

	// sorry, life is too short to figure out how to make ostream format floats nicely

	char timeStr[32];

	if(CUTraceDecoderApp::UseTimes())

		{

		switch(CUTraceDecoderApp::PeriodType())

			{

		case CUTraceDecoderApp::ESplit:

			{

			// guessing - need to test on Uni

			double sec = (double) ts1 * CUTraceDecoderApp::Period1() + (double) ts2 * CUTraceDecoderApp::Period2();

			sprintf_s(timeStr, sizeof(timeStr), "%1.6f,0", sec);

			break;

			}

		case CUTraceDecoderApp::E64Bit:

			{

			double sec = ((double) ((__int64) ts2 << 32) + ts1) * CUTraceDecoderApp::Period1();

			sprintf_s(timeStr, sizeof(timeStr), "%1.6f,0", sec);

			break;

			}

		default:

			sprintf_s(timeStr, sizeof(timeStr), "-0,0");

			break;

			}

		}

	else

		{

		sprintf_s(timeStr, sizeof(timeStr), "%d,%d", ts1, ts2);

		}

    aOutput << std::noshowbase << std::dec

        << iOutputHandler.CurrentFrame() << "," << PrimaryFilter() << ","

        << SubCategory() << "," 

		<< timeStr << ",0x"

        << std::noshowbase << std::setw(8) << std::setfill('0')

        << std::nouppercase << std::hex << contextId << "," ;

    }

void CTraceEventBase::WriteEventPrefix(std::ostream& aOutput) const

    {

    if (iPrefix.length() > 0)

        {

        aOutput << iPrefix << ": ";

        }

    }

void CTraceEventBase::SetPrefix(const std::string& aPrefix)

    {

    iPrefix = aPrefix;

    }

void CTraceEventBase::SetPrefix(const char* aPrefix)

    {

    iPrefix = aPrefix;

    }

void CTraceEventBase::ProcessEvent() const

    {

    iOutputHandler.WriteEvent(*this);

    }

void CTraceEventBase::DumpEvent(std::ostream& aStream) const

    {

    aStream

        << "Size: " << std::dec << DataLength() << std::endl

        << "Flags: 0x" << std::noshowbase << std::setw(2)

        << std::setfill('0') << std::nouppercase << std::hex

        << Flags() << std::endl

        << "Primary Filter: 0x" << std::noshowbase << std::setw(2)

        << std::setfill('0') << std::nouppercase << std::hex

        << PrimaryFilter() << std::endl

        << "Subcategory: 0x" << std::noshowbase << std::setw(2)

        << std::setfill('0') << std::nouppercase << std::hex

        << SubCategory() << std::endl;

    if (Header2Present())

        {

        aStream << "Header2: 0x" << std::noshowbase << std::setw(8)

            << std::setfill('0') << std::nouppercase << std::hex

            << Header2() << std::endl;

        }

    if (Timestamp1Present())

        {

        aStream << "Timestamp1: " << std::noshowbase << std::dec

            << Timestamp1() << std::endl;

        }

    if (Timestamp2Present())

        {

        aStream << "Timestamp2: " << std::noshowbase << std::dec

            << Timestamp2() << std::endl;

        }

    if (ContextIdPresent())

        {

        aStream << "Context Type: ";

        switch (ContextType())

            {

            case 0:

                aStream << "NThread" << std::endl;

                aStream << "Context ID: 0x" << std::noshowbase << std::hex << std::nouppercase

                    << std::setw(8) << std::setfill('0') << ContextId() << std::endl;

                break;

            case 1:

                aStream << "Fast Interrupt (FIQ)" << std::endl;

                break;

            case 2:

                aStream << "Interrupt (IRQ)" << std::endl;                    

                break;

            case 3:

                aStream << "Immediate Delayed Function Call (IDFC)" << std::endl;

                break;

            }

        }

    if (PcPresent())

        {

        aStream << "PC: 0x" << std::noshowbase << std::setw(8)

            << std::setfill('0') << std::nouppercase << std::hex

            << ProgramCounter() << std::endl;

        }

    if (ExtraPresent())

        {

        aStream << "Extra: 0x"

            << std::noshowbase << std::setw(8)

            << std::setfill('0') << std::nouppercase << std::hex

            << Extra() << std::endl;

        }

    DumpBytes(aStream, Data(), DataLength());

    aStream << std::endl;

    aStream.flush();

    }

unsigned int MTraceEvent::BytesToInt(const unsigned char *aBytes) const

    {

	unsigned int num = ((aBytes[3]<<24)&0xFF000000) |

	              ((aBytes[2]<<16)&0xFF0000) |

	              ((aBytes[1]<<8)&0xFF00) |

	              (aBytes[0]&0xFF);

	return num;

    }

unsigned int MTraceEvent::BytesToInt(const char *aBytes) const

    {

	return BytesToInt((const unsigned char *)aBytes);

    }