/*

* Copyright (c) 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 "CdlCompilerToolkit/CdlTkInterface.h"

#include "CdlTkPriv.h"

#include "CdlTkStdTrans.h"

#include <sstream>

#include <CdlDef.h>

using namespace std;

namespace CdlCompilerToolkit {

//

// TCdlTkFlag

//

struct TCdlTkFlag

	{

	const char* iName;

	int iValue;

	};

const TCdlTkFlag gCdlTkFlags[] =

	{

		{ "KCdlFlagRomOnly", KCdlFlagRomOnlyValue }

	};

//

// CCdlTkInterfaceHeader::CFlags

//

CCdlTkInterfaceHeader::CFlags::CFlags()

: iFlags(0)

	{

	}

void CCdlTkInterfaceHeader::CFlags::SetFlag(const string& aFlagName)

	{

	iFlags |= FlagVal(aFlagName);

	}

void CCdlTkInterfaceHeader::CFlags::ClearFlag(const string& aFlagName)

	{

	iFlags &= ~FlagVal(aFlagName);

	}

int CCdlTkInterfaceHeader::CFlags::FlagsAsInt() const

	{

	return iFlags;

	}

string CCdlTkInterfaceHeader::CFlags::FlagsAsString() const

	{

	string flags;

	for (int bit=0; bit<Count(); bit++)

		{

		if (IsSet(bit))

			{

			if (!flags.empty())

				CdlTkUtil::AppendString(flags, " | ");

			CdlTkUtil::AppendString(flags, FlagName(bit));

			}

		}

	if (flags.empty())

		flags = "0";

	return flags;

	}

int CCdlTkInterfaceHeader::CFlags::FlagVal(const string& aFlagName) const

	{

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

		{

		const TCdlTkFlag& flag = gCdlTkFlags[ii];

		if (aFlagName == flag.iName)

			return flag.iValue;

		}

	throw CdlTkAssert(aFlagName + " : unknown flag");

	return 0;

	}

string CCdlTkInterfaceHeader::CFlags::FlagName(int aFlagIndex) const

	{

	int flagVal = IndexToFlagVal(aFlagIndex);

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

		{

		const TCdlTkFlag& flag = gCdlTkFlags[ii];

		if (flagVal == flag.iValue)

			return flag.iName;

		}

	throw CdlTkAssert(CdlTkUtil::IntToString(aFlagIndex) + " : unknown flag index");

	return "";

	}

int CCdlTkInterfaceHeader::CFlags::Count() const

	{

	return sizeof(gCdlTkFlags)/sizeof(*gCdlTkFlags);

	}

int CCdlTkInterfaceHeader::CFlags::IndexToFlagVal(int aIndex) const

	{

	return 1<<aIndex;

	}

bool CCdlTkInterfaceHeader::CFlags::IsSet(int aFlagIndex) const

	{

	return !!(iFlags & IndexToFlagVal(aFlagIndex));

	}

bool CCdlTkInterfaceHeader::CFlags::IsSet(const string& aFlagName) const

	{

	return !!(iFlags & FlagVal(aFlagName));

	}

CCdlTkInterfaceHeader::CFlags& CCdlTkInterfaceHeader::CFlags::operator|=(const CFlags& aOther)

	{

	iFlags |= aOther.iFlags;

	return *this;

	}

//

// CCdlTkInterfaceHeader::CVersion

//

CCdlTkInterfaceHeader::CVersion::CVersion()

: iMajor(0), iMinor(0)

	{

	}

CCdlTkInterfaceHeader::CVersion::CVersion(int aMajor, int aMinor)

: iMajor(aMajor), iMinor(aMinor)

	{

	}

bool CCdlTkInterfaceHeader::CVersion::operator<(const CVersion aOther) const

	{

	return  (iMajor < aOther.iMajor) ||

			(iMajor == aOther.iMajor && iMinor < aOther.iMinor);

	}

bool CCdlTkInterfaceHeader::CVersion::operator==(const CVersion aOther) const

	{

	return iMajor == aOther.iMajor && iMinor == aOther.iMinor;

	}

int CCdlTkInterfaceHeader::CVersion::Major() const

	{

	return iMajor;

	}

void CCdlTkInterfaceHeader::CVersion::SetMajor(int aMajor)

	{

	iMajor = aMajor;

	}

int CCdlTkInterfaceHeader::CVersion::Minor() const

	{

	return iMinor;

	}

void CCdlTkInterfaceHeader::CVersion::SetMinor(int aMinor)

	{

	iMinor = aMinor;

	}

//

// CCdlTkInterfaceHeader

//

CCdlTkInterfaceHeader::CCdlTkInterfaceHeader()

: iName(""), iUid(0), iVer(0, 0)

	{

	}

void CCdlTkInterfaceHeader::MergeExtensionHeader(const CCdlTkInterfaceHeader& aOther)

	{

	if (!aOther.iName.empty() && iName != aOther.iName)

		throw CdlTkAssert("Can't change interface name in extension");

	if (aOther.iUid && iUid != aOther.iUid)

		throw CdlTkAssert("Can't change interface UID in extension");

	if (!(iVer < aOther.iVer))

		throw CdlTkAssert("Interface version must increase in extension");

	iVer = aOther.iVer;

	iFlags |= aOther.iFlags;

	}

string CCdlTkInterfaceHeader::Name() const

	{

	return iName;

	}

void CCdlTkInterfaceHeader::SetName(const string& aName)

	{

	iName = aName;

	}

int CCdlTkInterfaceHeader::Uid() const

	{

	return iUid;

	}

void CCdlTkInterfaceHeader::SetUid(int aUid)

	{

	iUid = aUid;

	}

void CCdlTkInterfaceHeader::SetVersion(const CVersion& aVer)

	{

	iVer = aVer;

	}

const CCdlTkInterfaceHeader::CVersion& CCdlTkInterfaceHeader::Version() const

	{

	return iVer;

	}

const CCdlTkInterfaceHeader::CFlags& CCdlTkInterfaceHeader::Flags() const

	{

	return iFlags;

	}

CCdlTkInterfaceHeader::CFlags& CCdlTkInterfaceHeader::Flags()

	{

	return iFlags;

	}

bool CCdlTkInterfaceHeader::operator==(const CCdlTkInterfaceHeader& aOther) const

	{

	return 

		iName == aOther.iName &&

		iUid == aOther.iUid &&

		iVer == aOther.iVer;

	}

//

// CCdlTkApiParam

//

CCdlTkApiParam::CCdlTkApiParam()

	{

	}

CCdlTkApiParam::CCdlTkApiParam(const string& aType, const string& aName)

: iType(aType), iName(aName)

	{

	}

CCdlTkApiParam::CCdlTkApiParam(const string& aType, const string& aName, const std::string& aDefaultValue)

: iType(aType), iName(aName), iDefaultValue(aDefaultValue)

	{

	}

const string& CCdlTkApiParam::Type() const

	{

	return iType;

	}

void CCdlTkApiParam::SetType(const string& aType)

	{

	iType = aType;

	}

const string& CCdlTkApiParam::Name() const

	{

	return iName;

	}

void CCdlTkApiParam::SetName(const string& aName)

	{

	iName = aName;

	}

const string& CCdlTkApiParam::DefaultValue() const

	{

	return iDefaultValue;

	}

void CCdlTkApiParam::SetDefaultValue(const std::string& aDefaultValue)

	{

	iDefaultValue = aDefaultValue;

	}

bool CCdlTkApiParam::operator==(const CCdlTkApiParam& aOther) const

	{

	return Type() == aOther.Type() && Name() == aOther.Name() && DefaultValue() == aOther.DefaultValue();

	}

CCdlTkApiParams::iterator CCdlTkApiParams::FindByName(string aParamName)

	{

	iterator it;

	for (it = begin(); it != end(); ++it)

		{

		if (it->Name() == aParamName)

			break;

		}

	return it;

	}

//

// CCdlTkApi

//

CCdlTkApi::CCdlTkApi(CCdlTkInterface& aInterface)

: iInterface(aInterface)

	{

	}

CCdlTkApi::~CCdlTkApi()

	{

	}

const string& CCdlTkApi::ReturnType() const

	{

	return iReturnType;

	}

void CCdlTkApi::SetReturnType(const string& aType)

	{

	iReturnType = aType;

	}

bool CCdlTkApi::IsVoidReturn() const

	{

	return iReturnType == "void";

	}

const string& CCdlTkApi::Name() const

	{

	return iName;

	}

void CCdlTkApi::SetName(const string& aName)

	{

	iName = aName;

	}

int CCdlTkApi::SourceFileLineNum() const

	{

	return iSourceFileLineNum;

	}

void CCdlTkApi::SetSourceFileLineNum(int aLineNum)

	{

	iSourceFileLineNum = aLineNum;

	}

const string& CCdlTkApi::Comment() const

	{

	return iComment;

	}

void CCdlTkApi::SetComment(const string& aComment)

	{

	iComment = aComment;

	}

const CCdlTkInterface& CCdlTkApi::Interface() const

	{

	return iInterface;

	}

CCdlTkInterface& CCdlTkApi::Interface()

	{

	return iInterface;

	}

const CCdlTkFunctionApi& CCdlTkApi::AsFunc() const

	{

	if (!IsFunc())

		throw CdlTkAssert("API is not a function");

	return static_cast<const CCdlTkFunctionApi&>(*this);

	}

const CCdlTkDataApi& CCdlTkApi::AsData() const

	{

	if (IsFunc())

		throw CdlTkAssert("API is not data");

	return static_cast<const CCdlTkDataApi&>(*this);

	}

bool CCdlTkApi::operator!=(const CCdlTkApi& aOther) const

	{

	return !(*this == aOther);

	}

bool CCdlTkApi::operator==(const CCdlTkApi& aOther) const

	{

	return 

		ReturnType() == aOther.ReturnType() &&

		Name() == aOther.Name() &&

		IsFunc() == aOther.IsFunc();

	}

void CCdlTkApi::operator=(const CCdlTkApi& aOther)

	{

	iReturnType = aOther.iReturnType;

	iName = aOther.iName;

	iSourceFileLineNum = aOther.iSourceFileLineNum;

	}

//

// CCdlTkDataApi

//

CCdlTkDataApi::CCdlTkDataApi(CCdlTkInterface& aInterface)

: CCdlTkApi(aInterface)

	{

	}

CCdlTkDataApi::CCdlTkDataApi(CCdlTkInterface& aInterface, const CCdlTkDataApi& aCopy)

: CCdlTkApi(aInterface)

	{

	CCdlTkApi::operator=(aCopy);

	}

bool CCdlTkDataApi::IsFunc() const

	{

	return false;

	}

string CCdlTkDataApi::PointerType() const

	{

	return ReturnType() + " const*";

	}

string CCdlTkDataApi::ParamsTypeAndNameList() const

	{

	return "";

	}

CCdlTkApi* CCdlTkDataApi::Clone(CCdlTkInterface& aInterface) const

	{

	return new CCdlTkDataApi(aInterface, *this);

	}

//

// CCdlTkFunctionApi

//

CCdlTkFunctionApi::CCdlTkFunctionApi(CCdlTkInterface& aInterface)

: CCdlTkApi(aInterface)

	{

	}

CCdlTkFunctionApi::CCdlTkFunctionApi(CCdlTkInterface& aInterface, const CCdlTkFunctionApi& aCopy)

: CCdlTkApi(aInterface)

	{

	CCdlTkApi::operator=(aCopy);

	iParams = aCopy.iParams;

	}

bool CCdlTkFunctionApi::IsFunc() const

	{

	return true;

	}

string CCdlTkFunctionApi::PointerType() const

	{

	return ApiNameAsTypeName() + "*";

	}

string CCdlTkFunctionApi::ParamsTypeAndNameList() const

	{

	string ret = "(";

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

		{

		if (pParam != iParams.begin())

			CdlTkUtil::AppendString(ret, string(",") + KSpace);

		CdlTkUtil::AppendString(ret, pParam->Type() + KSpace + pParam->Name());

		if(!(pParam->DefaultValue().empty()))

			CdlTkUtil::AppendString(ret, KSpace + KEqualsSign + KSpace + pParam->DefaultValue());

		}

	ret += ")";

	return ret;

	}

CCdlTkApiParams& CCdlTkFunctionApi::Params()

	{

	return iParams;

	}

const CCdlTkApiParams& CCdlTkFunctionApi::Params() const

	{

	return iParams;

	}

string CCdlTkFunctionApi::ApiNameAsTypeName() const

	{

	string name = "T";

	name += Name();

	name += "_sig";

	return name;

	}

string CCdlTkFunctionApi::ParamNameList() const

	{

	string ret = "";

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

		{

		if (pParam != iParams.begin())

			CdlTkUtil::AppendString(ret, ", ");

		CdlTkUtil::AppendString(ret, pParam->Name());

		}

	return ret;

	}

string CCdlTkFunctionApi::ParamTypeList() const