/*

* Copyright (c) 2002-2004 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:  

*

*/

// disable "identifier was truncated to '255' characters in the browser information" warning

#pragma warning (disable:4786)

#include "LayCdl2InstO.h"

#include "LayoutCompilerErr.h"

#include "LayoutParse.h"

#include "CppWriter.h"

#include "Lay2Cdl.h"

#include "CodeGenConsts.h"

#include <fstream>

#include <algorithm>

#include <iostream>

using namespace std;

using namespace CdlCompilerToolkit;

#define AKNLAYOUT_DEFINE_BYTECODE(name,byte) const char name = char(byte);

#include "AknLayoutByteCodes.h"

extern string KMultiLine;

string KMultiLine("Multiline_");

typedef LayoutProcessArgsErr<LayoutCdlInstanceOpt> LayoutCdlInstanceOptArgsErr;

/**

*  gTheFuncs

*  This is a collection of all SImplFunc objects that a layout instance needs, initialised

*  so that there are up to four integer parameters per API type.

*/

CAllFuncs gTheFuncs(4);

const string KDefinitionNotSet("Layout definition not found");

CAllFuncs::CAllFuncs(int aMaxParams)

	{

	for (int ii=0; ii<=aMaxParams; ii++)

		{

		for (int jj=0; jj<2; jj++)

			{

			bool useParent = (jj == 1);

			AddLineFunc(SImplFunc::EWindowLine, ii, useParent, KTypeWindowLineLayout, "WindowLine");

			AddLineFunc(SImplFunc::ETextLine, ii, useParent, KTypeTextLineLayout, "TextLine");

			AddLineFunc(SImplFunc::EMultilineTextLine, ii, useParent, KTypeMultiLineTextLayout, "MultiLineTextLine");

			AddTableFunc(SImplFunc::EWindowTable, ii, useParent, KTypeWindowLineLayout, "WindowTable");

			AddTableFunc(SImplFunc::ETextTable, ii, useParent, KTypeTextLineLayout, "TextTable");

			}

		}

	SImplFunc limits(

		SImplFunc::ETableLimits, 0, false,

		KTypeLayoutTableLimits + " Limits() { return AknLayoutDecode::TableLimits(KDataLookup); }",

		"&Limits");

	push_back(limits);

	}

void CAllFuncs::AddLineFunc(SImplFunc::TFuncType aType, int aParams, bool aParent, const string& aReturn, const string& aFuncName)

	{

	// create a function of this form:

	//TAknWindowLineLayout WindowTable$NUM$PARENT($PARAMS_TYPES_AND_NAMES)

	//	{

	//	return AknLayoutDecode::WindowLine$NUM$PARENT(&KImplData, $PARAM_NAMES);

	//  }

	string funcName = aFuncName + CdlTkUtil::IntToString(aParams) + (aParent ? "t" : "f");

	string defn = aReturn + " " + funcName + "(";

	string body = string(") { return AknLayoutDecode::") + funcName + "(&KImplData";

	if (aParent)

		{

		defn += KTypeRect + " " + KParamParentRect;

		body += ", " + KParamParentRect;

		}

	for (int ii=0; ii<aParams; ii++)

		{

		if (aParent || ii>0)

			defn += ",";

		defn += string(KTypeInt + " aParam") + CdlTkUtil::IntToString(ii);

		body += string(", aParam") + CdlTkUtil::IntToString(ii);

		}

	defn += body + "); }";

	string ptrRef = string("&") + funcName;

	SImplFunc func(aType, aParams, aParent, defn, ptrRef);

	push_back(func);

	}

void CAllFuncs::AddTableFunc(SImplFunc::TFuncType aType, int aParams, bool aParent, const string& aReturn, const string& aFuncName)

	{

	//Create a function of this form:

	//TAknWindowLineLayout WindowTable$NUM$PARENT(TInt aLineIndex, $PARAMS_TYPES_AND_NAMES) 

	//	{

	//	return AknLayoutDecode::WindowTable$NUM$PARENT(&KImplData, aLineIndex, $PARAM_NAMES); 

	//  }

	string funcName = aFuncName + CdlTkUtil::IntToString(aParams) + (aParent ? "t" : "f");

	string defn = aReturn + " " + funcName + "(" + KTypeInt + " " + KParamLineIndex;

	string body = string(") { return AknLayoutDecode::") + funcName + "(&KImplData, " + KParamLineIndex;

	if (aParent)

		{

		defn += ", " + KTypeRect + " " + KParamParentRect;

		body += ", " + KParamParentRect;

		}

	for (int ii=0; ii<aParams; ii++)

		{

		defn += string(", " + KTypeInt + " aParam") + CdlTkUtil::IntToString(ii);

		body += string(", aParam") + CdlTkUtil::IntToString(ii);

		}

	defn += body + "); }";

	string ptrRef = string("&") + funcName;

	SImplFunc func(aType, aParams, aParent, defn, ptrRef);

	push_back(func);

	}

class CLayoutInstOptImpl

	{

public:

	CLayoutInstOptImpl(TLayoutLine* aLine, CCdlTkImplementation* aImpl);

	TLayoutLine* iLine;

	CCdlTkImplementation* iImpl;

	int iByteCodeIndex;

	string iComment;

	vector<char> iBytes;

	};

CLayoutInstOptImpl::CLayoutInstOptImpl(TLayoutLine* aLine, CCdlTkImplementation* aImpl)

: iLine(aLine), iImpl(aImpl)

	{

	}

class CLayoutInstOpt

	{

public:

	CLayoutInstOpt(LayoutCdlInstanceOpt& aInstances, auto_ptr<TLayout>& aLayout, const string& aInstName);

	~CLayoutInstOpt();

	void Process();

	void WriteInstance();

	CCdlTkInstance& Inst() { return *iInstance; }

private:

	void ProcessTable(TLayoutTable& aTable);

	void ProcessLine(TLayoutLine& aLine);

	void ProcessLineApi(TLayoutLine& aLine, CCdlTkImplementation& aImpl);

	void ProcessMultiLineApi(TLayoutLine& aLine, CCdlTkImplementation& aImpl);

	void SetSimilarLineData(CLayoutInstOptImpl& aImpl, CLayoutInstOptImpl& aSimilar);

	void SetNewLineData(CLayoutInstOptImpl& aImpl);

	bool HasApi(const string& aName);

	CCdlTkImplementation& FindImp(const string& aName);

	void SetLineFunc(CLayoutInstOptImpl& aImpl);

	void CountApiParams(CCdlTkImplementation& aApi, int& aParams, bool& aParent);

	SImplFunc& AddImplFunc(SImplFunc::TFuncType aType, int iParams, bool aParent);

	void SetExtraCpp();

	void AddTableToInstance(TLayoutTable& aTable, TLayoutTable::TLayoutSubTable& aSub, int aTableNum);

	void AddTableLimitsImpl(const string& aApiName, TLayoutTable::TLayoutSubTable& aSubTable);

	void AddTableImpl(const string& aApiName, TLayoutTable& aTable, TLayoutTable::TLayoutSubTable& aSub);

	void EncodeValue(vector<char>& aBytes, string aValue);

	void MirrorParamName(string& aParamName);

private:

	LayoutCdlInstanceOpt& iInstances;

	TLayout* iLayout;

	string iName;

	CCdlTkInterface& iInterface;

	CCdlTkInstance* iInstance;

	CLayoutInstOptImpls iImpls;

	typedef vector<SImplFunc*> CImplFuncs;

	CImplFuncs iFuncs;

	};

CLayoutInstOpt::CLayoutInstOpt(LayoutCdlInstanceOpt& aInstances, auto_ptr<TLayout>& aLayout, const string& aInstName)

: iInstances(aInstances), iName(aInstName), iInterface(iInstances.Interface())

	{

	iLayout = aLayout.get();

	aLayout.release();

	iInstance = new CCdlTkInstance(iInterface);

	iInstance->SetName(aInstName);

	// Initially set definitions that will not compile in the resulting code.

	// This will alert the programmer to missing layout data.

	CCdlTkImplementations& impl = iInstance->Impl();

	for (CCdlTkImplementations::iterator pImpl = impl.begin(); pImpl != impl.end(); ++pImpl)

		(*pImpl)->SetDefinition(KDefinitionNotSet);

	}

CLayoutInstOpt::~CLayoutInstOpt()

	{

	delete iLayout;

	delete iInstance;

	for (CLayoutInstOptImpls::iterator pImpl = iImpls.begin(); pImpl != iImpls.end(); ++pImpl)

		delete *pImpl;

	}

void CLayoutInstOpt::Process()

	{

	for (TLayout::iterator pTab = iLayout->begin(); pTab != iLayout->end(); ++pTab)

		ProcessTable(**pTab);

	SetExtraCpp();

	}

void CLayoutInstOpt::WriteInstance()

	{

	CCdlTkWriteInstance writer(*iInstance);

	writer.Process();

	}

void CLayoutInstOpt::ProcessTable(TLayoutTable& aTable)

	{

	for (TLayoutTable::iterator pLine = aTable.begin(); pLine != aTable.end(); ++pLine)

		ProcessLine(**pLine);

	int tableNum = 0;

	for (TLayoutTable::TLayoutSubTables::const_iterator pSub = aTable.iSubTables.begin(); pSub != aTable.iSubTables.end(); ++pSub)

		{

		TLayoutTable::TLayoutSubTable& sub = **pSub;

		AddTableToInstance(aTable, sub, tableNum);

		tableNum++;

		}

	}

void CLayoutInstOpt::ProcessLine(TLayoutLine& aLine)

	{

	string apiName = LayoutToCdl::LineApiName(aLine);

	if (!HasApi(apiName))

		return;

	ProcessLineApi(aLine, FindImp(apiName));

	string multilineApiName = KFuncMultiline + apiName;

	if (aLine.iTable->iType == TLayoutTable::ETextTable &&

		aLine["B"].size() > 1 &&

		HasApi(multilineApiName))

		ProcessMultiLineApi(aLine, FindImp(multilineApiName));

	}

void CLayoutInstOpt::ProcessLineApi(TLayoutLine& aLine, CCdlTkImplementation& aImpl)

	{

	CLayoutInstOptImpl* newImpl = new CLayoutInstOptImpl(&aLine, &aImpl);

	iImpls.push_back(newImpl);

	// always set the new line data

	SetNewLineData(*newImpl);

	// if we can find the new line data in the aggregated data, point to that instead

	int foundIndex = iInstances.FindSimilarBytes(newImpl);

	if(foundIndex >= 0)

		{

		newImpl->iByteCodeIndex = foundIndex;

		newImpl->iBytes.clear();

		}

	SetLineFunc(*newImpl);

	iInstances.AddImpl(newImpl);

	newImpl->iImpl->SetDefinition(CdlTkUtil::ShortToHexString(newImpl->iByteCodeIndex) + ",\t// " + LayoutToCdl::LineApiName(aLine));

	}

void CLayoutInstOpt::ProcessMultiLineApi(TLayoutLine& aLine, CCdlTkImplementation& aImpl)

	{

	CLayoutInstOptImpl* newImpl = new CLayoutInstOptImpl(&aLine, &aImpl);

	iImpls.push_back(newImpl);

	CCdlTkImplementation& textImpl = FindImp(LayoutToCdl::LineApiName(aLine));

	// locate the position of the "aIndex_B" paramters in the text API parameter list

	// and the position of the "aNumberOfLinesShown" parameter in the multiline API

	// parmeter list. This is all the info needed to implement multiline APIs in terms

	// of the corresponding text API

	int bPos = 4, lPos = 0;

	const CCdlTkApiParams& mParams = aImpl.Api().AsFunc().Params();

	const CCdlTkApiParams& tParams = textImpl.Api().AsFunc().Params();

	CCdlTkApiParams::const_iterator pMParam = mParams.begin(); 

	CCdlTkApiParams::const_iterator pTParam = tParams.begin();

	int ii=0;

	while (pMParam != mParams.end() || pTParam != tParams.end())

		{

		if (pTParam != tParams.end())

			{

			if (pTParam->Name() == KParamNameB)

				bPos = ii;

			++pTParam;

			}

		if (pMParam != mParams.end())

			{

			if (pMParam->Name() == KParamNameNumberOfLinesShown)

				lPos = ii;

			++pMParam;

			}

		ii++;

		}

	SetLineFunc(*newImpl);

	iInstances.AddImpl(newImpl);

	newImpl->iImpl->SetDefinition(CdlTkUtil::ShortToHexString((bPos<<8)|lPos) + ",\t// " + aImpl.Name());

	}

void CLayoutInstOpt::SetSimilarLineData(CLayoutInstOptImpl& aImpl, CLayoutInstOptImpl& aSimilar)

	{

	aImpl.iByteCodeIndex = aSimilar.iByteCodeIndex;

	}

void CLayoutInstOpt::SetNewLineData(CLayoutInstOptImpl& aImpl)

	{

	TLayoutLine& line = *aImpl.iLine;

	// set comment

	aImpl.iComment = string("for ") + LayoutToCdl::LineApiName(line);

	const string* outputOrder = KWindowOutputOrder;

	int outputSize = KWindowOutputOrderSize;

	if (line.iTable->iType == TLayoutTable::ETextTable)

		{

		outputOrder = KTextOutputOrder;

		outputSize = KTextOutputOrderSize;

		}

	// encode parameters

	const CCdlTkApiParams& params = aImpl.iImpl->Api().AsFunc().Params();

	for (CCdlTkApiParams::const_iterator pParam = params.begin(); pParam != params.end(); ++pParam)

		{

		const CCdlTkApiParam& param = *pParam;

		if (param.Type() == KTypeInt)	// is it a cell index parameter

			{

			string paramName = param.Name();

			if (line.iIsMirroredHorizontally)

				MirrorParamName(paramName);

			char cells = 0;		// bit field for cells that this parameter applies to

			char maxVal = 0;

			char nextCell = 1;	// bit flag for the next cell

			for (int ii=0; ii<outputSize; ii++)

				{

				TValues& values = line[outputOrder[ii]];

				if (values.iNeedsIndex && values.ParamName() == paramName)

					{

					if (maxVal == 0)

						maxVal = values.size();

					else if (static_cast<unsigned int>(maxVal) != values.size())

						throw CdlTkAssert(string("param range mismatch ") + line.Name() + " " + param.Name());

					cells |= nextCell;

					}

				nextCell = nextCell << 1;

				}

			aImpl.iBytes.push_back(cells);

			aImpl.iBytes.push_back(maxVal);

			}

		}

	// encode data

	for (int ii=0; ii<outputSize; ii++)

		{

		TValues& values = line[outputOrder[ii]];

		for (TValues::iterator pVal = values.begin(); pVal != values.end(); ++pVal)

			EncodeValue(aImpl.iBytes, *pVal);

		}

	}

void CLayoutInstOpt::CountApiParams(CCdlTkImplementation& aApi, int& aParams, bool& aParent)

	{

	aParams = 0;

	aParent = false;

	const CCdlTkApiParams& params = aApi.Api().AsFunc().Params();

	for (CCdlTkApiParams::const_iterator pParam = params.begin(); pParam != params.end(); ++pParam)

		{

		if (pParam->Type() == KTypeInt) // is it a cell index parameter

			aParams++;

		else

			aParent = true;

		}

	}

void CLayoutInstOpt::SetLineFunc(CLayoutInstOptImpl& aImpl)

	{

	int nParams;

	bool hasParent;

	CountApiParams(*aImpl.iImpl, nParams, hasParent);

	SImplFunc::TFuncType type = SImplFunc::EWindowLine;

	if (aImpl.iLine->iTable->iType == TLayoutTable::ETextTable)

		{

		type = SImplFunc::ETextLine;

		string name = aImpl.iImpl->Name();

		if (name.size() > KFuncMultiline.size() && name.substr(0,KFuncMultiline.size()) == KFuncMultiline)

			type = SImplFunc::EMultilineTextLine;

		}

	SImplFunc& func = AddImplFunc(type, nParams, hasParent);

	aImpl.iImpl->SetPointerReference(func.iPtrRef);

	}

CCdlTkImplementation& CLayoutInstOpt::FindImp(const string& aName)

	{

	CCdlTkImplementation* impl = iInstance->Impl().Find(aName);

	if (!impl)

		throw NotFoundErr(aName + " in interface " + iInterface.FileName());

	return *impl;

	}

bool CLayoutInstOpt::HasApi(const string& aName)

	{

	return iInterface.ApiList().Find(aName) != 0;

	}

SImplFunc& CLayoutInstOpt::AddImplFunc(SImplFunc::TFuncType aType, int aParams, bool aParent)

	{

	for (CImplFuncs::iterator pFunc = iFuncs.begin(); pFunc != iFuncs.end(); ++pFunc)

		{

		SImplFunc& func = **pFunc;

		if (func.iType == aType && func.iParams == aParams && func.iParent == aParent)

			return func;

		}

	int count = gTheFuncs.size();

	for (int ii=0; ii<count; ii++)

		{

		SImplFunc* func = &gTheFuncs[ii];

		if (func->iType == aType && func->iParams == aParams && func->iParent == aParent)

			{

			iFuncs.push_back(func);

			return *func;

			}

		}

	throw NotFoundErr("implementation function");

	return gTheFuncs[0];

	}

// The following strings and the SetExtraCpp() function build the gross structure of

// the C++ customisation instance.

// So far, the implementations are actually just 16-bit values, typically indexes into

// the data lookup table. These need to be turned into an array by adding declarations

// and brackets to the first and last implementations. Extra support functions are also

// added.

extern string KExtraCpp;

string KExtraCpp = "\

#include \"aknlayout2decode.h\"\n\

namespace $INTERFACE_NS { extern const TUint8 KByteCodedData[]; }\n";

extern string KInitialCpp;

string KInitialCpp ="\

extern const TUint16 KDataLookup[$INTERFACE_NS::E_TApiId_TableSize];\n\

const SImplData KImplData = { KDataLookup, $INTERFACE_NS::KByteCodedData };\n\

\n\

$FUNCTIONS\

\n\

const TUint16 KDataLookup[$INTERFACE_NS::E_TApiId_TableSize] =\n\

\t{\n";

void CLayoutInstOpt::SetExtraCpp()

	{

	// The "extra cpp" field is written to the top of the cpp file.

	iInstance->SetExtraCpp(CdlTkUtil::Replace("$INTERFACE_NS", iInterface.NamespaceName(), KExtraCpp));

	// add headers & fwd declarations

	string init = CdlTkUtil::Replace("$INTERFACE_NS", iInterface.NamespaceName(), KInitialCpp);

	// add decode functions

	string functions;

	for (CImplFuncs::iterator pFunc = iFuncs.begin(); pFunc != iFuncs.end(); ++pFunc)

		{

		CdlTkUtil::AppendString(functions, (*pFunc)->iDefn);

		CdlTkUtil::AppendString(functions, "\n");

		}

	init = CdlTkUtil::Replace("$FUNCTIONS", functions, init);

	CCdlTkImplementation& first = **(iInstance->Impl().begin());

	first.SetDefinition(init + first.Definition());

	// add end of data table

	CCdlTkImplementation& last = **(iInstance->Impl().end() - 1);

	last.SetDefinition(last.Definition() + "\n};");

	}

void CLayoutInstOpt::AddTableToInstance(TLayoutTable& aTable, TLayoutTable::TLayoutSubTable& aSub, int aTableNum)

	{

	string tableName = LayoutToCdl::TableApiName(aTable, aSub, aTableNum);

	if (HasApi(tableName))

		{

		AddTableLimitsImpl(tableName + KFuncLimitsSuffix, aSub);

		AddTableImpl(tableName, aTable, aSub);

		}

	}

void CLayoutInstOpt::AddTableLimitsImpl(const string& aApiName, TLayoutTable::TLayoutSubTable& aSubTable)

	{

	// code up table limits as a pair of byte values, the first byte is the first table

	// index, the second is the last table index.

	CCdlTkImplementation& impl = FindImp(aApiName);

	int first = (*aSubTable.begin()) & 0xff;

	int last = (*aSubTable.rbegin()) & 0xff;

	impl.SetDefinition(CdlTkUtil::ShortToHexString((first<<8)|last) + ",");

	impl.SetPointerReference(AddImplFunc(SImplFunc::ETableLimits, 0, false).iPtrRef);

	}

void CLayoutInstOpt::AddTableImpl(const string& aApiName, TLayoutTable& aTable, TLayoutTable::TLayoutSubTable& aSub)

	{