#include "stdafx.h"

void Meta::Clear()
{
	// 名前空間
	namespaceScopesCollection.clear();

	// 関数・メソッド
	userProcs.Clear();

	// DLL関数
	dllProcs.Clear();

	// クラス
	classesImpl.Clear();

	// グローバル変数
	globalVars.Clear();

	// グローバル定数
	globalConsts.Clear();

	// グローバル定数マクロ
	globalConstMacros.Clear();

	// blittable型
	blittableTypes.clear();

	// TypeDef
	typeDefs.clear();

	// 関数ポインタ
	procPointers.Clear();
}

void Meta::StaticLink( Meta &meta, long dataSectionBaseOffset, const std::vector<int> &relationTable )
{
	// 名前空間
	BOOST_FOREACH( NamespaceScopes &namespaceScopes, meta.namespaceScopesCollection )
	{
		if( !this->namespaceScopesCollection.IsExist( namespaceScopes ) )
		{
			this->namespaceScopesCollection.push_back( namespaceScopes );
		}
	}

	// 関数・メソッド
	meta.GetUserProcs().Iterator_Reset();
	while( meta.GetUserProcs().Iterator_HasNext() )
	{
		UserProc *pUserProc = meta.GetUserProcs().Iterator_GetNext();
		if( pUserProc->IsExternal() )
		{
			// 外部参照の場合は取り込まない
			continue;
		}

		pUserProc->ResetRelationalObjectModuleIndex( relationTable );

		pUserProc->GetNativeCode().ResetDataSectionBaseOffset( dataSectionBaseOffset );

		this->userProcs.Put( pUserProc );
	}
	meta.GetUserProcs().PullOutAll();

	// DLL関数
	meta.GetDllProcs().Iterator_Reset();
	while( meta.GetDllProcs().Iterator_HasNext() )
	{
		DllProc *pDllProc = meta.GetDllProcs().Iterator_GetNext();
		if( pDllProc->IsExternal() )
		{
			// 外部参照の場合は取り込まない
			continue;
		}

		pDllProc->ResetRelationalObjectModuleIndex( relationTable );
		this->dllProcs.Put( pDllProc );
	}
	meta.GetDllProcs().PullOutAll();

	// クラス
	meta.GetClasses().Iterator_Reset();
	while( meta.GetClasses().Iterator_HasNext() )
	{
		CClass *pClass = meta.GetClasses().Iterator_GetNext();
		if( pClass->IsExternal() )
		{
			// 外部参照の場合は取り込まない
			continue;
		}

		pClass->ResetRelationalObjectModuleIndex( relationTable );
		pClass->Readed();
		this->GetClasses().Put( pClass );
	}
	meta.GetClasses().PullOutAll();

	// グローバル変数
	long initAreaBaseOffset = this->globalVars.initAreaBuffer.GetSize();
	BOOST_FOREACH( Variable *pVar, meta.globalVars )
	{
		if( pVar->IsExternal() )
		{
			// 外部参照の場合は取り込まない
			continue;
		}

		// 基底スコープレベルのグローバル変数の生存値をオンにする
		if( pVar->GetScopeLevel() == 0 )
		{
			pVar->isLiving = true;
		}

		bool isResetOffsetAddress = true;
		if( pVar->HasInitData() )
		{
			// 初期バッファがあるときはデータテーブルオフセットを適用する
			pVar->SetOffsetAddress( pVar->GetOffsetAddress() + initAreaBaseOffset );

			isResetOffsetAddress = false;
		}

		pVar->ResetRelationalObjectModuleIndex( relationTable );
		this->globalVars.Add( pVar, isResetOffsetAddress );
	}
	meta.globalVars.PullOutAll();
	this->globalVars.initAreaBuffer.Put(
		meta.globalVars.initAreaBuffer.GetBuffer(),
		meta.globalVars.initAreaBuffer.GetSize()
	);

	// グローバル定数
	meta.GetGlobalConsts().Iterator_Reset();
	while( meta.GetGlobalConsts().Iterator_HasNext() )
	{
		CConst *pConst = meta.GetGlobalConsts().Iterator_GetNext();
		if( pConst->IsExternal() )
		{
			// 外部参照の場合は取り込まない
			continue;
		}

		pConst->ResetRelationalObjectModuleIndex( relationTable );
		this->GetGlobalConsts().Put( pConst );
	}
	meta.GetGlobalConsts().PullOutAll();

	// グローバル定数マクロ
	meta.GetGlobalConstMacros().Iterator_Reset();
	while( meta.GetGlobalConstMacros().Iterator_HasNext() )
	{
		ConstMacro *pConstMacro = meta.GetGlobalConstMacros().Iterator_GetNext();
		if( pConstMacro->IsExternal() )
		{
			// 外部参照の場合は取り込まない
			continue;
		}

		pConstMacro->ResetRelationalObjectModuleIndex( relationTable );
		this->GetGlobalConstMacros().Put( pConstMacro );
	}
	meta.GetGlobalConstMacros().PullOutAll();

	// blittable型
	BOOST_FOREACH( BlittableType &blittableType, meta.blittableTypes )
	{
		// TODO: coreモジュール以外でもBlittable型用のクラスモジュールを定義できるようにすべき
		this->blittableTypes.push_back( blittableType );
	}
	meta.blittableTypes.clear();

	// TypeDef
	BOOST_FOREACH( TypeDef &typeDef, meta.typeDefs )
	{
		if( typeDef.IsExternal() )
		{
			// 外部参照の場合は取り込まない
			continue;
		}

		typeDef.ResetRelationalObjectModuleIndex( relationTable );
		this->typeDefs.push_back( typeDef );
	}
	meta.typeDefs.clear();

	// 関数ポインタ
	BOOST_FOREACH( ProcPointer *pProcPointer, meta.procPointers )
	{
		if( pProcPointer->IsExternal() )
		{
			// 外部参照の場合は取り込まない
			continue;
		}

		pProcPointer->ResetRelationalObjectModuleIndex( relationTable );
		this->procPointers.push_back( pProcPointer );
	}
	meta.procPointers.PullOutAll();

	// デリゲート
	meta.GetDelegates().Iterator_Reset();
	while( meta.GetDelegates().Iterator_HasNext() )
	{
		Delegate *pDelegate = meta.GetDelegates().Iterator_GetNext();
		if( pDelegate->IsExternal() )
		{
			// 外部参照の場合は取り込まない
			continue;
		}

		pDelegate->ResetRelationalObjectModuleIndex( relationTable );
		this->GetDelegates().Put( pDelegate );
	}
	meta.GetDelegates().PullOutAll();
}

const ::Delegate &Meta::ToDelegate( const CClass &_class )
{
	const ::Delegate *dg = this->GetDelegates().GetHashArrayElement( _class.GetName().c_str() );
	while( dg )
	{
		if( dg->IsEqualSymbol( _class.GetNamespaceScopes(), _class.GetName() ) ){
			//名前空間とクラス名が一致した
			return *dg;
		}
		dg = dg->GetChainNext();
	}

	throw;
}

const CClass *Meta::FindClassSupportedTypeDef( const Symbol &symbol )
{
	const CClass *pClass = this->GetClasses().FindEx( symbol );
	if( pClass )
	{
		return pClass;
	}

	// TypeDefも見る
	const TypeDef *pTypeDef = this->GetTypeDefs().Find( symbol );
	if( pTypeDef )
	{
		Type type = pTypeDef->GetBaseType();
		if( type.IsObject() )
		{
			return &type.GetClass();
		}
	}

	return NULL;
}

void Meta::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
{
	// 関数・メソッド
	this->GetUserProcs().Iterator_Init();
	this->GetUserProcs().Iterator_Reset();
	while( this->GetUserProcs().Iterator_HasNext() )
	{
		UserProc *pUserProc = this->GetUserProcs().Iterator_GetNext();
		pUserProc->Resolve( resolver, resolveErrors );
	}

	// DLL関数
	this->GetDllProcs().Iterator_Init();
	this->GetDllProcs().Iterator_Reset();
	while( this->GetDllProcs().Iterator_HasNext() )
	{
		DllProc *pDllProc = this->GetDllProcs().Iterator_GetNext();
		pDllProc->Resolve( resolver, resolveErrors );
	}

	// クラス
	this->GetClasses().Iterator_Init();
	this->GetClasses().Iterator_Reset();
	while( this->GetClasses().Iterator_HasNext() )
	{
		CClass *pClass = this->GetClasses().Iterator_GetNext();
		pClass->Resolve( resolver, resolveErrors );
	}

	// グローバル変数
	BOOST_FOREACH( Variable *pVar, globalVars )
	{
		pVar->Resolve( resolver, resolveErrors );
	}

	// グローバル定数
	this->GetGlobalConsts().Iterator_Init();
	this->GetGlobalConsts().Iterator_Reset();
	while( this->GetGlobalConsts().Iterator_HasNext() )
	{
		CConst *pConst = this->GetGlobalConsts().Iterator_GetNext();
		pConst->Resolve( resolver, resolveErrors );
	}

	// グローバル定数マクロ
	this->GetGlobalConstMacros().Iterator_Init();
	this->GetGlobalConstMacros().Iterator_Reset();
	while( this->GetGlobalConstMacros().Iterator_HasNext() )
	{
		ConstMacro *pConstMacro = this->GetGlobalConstMacros().Iterator_GetNext();
		pConstMacro->Resolve( resolver, resolveErrors );
	}

	// blittable型
	BOOST_FOREACH( BlittableType &blittableType, blittableTypes )
	{
		blittableType.Resolve( resolver, resolveErrors );
	}

	// TypeDef
	BOOST_FOREACH( TypeDef &typeDef, typeDefs )
	{
		typeDef.Resolve( resolver, resolveErrors );
	}

	// 関数ポインタ
	BOOST_FOREACH( ProcPointer *pProcPointer, procPointers )
	{
		pProcPointer->Resolve( resolver, resolveErrors );
	}

	// デリゲート
	this->GetDelegates().Iterator_Init();
	this->GetDelegates().Iterator_Reset();
	while( this->GetDelegates().Iterator_HasNext() )
	{
		Delegate *pDelegate = this->GetDelegates().Iterator_GetNext();
		pDelegate->Resolve( resolver, resolveErrors );
	}
}