// 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:
//



/**
 @file te_parser.cpp
 @internalTechnology
*/
#include "te_parser.h"
#include "te_logger.h"
#include "te_suite_defs.h"
#include "te_tracer.h"


TTraceParser::TTraceParser()
	{
	iMissingTraceFound = false;
	iTimestamp = 0;
	iTimestamp2Present = 0;
	}

TTraceParser::~TTraceParser()
	{
	}


TInt TTraceParser::ParseRawBuffer(TUint8* aRawBuffer, TUint aBufferSize, RPointerArray<TTraceConfigs>& aLoggedTraces)
	{
	TInt error = KErrNone;
	// process all the complete traces in buffer...
	const TUint8* data = aRawBuffer;
	TUint sizeRemaining = aBufferSize;
	while(sizeRemaining>BTrace::ESizeIndex)
		{
		TUint traceSize = (data[BTrace::ESizeIndex]+3)&~3;
		if(traceSize>sizeRemaining)
			{
			error = KErrNoMemory;
			break;
			}

		TTraceConfigs* trace = new TTraceConfigs;
		ASSERT(trace);
		TTraceConfigsOperator::Init(*trace);
		if(!PreProcessTrace(*trace,data))
			{
			if (iMissingTraceFound)
				{
				// bad trace, create dummy 1 byte trace record...
				memset(trace,0,sizeof(*trace));
				trace->iGroupId = BTrace::EMetaTrace;
				trace->iSubCategory = KJunkTraceCategory;
				trace->iRawDataSize = 4;
					trace->iRawData[0] = *data;
				traceSize = 1;
				}
			else // The buffer was filled so ignore the rest of the data
				{
				break;
				}
			}
		data += traceSize;
		sizeRemaining -= traceSize;
		aLoggedTraces.Append(trace);
		}
	return error;
	}

TBool TTraceParser::PreProcessTrace(TTraceConfigs& aTrace, const TUint8* aData)
	{
	// process aTrace header...
	TUint traceSize = aData[BTrace::ESizeIndex];
	if(traceSize < 4u || traceSize > (TUint)KMaxBTraceRecordSize)
		return false; // bad size

	aTrace.iFlags = aData[BTrace::EFlagsIndex];
//	if(!TraceRecordId)						// first trace record...?
//		aTrace.iFlags &= ~BTrace::EMissingRecord;	// ignore missing traces before log start

	aTrace.iGroupId = aData[BTrace::ECategoryIndex];
	aTrace.iSubCategory = aData[BTrace::ESubCategoryIndex];

	const TUint8* header = aData + 4;
	
	if(aTrace.iFlags&BTrace::EHeader2Present)
		aTrace.iHeader2 = ReadTraceWord(header);

	// process timestamp...
	TUint64 timestamp = 0;
	if(aTrace.iFlags&BTrace::ETimestampPresent)
		{
		timestamp = ReadTraceWord(header);
		if(timestamp<(iTimestamp&0xffffffffu))
			iTimestamp += TUint64(1)<<32;
		iTimestamp &= TUint64(0xffffffff)<<32;
		iTimestamp |= timestamp; 
		timestamp = iTimestamp;
//		if(!TraceRecordId)
//			TimestampBase = timestamp; // record timestamp of first trace
		}
	aTrace.iTimestamp = timestamp;

	// process timestamp2...
	if(aTrace.iFlags&BTrace::ETimestamp2Present)
		{
		iTimestamp2Present = true;
		aTrace.iTimestamp2 = ReadTraceWord(header);
		}

	// process context...
	if(aTrace.iFlags&BTrace::EContextIdPresent)
		{
		aTrace.iHasThreadId = EAddThreadIdentification;
		aTrace.iContextId = ReadTraceWord(header);
		}
		

	// process pc...
	if(aTrace.iFlags & BTrace::EPcPresent)
		{
		aTrace.iPc = ReadTraceWord(header);
		aTrace.iHasProgramCounter = EAddProgramCounter;
		}

	// process extra...
	if(aTrace.iFlags & BTrace::EExtraPresent)
		aTrace.iExtra = ReadTraceWord(header);

	// process beginning of payload data...	
	TUint headerSize = header - aData;
	aData = (TUint8*)header;
	if(headerSize > traceSize)
		return false; // bad trace record, header was read beyond start point of payload
	
	
	TUint dataSize = traceSize - headerSize;
	if(dataSize > sizeof(aTrace.iRawData))
		return false; // bad trace record, its bigger than max allowed size

	if(dataSize < 8)
		return false; //bad trace, it's meant to contain both uid and format id
	
	//process module uid...
	aTrace.iComponentId = ReadTraceWord(aData);
	dataSize -= 4;
	//process format id...
	
	aTrace.iTraceId = ReadTraceWord(aData);
	dataSize -= 4;

	//process rest of payload data...
	if(dataSize > 0)
		{
		aTrace.iRawDataSize = dataSize;
		memcpy(&aTrace.iRawData, aData, dataSize);
		}
	/* Legacy code from btrace analyze...
	// clear pre-processor specific data...
	aTrace.iDataTypes[0] = 0;
	aTrace.iDataTypes[1] = 0;
	aTrace.iDataTypes[2] = 0;
	aTrace.iDataTypes[3] = 0;
	aTrace.iCalculatedData[0] = 0;
	aTrace.iCalculatedData[1] = 0;
	 */
	
	// check for missing.
	if(aTrace.iFlags & BTrace::EMissingRecord)
		{// Some trace was missing as the btrace buffer must have been filled.
		iMissingTraceFound = true;
		return false;
		}

	// update trace ID...
//	++TraceRecordId;

	return true;
	}

TUint32 TTraceParser::ReadTraceWord(const TUint8*& data)
	{
	TUint32 word;
	memcpy(&word, data, sizeof(TUint32));
	data += sizeof(TUint32);
	return word;
	}