#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);

	//push eax
	op_push(REG_EAX);

	//push ebp
	op_push(REG_EBP);

	//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;
		GetObjectName(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;
		}


		ret_type=Opcode_CallProc(Parameter,psi,plpRetIndex,0,ObjectName,RefType);
	}
	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;
	GetObjectName(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){
		//呼び出し
		int type;
		LONG_PTR lpIndex;
		type=Opcode_CallProc(Parameter,psi,&lpIndex,0,ObjectName,RefType);

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

	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);

	//エラーチェック
	pobj_parameter->ErrorCheck(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum);

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

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


	RELATIVE_VAR RelativeVar;
	LONG_PTR lp;
	GetVarOffset(1,variable,&i,&RelativeVar,&lp);
	SetVarPtrToEax(&RelativeVar);

	//mov eax,dword ptr[eax]
	OpBuffer[obp++]=(char)0x8B;
	OpBuffer[obp++]=(char)0x00;

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

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

	return pi->ReturnType;
}

int Opcode_CallProc(char *Parameter,SUBINFO *psi,LONG_PTR *plpIndex,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 -1;
		}
		if(lstrcmpi(psi->name,"Input")==0){
			Opcode_Input(Parameter);
			return -1;
		}
		if(lstrcmpi(psi->name,"Write")==0){
			Opcode_Print(Parameter,1);
			return -1;
		}
	}

	psi->bUse=1;

	BOOL bStatic=0;
	CClass *pobj_c;
	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;
			}
		}


		DWORD dwAccess;
		for(i=0;i<pobj_c->iMethodNum;i++){
			if(psi==pobj_c->ppobj_Method[i]->psi) break;
		}
		if(i==pobj_c->iMethodNum){
			for(i=0;i<pobj_c->iStaticMethodNum;i++){
				if(psi==pobj_c->ppobj_StaticMethod[i]->psi) break;
			}
			dwAccess=pobj_c->ppobj_StaticMethod[i]->dwAccess;

			bStatic=1;
		}
		else dwAccess=pobj_c->ppobj_Method[i]->dwAccess;


		//////////////////////////////
		// アクセスエラーチェック
		//////////////////////////////

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



	///////////////////////////////////////////////////////////////
	// _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){
		//_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);

	//エラーチェック
	pobj_parameter->ErrorCheck(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum);

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

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

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



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

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

		//push object_size
		op_push_value(object_size);

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

		//push eax
		op_push(REG_EAX);
	}


	if(psi->pobj_ParentClass&&bStatic==0){
		//////////////////////////////////////////////////////
		// メンバ関数の場合
		// ※_System_LocalThis パラメータをセット
		//////////////////////////////////////////////////////

		if(ObjectName[0]){
			if(lstrcmpi(ObjectName,"Super")==0) goto InClassMember;

			RELATIVE_VAR RelativeVar;
			if(!GetVarOffset(1,ObjectName,&i2,&RelativeVar,0)) return -1;
			SetVarPtrToEax(&RelativeVar);

			//参照タイプが整合しているかをチェック
			if(i2!=RefType) SetError(104,ObjectName,cp);

			if(i2==DEF_PTR_OBJECT){
				//mov eax,dword ptr[eax]
				OpBuffer[obp++]=(char)0x8B;
				OpBuffer[obp++]=(char)0x00;
			}

			//mov ecx,eax
			OpBuffer[obp++]=(char)0x8B;
			OpBuffer[obp++]=(char)0xC8;
		}
		else{
InClassMember:
			if(dwFlags&PROCFLAG_NEW){
				//New演算子によるコンストラクタ呼び出しの場合
				//mov ecx,dword ptr[esp+ParmSize]
				OpBuffer[obp++]=(char)0x8B;
				OpBuffer[obp++]=(char)0x8C;
				OpBuffer[obp++]=(char)0x24;
				*((long *)(OpBuffer+obp))=ParmSize;
				obp+=sizeof(long);
			}
			else{
				//Thisポインタをecxにコピー
				SetThisPtrToReg(REG_ECX);
			}
		}

		//push ecx
		op_push(REG_ECX);
	}

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

		//mov edx,dword ptr[ecx]
		OpBuffer[obp++]=(char)0x8B;
		OpBuffer[obp++]=(char)0x11;

		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 dword ptr[edx+func_index]
		if(i2*PTR_SIZE<=0x7F){
			OpBuffer[obp++]=(char)0xFF;
			OpBuffer[obp++]=(char)0x52;
			OpBuffer[obp++]=(char)(i2*PTR_SIZE);
		}
		else{
			OpBuffer[obp++]=(char)0xFF;
			OpBuffer[obp++]=(char)0x92;
			*((long *)(OpBuffer+obp))=i2*PTR_SIZE;
			obp+=sizeof(long);
		}
	}
	else{
		//通常呼び出し

		//call ProcAddr
		op_call(psi);
	}

	if(psi->bCdecl){
		//add esp,ParmSize
		op_add_esp(ParmSize);
	}

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

	return psi->ReturnType;
}

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();

	pdi->bUse=1;


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

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

	//エラーチェック
	pobj_parameter->ErrorCheck(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum);

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

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


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

	//call dword ptr[LookupTable]
	OpBuffer[obp++]=(char)0xFF;
	OpBuffer[obp++]=(char)0x15;
	pobj_ImportAddrSchedule->add(pdi);
	obp+=sizeof(long);

	if(pdi->bCdecl){
		//add esp,ParmSize
		op_add_esp(ParmSize);
	}

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

	HeapDefaultFree(temporary);

	return pdi->ReturnType;
}