#include "stdafx.h"

#include <TypeDef.h>
#include <Compiler.h>

TypeDef::TypeDef( const NamespaceScopes &namespaceScopes, const std::string &name, const std::string &baseName, int nowLine )
	: Symbol( namespaceScopes, name )
	, baseName( baseName )
{
	if( !compiler.StringToType( baseName, baseType ) ){
		compiler.errorMessenger.Output(3, baseName, nowLine );
		return;
	}
}
/*
bool TypeDef::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const std::string &name ) const
{
	if( GetName() != name ){
		return false;
	}
	return compiler.GetNamespaceSupporter().IsSameAreaNamespace( this->namespaceScopes, namespaceScopes );
}
bool TypeDef::IsEqualSymbol( const std::string &fullName ) const
{
	char AreaName[VN_SIZE] = "";		//オブジェクト変数
	char NestName[VN_SIZE] = "";		//入れ子メンバ
	bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );

	if( IsEqualSymbol( NamespaceScopes( AreaName ), NestName ) ){
		return true;
	}

	if( isNest ){
		// 静的メンバを考慮

		char AreaName2[VN_SIZE] = "";		//オブジェクト変数
		char NestName2[VN_SIZE] = "";		//入れ子メンバ
		bool isNest = SplitMemberName( AreaName, AreaName2, NestName2 );
		lstrcat( NestName2, "." );
		lstrcat( NestName2, NestName );

		return IsEqualSymbol( NamespaceScopes( AreaName2 ), NestName2 );
	}

	return false;
}*/



TypeDefCollection::TypeDefCollection(){
}
TypeDefCollection::~TypeDefCollection(){
}
void TypeDefCollection::Add( const NamespaceScopes &namespaceScopes, const std::string &name, const std::string &baseName, int nowLine ){
	TypeDef typeDef( namespaceScopes, name, baseName, nowLine );
	this->push_back( typeDef );
}
int TypeDefCollection::GetIndex( const NamespaceScopes &namespaceScopes, const std::string &name ) const{
	int max = (int)(*this).size();
	for( int i=0; i<max; i++ ){
		if( (*this)[i].IsEqualSymbol( namespaceScopes, name ) ){
			return i;
		}
	}
	return -1;
}
int TypeDefCollection::GetIndex( const std::string &fullName ) const{
	char AreaName[VN_SIZE] = "";		//オブジェクト変数
	char NestName[VN_SIZE] = "";		//入れ子メンバ
	bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );

	return GetIndex( NamespaceScopes( AreaName ), NestName );
}

void TypeDefCollection::Add( const NamespaceScopes &namespaceScopes, const std::string &expression, int nowLine ){
	int i;
	char temporary[VN_SIZE];

	for(i=0;;i++){
		if(expression[i]=='='||expression[i]=='\0'){
			temporary[i]=0;
			break;
		}
		temporary[i]=expression[i];
	}

	if(expression[i]!='='){
		compiler.errorMessenger.Output(10,"TypeDef",nowLine);
		return;
	}

	const char *pTemp=expression.c_str()+i+1;

	//識別文字のエラーチェック（新しい型）
	i=0;
	for(;;i++){
		if(temporary[i]=='\0') break;
		if( !( IsVariableChar( temporary[i], true) ) ){
			compiler.errorMessenger.Output(10,"TypeDef",nowLine);
			return;
		}
	}

	//識別文字のエラーチェック（コピー元の型）
	if(pTemp[0]=='*'&&pTemp[1]==1&&(pTemp[2]==ESC_FUNCTION||pTemp[2]==ESC_SUB)){
		//関数ポインタ
		if(pTemp[3]!='('){
			compiler.errorMessenger.Output(10,"TypeDef",nowLine);
			return;
		}
	}
	else{
		i=0;
		while(pTemp[i]=='*') i++;
		for(;;i++){
			if(pTemp[i]=='\0') break;
			if( !( IsVariableChar( pTemp[i], true) ) )
			{
				compiler.errorMessenger.Output(10,"TypeDef",nowLine);
				return;
			}
		}
	}

	//識別子が重複している場合はエラーにする
	if(lstrcmp(temporary,pTemp)==0){
		compiler.errorMessenger.Output(1,NULL,nowLine);
		return;
	}



	//////////////////////////
	// TypeDef情報を追加
	//////////////////////////

	Add( namespaceScopes, temporary, pTemp, nowLine );
}

void TypeDefCollection::CollectTypeDefs(){

	// 名前空間管理
	NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
	namespaceScopes.clear();

	// Importsされた名前空間の管理
	NamespaceScopesCollection &importedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
	importedNamespaces.clear();

	int i=-1, i2;
	char temporary[VN_SIZE];
	while(1){
		extern char *basbuf;

		i++;

		if( basbuf[i] == 1 && basbuf[i+1] == ESC_NAMESPACE ){
			for(i+=2,i2=0;;i2++,i++){
				if( IsCommandDelimitation( basbuf[i] ) ){
					temporary[i2]=0;
					break;
				}
				temporary[i2]=basbuf[i];
			}
			namespaceScopes.push_back( temporary );

			continue;
		}
		else if( basbuf[i] == 1 && basbuf[i+1] == ESC_ENDNAMESPACE ){
			if( namespaceScopes.size() <= 0 ){
				compiler.errorMessenger.Output(12, "End Namespace", i );
			}
			else{
				namespaceScopes.pop_back();
			}

			i += 2;
			continue;
		}
		else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPORTS ){
			for(i+=2,i2=0;;i2++,i++){
				if( IsCommandDelimitation( basbuf[i] ) ){
					temporary[i2]=0;
					break;
				}
				temporary[i2]=basbuf[i];
			}
			if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
			{
				compiler.errorMessenger.Output(64,temporary,i );
			}

			continue;
		}
		else if( basbuf[i] == 1 && basbuf[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
			importedNamespaces.clear();
			continue;
		}

		if( basbuf[i]==1 ){
			char temporary[VN_SIZE];
			if(basbuf[i+1]==ESC_TYPEDEF){
				int i2 = 0;
				for(i+=2;;i2++,i++){
					if(basbuf[i]=='\n'){
						temporary[i2]=0;
						break;
					}
					temporary[i2]=basbuf[i];
					if(basbuf[i]=='\0') break;
				}
				Add( namespaceScopes, temporary, i );

				continue;
			}
			else if( basbuf[i+1] == ESC_CONST && basbuf[i+2] == 1 && basbuf[i+3] == ESC_ENUM ){
				int i2 = 0;
				for(i+=4;;i2++,i++){
					if(!IsVariableChar(basbuf[i])){
						temporary[i2]=0;
						break;
					}
					temporary[i2]=basbuf[i];
					if(basbuf[i]=='\0') break;
				}
				Add( namespaceScopes, temporary, "Long", i );
			}
		}

		//次の行
		for(;;i++){
			if(IsCommandDelimitation(basbuf[i])) break;
		}
		if(basbuf[i]=='\0') break;
	}
}