#include "../BasicCompiler_Common/common.h"
#include "Opcode.h"

//ローカル変数アドレススケジュール
DWORD *pLocalVarAddrSchedule;
int LocalVarAddrScheduleNum;

void Call_DebugSys_SaveContext(){
	//call _System_GetEip
	extern SUBINFO *pSub_System_GetEip;
	op_call(pSub_System_GetEip);

	//mov rdx,rax
	op_mov64_ToReg_FromReg(REG_RDX,REG_RAX);

	//mov rcx,rsp
	op_mov64_ToReg_FromReg(REG_RCX,REG_RSP);

	//call _DebugSys_SaveContext
	extern SUBINFO *pSub_DebugSys_SaveContext;
	op_call(pSub_DebugSys_SaveContext);
}

void AddLocalVarAddrSchedule(){
	extern HANDLE hHeap;

	//ローカル変数アドレススケジュールに追加する
	pLocalVarAddrSchedule=(DWORD *)HeapReAlloc(hHeap,0,pLocalVarAddrSchedule,(LocalVarAddrScheduleNum+1)*sizeof(DWORD));
	pLocalVarAddrSchedule[LocalVarAddrScheduleNum]=obp;
	LocalVarAddrScheduleNum++;
}

int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
	int ret_type;

	if(idProc==PROC_DEFAULT){
		/////////////////////
		// ユーザー定義関数
		/////////////////////

		SUBINFO *psi;
		psi=(SUBINFO *)pInfo;

		//GetSubHash内でエラー提示が行われた場合
		if(psi==(SUBINFO *)-1) return -1;


		//オブジェクト名を取得
		char ObjectName[VN_SIZE];
		int RefType;
		SplitObjectName(name,ObjectName,&RefType);


		////////////////////////
		// オーバーロードを解決
		////////////////////////

		SUBINFO **ppsi;
		int num;
		ppsi=GetOverloadSubHash(name,&num);
		if(num){
			//オーバーロードを解決
			psi=OverloadSolutionWithStrParam(name,ppsi,num,Parameter,ObjectName,NULL);
			HeapDefaultFree(ppsi);

			if(!psi) return 0;
		}


		Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);
		if( plpRetIndex ){
			*plpRetIndex = psi->u.ReturnIndex;
		}
		return psi->ReturnType;
	}
	else if(idProc==PROC_DLL){
		/////////////////////////
		// DLL関数
		/////////////////////////
		DECLAREINFO *pdi;
		pdi=(DECLAREINFO *)pInfo;

		ret_type=Opcode_CallDllProc(Parameter,pdi,plpRetIndex);
	}
	else if(idProc==PROC_BUILTIN){
		/////////////////////////
		// 組み込み関数
		/////////////////////////
		int FuncId;
		FuncId=(int)(_int64)pInfo;

		ret_type=Opcode_CallFunc(Parameter,FuncId);
	}
	else if(idProc==PROC_PTR){
		/////////////////
		// 関数ポインタ
		/////////////////

		LONG_PTR lpIndex;
		GetVarType(name,&lpIndex,0);

		extern PROCPTRINFO *pProcPtrInfo;
		ret_type=Opcode_CallProcPtr(name,Parameter,&pProcPtrInfo[lpIndex],plpRetIndex);
	}

	return ret_type;
}

BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
	//プロパティ用のメソッドを呼び出す

	//配列要素を取得
	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
	GetArrayElement(variable,VarName,ArrayElements);

	//オブジェクト名を取得
	char ObjectName[VN_SIZE];
	int RefType;
	SplitObjectName(VarName,ObjectName,&RefType);

	//オーバーロード用の関数リストを作成
	SUBINFO **ppsi;
	int num;
	ppsi=GetOverloadSubHash(VarName,&num);
	if(num==0){
		return 0;
	}

	//パラメータを整備
	char *Parameter;
	Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
	lstrcpy(Parameter,ArrayElements);
	if(RightSide){
		if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
		lstrcat(Parameter,RightSide);
	}

	//オーバーロードを解決
	SUBINFO *psi;
	psi=OverloadSolutionWithStrParam(VarName,ppsi,num,Parameter,ObjectName,NULL);
	HeapDefaultFree(ppsi);

	if(psi){
		//呼び出し
		Opcode_CallProc(Parameter,psi,0,ObjectName,RefType);

		if( pRetTypeInfo ){
			pRetTypeInfo->type = psi->ReturnType;
			pRetTypeInfo->u.lpIndex = psi->u.ReturnIndex;
		}
	}

	HeapDefaultFree(Parameter);

	return 1;
}


int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex){
	extern HANDLE hHeap;
	int i;


	extern BOOL bDebugCompile;
	extern BOOL bDebugSupportProc;
	if(bDebugCompile&&bDebugSupportProc==0)
		Call_DebugSys_SaveContext();


	////////////////////////
	// パラメータのセット
	////////////////////////

	//パラメータオブジェクトを生成
	CParameter *pobj_parameter=0;
	pobj_parameter=new CParameter(Parameter);

	//エラーチェック
	if( !pobj_parameter->ErrorCheck(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum) ){
		//パラメータにエラーがあるときは処理を終える
		return pi->ReturnType;
	}

	//スタックフレームに存在する既存のパラメータをバックアップ
	pobj_parameter->BackupParameter(pi->ParmNum);

	//一時オブジェクトを生成
	pobj_parameter->NewTempParameters( variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum );

	//レジスタ、スタックフレームにセット
	pobj_parameter->SetParameter(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum);



	RELATIVE_VAR RelativeVar;
	LONG_PTR lp;
	GetVarOffsetReadOnly(variable,&i,&RelativeVar,&lp);
	SetVarPtrToReg(REG_RAX,&RelativeVar);

	//mov rax,qword ptr[rax]
	op_mov_RM(sizeof(_int64),REG_RAX,REG_RAX,0,MOD_BASE);

	//call rax
	OpBuffer[obp++]=(char)0xFF;
	OpBuffer[obp++]=(char)0xD0;


	//レジスタのブロッキングを解除		※パラメータセット時にロックされたレジスタ
	pobj_BlockReg->clear();

	//一時オブジェクトを破棄
	pobj_parameter->DeleteTempParameters();

	//スタックフレームに存在する既存のパラメータを復元
	pobj_parameter->RestoreParameter(pi->ParmNum);

	//パラメータオブジェクトを破棄
	delete pobj_parameter;

	return pi->ReturnType;
}

void Opcode_CallProc(char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType){
	int i,i2;

	if(psi->dwType==SUBTYPE_MACRO){
		if(lstrcmpi(psi->name,"Print")==0){
			Opcode_Print(Parameter,0);
			return;
		}
		if(lstrcmpi(psi->name,"Input")==0){
			Opcode_Input(Parameter);
			return;
		}
		if(lstrcmpi(psi->name,"Write")==0){
			Opcode_Print(Parameter,1);
			return;
		}
	}

	psi->bUse=1;

	BOOL bStatic=0;
	CClass *pobj_c = NULL;
	CMethod *pMethod = NULL;
	if(psi->pobj_ParentClass){
		//クラスのメンバ関数を呼び出す場合はアクセスチェックを行う
		if(ObjectName[0]){
			if(lstrcmpi(ObjectName,"Super")==0){
				//クラスメンバ関数内から基底クラスの呼び出し
				pobj_c=pobj_CompilingClass;
			}
			else{
				pobj_c=pobj_DBClass->check(ObjectName);
				if(pobj_c){
					//静的メンバ
					bStatic=1;
				}
				else{
					//"->"によってオブジェクトを指定する通常のメンバ関数呼び出し
					GetVarType(ObjectName,(LONG_PTR *)&pobj_c,1);
				}
			}
		}
		else{
			if(dwFlags&PROCFLAG_NEW){
				//New演算子によるコンストラクタ呼び出し
				pobj_c=psi->pobj_ParentClass;
			}
			else{
				//クラスメンバ関数内から同一クラスのメンバ関数の呼び出し
				pobj_c=pobj_CompilingClass;
			}
		}


		/////////////////////////////////
		// メソッド情報を取得
		/////////////////////////////////
		pMethod = NULL;
		if( ! bStatic ) pMethod = pobj_c->GetMethodInfo( psi );
		if( ! pMethod ){
			//動的メソッドが取得できなかったときは静的メソッドを当たる
			pMethod = pobj_c->GetStaticMethodInfo( psi );
			if( !pMethod ){
				SetError(300,NULL,cp);
				return;
			}

			//静的メンバ
			bStatic=1;
		}


		//////////////////////////////
		// アクセスエラーチェック
		//////////////////////////////
		DWORD dwAccess = pMethod->dwAccess;

		if(ObjectName[0]){
			//外部からの呼び出し
			if(pobj_c==pobj_CompilingClass){
				//同一クラスオブジェクトの場合はプライベートアクセスを容認する
				if(dwAccess==ACCESS_NON){
					SetError(109,psi->name,cp);
					return;
				}
			}
			else{
				if(dwAccess==ACCESS_PRIVATE||
					dwAccess==ACCESS_NON){
					SetError(109,psi->name,cp);
					return;
				}
				if(dwAccess==ACCESS_PROTECTED){
					SetError(110,psi->name,cp);
					return;
				}
			}
		}
		else{
			//クラス内部からの呼び出し（継承によるACCESS_NONのみをエラーとする）
			if(dwAccess==ACCESS_NON){
				SetError(109,psi->name,cp);
				return;
			}
		}
	}


	///////////////////////////////////////////////////////////////
	// _System_LocalThis、_System_ReturnObjectのダミーをセット
	///////////////////////////////////////////////////////////////

	char temporary[VN_SIZE]={0};
	if(psi->pobj_ParentClass&&bStatic==0){
		//_System_LocalThis（第一パラメータ）のダミーを作成
		lstrcpy(temporary,"0,");
	}

	if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false ){
		//_System_ReturnObject（第一または第二パラメータのダミーを作成）
		sprintf(temporary+lstrlen(temporary),"%c%c0,",1,ESC_BYVAL);
	}

	if(Parameter[0]=='\0'&&temporary[0])
		temporary[lstrlen(temporary)-1]=0;
	else lstrcat(temporary,Parameter);


	////////////////////////
	// パラメータをセット
	////////////////////////

	//パラメータオブジェクトを生成
	CParameter *pobj_parameter=0;
	pobj_parameter=new CParameter(temporary);

	//エラーチェック
	if( !pobj_parameter->ErrorCheck(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->SecondParmNum) ){
		//パラメータにエラーがあるときは処理を終える
		return;
	}

	if(psi->dwType==SUBTYPE_MACRO){
		//マクロ関数の場合は、パラメータ省略を考慮する
		pobj_parameter->MacroParameterSupport(psi->pRealParmInfo);
	}

	//スタックフレームに存在する既存のパラメータをバックアップ
	pobj_parameter->BackupParameter(psi->RealParmNum);

	//一時オブジェクトを生成
	pobj_parameter->NewTempParameters( psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum );

	//レジスタ、スタックフレームにセット
	pobj_parameter->SetParameter(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum);


	if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
		//////////////////////////////////////////////////////
		// 戻り値にオブジェクト インスタンスを持つ場合
		// ※ByRef _System_ReturnObject パラメータをセット
		//////////////////////////////////////////////////////


		//////////////////////////////////////////////////////
		/////    レジスタ資源のバックアップ
		{	BACKUP_REGISTER_RESOURCE
		//////////////////////////////////////////////////////

			int object_size;
			object_size=GetSizeOfClass(psi->u.Return_pobj_c);

			//mov rcx,object_size
			op_mov_RV(sizeof(_int64),REG_RCX,object_size);

			//call calloc
			extern SUBINFO *pSub_calloc;
			op_call(pSub_calloc);

			//mov r13,rax
			op_mov_RR(REG_R13,REG_RAX);

		/////////////////////////////////////////////
		//////   レジスタ資源を復元
			RESTORE_REGISTER_RESOURCE
		}////////////////////////////////////////////

		if(psi->pobj_ParentClass&&bStatic==0){
			//mov rdx,r13
			op_mov_RR(REG_RDX,REG_R13);
		}
		else{
			//mov rcx,r13
			op_mov_RR(REG_RCX,REG_R13);
		}
	}


	if(psi->pobj_ParentClass&&bStatic==0){
		///////////////////////////////
		// メンバ関数の場合
		// thisポインタをrcxで受け渡す
		///////////////////////////////

		if(ObjectName[0]){
			if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;
			else{
				RELATIVE_VAR RelativeVar;
				if( pMethod->isConst ){
					//Constアクセスが可能なメソッドの場合
					if( !GetVarOffsetReadOnly( ObjectName, &i2, &RelativeVar, 0 ) ) return;
				}
				else{
					//Constアクセスが不可能なメソッドの場合
					if( !GetVarOffsetReadWrite( ObjectName, &i2, &RelativeVar, 0 ) ) return;
				}

				SetVarPtrToReg(REG_RCX,&RelativeVar);

				//参照タイプが "->" の場合
				if(RefType==DEF_PTR_OBJECT){
					//mov rcx,qword ptr[rcx]
					op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
				}
			}
		}
		else{
InClassMember:
			if(dwFlags&PROCFLAG_NEW){
				//New演算子によるコンストラクタ呼び出しの場合

				//mov rcx,qword ptr[rsp+offset]     ※スタックフレームを利用
				pobj_sf->ref(REG_RCX);
			}
			else{
				//自身のオブジェクトのThisポインタをrcxにコピー
				SetThisPtrToReg(REG_RCX);
			}
		}
	}

	if(psi->bVirtual){
		//仮想関数（オブジェクトメソッド）呼び出し
		//pObj->func_table->func1
		//                ->func2
		//                ->func3

		//mov r11,qword ptr[rcx]
		op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);

		for(i=0,i2=0;i<pobj_c->iMethodNum;i++){
			if(pobj_c->ppobj_Method[i]->psi==psi) break;
			if(pobj_c->ppobj_Method[i]->psi->bVirtual) i2++;
		}

		//call qword ptr[r11+func_index]
		if(i2*PTR_SIZE<=0x7F){
			OpBuffer[obp++]=(char)0x41;
			OpBuffer[obp++]=(char)0xFF;
			OpBuffer[obp++]=(char)0x53;
			OpBuffer[obp++]=(char)(i2*PTR_SIZE);
		}
		else{
			OpBuffer[obp++]=(char)0x41;
			OpBuffer[obp++]=(char)0xFF;
			OpBuffer[obp++]=(char)0x93;
			*((long *)(OpBuffer+obp))=i2*PTR_SIZE;
			obp+=sizeof(long);
		}
	}
	else{
		//通常呼び出し

		//call ProcAddr
		op_call(psi);
	}

	/* 64コンパイラでは不要
	if(pdi->bCdecl){
		//add esp,ParmSize
	}*/


	//レジスタのブロッキングを解除		※パラメータセット時にロックされたレジスタ
	pobj_BlockReg->clear();

	//一時オブジェクトを破棄
	pobj_parameter->DeleteTempParameters();

	//スタックフレームに存在する既存のパラメータを復元
	pobj_parameter->RestoreParameter(psi->RealParmNum);

	//パラメータオブジェクトを破棄
	delete pobj_parameter;
}

int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex){
	char *temporary;

	temporary=(char *)HeapAlloc(hHeap,0,lstrlen(Parameter)+1);

	extern BOOL bDebugCompile;
	extern BOOL bDebugSupportProc;
	if(bDebugCompile&&bDebugSupportProc==0&&lstrcmp(pdi->name,"DebugBreak")!=0)
		Call_DebugSys_SaveContext();



	////////////////////////
	// パラメータのセット
	////////////////////////

	//パラメータオブジェクトを生成
	CParameter *pobj_parameter=0;
	pobj_parameter=new CParameter(Parameter);

	//エラーチェック
	if( !pobj_parameter->ErrorCheck(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum) ){
		//パラメータにエラーがあるときは処理を終える
		return pdi->ReturnType;
	}

	//スタックフレームに存在する既存のパラメータをバックアップ
	pobj_parameter->BackupParameter(pdi->ParmNum);

	//レジスタ、スタックフレームにセット
	pobj_parameter->SetParameter(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum);


	//レジスタのブロッキングを解除		※パラメータセット時にロックされたレジスタ
	pobj_BlockReg->clear();


	//動的リンクされたプロシージャの呼び出し

	//call dword ptr[ImportTable]
	op_call( pdi );

	/* 64コンパイラでは不要
	if(pdi->bCdecl){
		//add esp,ParmSize
	}*/

	//スタックフレームに存在する既存のパラメータを復元
	pobj_parameter->RestoreParameter(pdi->ParmNum);

	//パラメータオブジェクトを破棄
	delete pobj_parameter;

	if(plpIndex) *plpIndex=pdi->u.ReturnIndex;

	HeapDefaultFree(temporary);

	return pdi->ReturnType;
}