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

void _call_constructor(CClass *pobj_c,const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
	////////////////////////////
	// コンストラクタの呼び出し
	////////////////////////////
	
	//この関数を使用する場合は、
	//・ebxにオブジェクトの個数（複数個の場合のみ）
	//・スタックフレームの先頭参照位置に先頭Thisポインタ
	//をセットしておかなければならない

	int jnz_back;


	//jnzの番地
	jnz_back=obp;

	if(bSomeObjects){
		//mov qword ptr[rsp+offset],rbx     ※スタックフレームを利用
		pobj_sf->push(REG_RBX);

		// ※ここでプッシュされた値はコンストラクタのthisポインタとなる
		//mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
		pobj_sf->push(REG_RAX);
	}


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

	std::vector<SUBINFO *> subs;
	pobj_c->EnumMethod( pobj_c->name, subs );

	SUBINFO *psi;
	if( subs.size() > 0 ){
		//オーバーロードを解決
		psi=OverloadSolutionWithStrParam(pobj_c->name,
			subs,CreateParameter,"",NULL);

		if(!psi) return;
	}

	//コンストラクタを呼び出す
	Opcode_CallProc(CreateParameter,
		psi,
		PROCFLAG_NEW,"",0);

	if(bSomeObjects){
		//mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
		pobj_sf->pop(REG_RAX);

		//mov rbx,qword ptr[rsp+offset]     ※スタックフレームを利用
		pobj_sf->pop(REG_RBX);

		//add eax,TypeSize
		OpBuffer[obp++]=(char)0x05;
		*((long *)(OpBuffer+obp))=ObjectSize;
		obp+=sizeof(long);

		//sub ebx,1
		OpBuffer[obp++]=(char)0x83;
		OpBuffer[obp++]=(char)0xEB;
		OpBuffer[obp++]=(char)0x01;

		//jnz ↑
		OpBuffer[obp++]=(char)0x0F;
		OpBuffer[obp++]=(char)0x85;
		*((long *)(OpBuffer+obp))=jnz_back-(obp+sizeof(long));
		obp+=sizeof(long);
	}
}
void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter, const TYPEINFO &baseTypeInfo ){
	int typeSize = classObj.GetSize();

	if(classObj.IsAbstract()){
		//抽象クラスだったとき
		SetError(125,classObj.name,cp);
	}

	BOOL bSomeObjects=0;
	if(objectSizeStr[0]){
		bSomeObjects=1;

		int reg=REG_RAX;
		int type = NumOpe(&reg,objectSizeStr,0,0,0);
		if(!IsWholeNumberType(type)) SetError(49,NULL,cp);

		//※添え字上限値であることを考慮
		//add rax,1
		op_add_RV(REG_RAX,1);

		//オブジェクトの個数をrbxに一時保持
		//※rbxは関数が呼ばれても不変
		//mov rbx,rax
		op_mov_RR(REG_RBX,REG_RAX);

		//imul rax,size
		op_imul_RV(sizeof(_int64),REG_RAX,typeSize);

		//add rax,PTR_SIZE*3
		op_add_RV(REG_RAX,PTR_SIZE*3);

		//mov rcx,rax
		op_mov_RR(REG_RCX,REG_RAX);
	}
	else{
		//オブジェクトの個数をrbxに一時保持
		//※rbxは関数が呼ばれても不変
		//mov rbx,1
		op_mov_RV(sizeof(_int64),REG_RBX,1);

		//mov rcx,typeSize+PTR_SIZE*3
		op_mov_RV(sizeof(_int64),REG_RCX,typeSize+PTR_SIZE*3);
	}

	if( baseTypeInfo.type == DEF_OBJECT ){
		//DeleteはGCで処理

		//call _System_GC_malloc_ForObject
		extern SUBINFO *pSub_System_GC_malloc_ForObject;
		op_call(pSub_System_GC_malloc_ForObject);
	}
	else{
		//明示的なDeleteが必要

		//call _System_GC_malloc_ForObjectPtr
		extern SUBINFO *pSub_System_GC_malloc_ForObjectPtr;
		op_call(pSub_System_GC_malloc_ForObjectPtr);
	}


	/*
	確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
	pPtr-=sizeof(DWORD)*3
	pPtr[0]=オブジェクトの個数
	pPtr[1]=オブジェクトのサイズ
	pPtr[2]=デストラクタの関数ポインタ
	*/


	//mov qword ptr[rax],rbx（オブジェクトの個数）
	op_mov_MR(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);

	//add rax,PTR_SIZE
	op_add_RV(REG_RAX,PTR_SIZE);


	//mov qword ptr[rax],typeSize（オブジェクトのサイズ）
	op_mov_MV(sizeof(_int64),REG_RAX,0,NON_OFFSET,typeSize);

	//add rax,PTR_SIZE
	op_add_RV(REG_RAX,PTR_SIZE);


	CMethod *method = classObj.GetDestructorMethod();
	if( method == NULL ) return;

	//mov rcx,DestructorProcAddr
	op_mov_RV(sizeof(_int64),REG_RCX,0);
	obp-=sizeof(long);
	pobj_SubAddrSchedule->add(method->psi,0);
	method->psi->bUse=1;
	obp+=sizeof(long);

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

	//add rax,PTR_SIZE
	op_add_RV(REG_RAX,PTR_SIZE);


	// ※ここでプッシュされた値はNew演算子の戻り値となる
	//mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
	pobj_sf->push(REG_RAX);


	/////////////////////////////////////////////////////////////////////

	////////////////////////////
	// コンストラクタの呼び出し
	////////////////////////////

	_call_constructor(&classObj,parameter,typeSize,bSomeObjects);


	//mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
	pobj_sf->pop(REG_RAX);
}
int Operator_New(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo ){
	char TypeName[VN_SIZE],CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
	int i,i2;

	i=0;

	if(Parameter[0]=='['){
		i=GetStringInBracket(objectSizeStr,Parameter);

		SlideString(objectSizeStr+1,-1);
		objectSizeStr[i-2]=0;
	}
	else objectSizeStr[0]=0;

	for(i2=0;;i++,i2++){
		if(Parameter[i]=='('){
			TypeName[i2]=0;

			//コンストラクタに渡すパラメータを取得
			i2=GetStringInPare(CreateParameter,Parameter+i);
			RemoveStringPare(CreateParameter);
			i+=i2;
			if(Parameter[i]!='\0'){
				SetError(42,NULL,cp);
				return 0;
			}
			break;
		}
		TypeName[i2]=Parameter[i];
		if(Parameter[i]=='\0'){
			CreateParameter[0]=0;
			break;
		}
	}

	int type;
	type=GetTypeFixed(TypeName,plpIndex);
	if(type==-1){
		SetError(3,TypeName,cp);
		return 0;
	}

	if(type!=DEF_OBJECT){
		////////////////////////
		// 通常のデータ型の場合
		////////////////////////

		SetError(121,NULL,cp);
		return 0;
	}

	CClass *pobj_c;
	pobj_c=(CClass *)*plpIndex;

	Operator_New( *pobj_c, objectSizeStr, CreateParameter, baseTypeInfo );

	if( baseTypeInfo.type == DEF_OBJECT ){
		return DEF_OBJECT;
	}
	return DEF_PTR_OBJECT;
}

void OpcodeDelete(const char *Parameter, bool isSweeping){
	int type;

	int reg=REG_RAX;
	type=NumOpe(&reg,Parameter,0,0,0);
	if(type==-1) return;
	if(!(type==DEF_PTR_OBJECT||type==DEF_PTR_VOID)) SetError(122,NULL,cp);

	//sub rax,PTR_SIZE*3
	op_sub_RV(sizeof(_int64),REG_RAX,PTR_SIZE*3);

	//mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
	pobj_sf->push(REG_RAX);


	//mov rbx,qword ptr[rax]（オブジェクトの個数）
	op_mov_RM(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);

	//add rax,PTR_SIZE
	op_add_RV(REG_RAX,PTR_SIZE);


	//mov rsi,qword ptr[rax]（オブジェクトのサイズ）
	op_mov_RM(sizeof(_int64),REG_RSI,REG_RAX,0,MOD_BASE);

	//add rax,PTR_SIZE
	op_add_RV(REG_RAX,PTR_SIZE);


	//mov rdi,qword ptr[rax]（デストラクタの関数ポインタ）
	op_mov_RM(sizeof(_int64),REG_RDI,REG_RAX,0,MOD_BASE);

	//add rax,PTR_SIZE
	op_add_RV(REG_RAX,PTR_SIZE);


	//mov rcx,rax
	op_mov_RR(REG_RCX,REG_RAX);


	//jnzの番地
	int jnz_back;
	jnz_back=obp;

	//mov qword ptr[rsp+offset],rcx     ※スタックフレームを利用
	pobj_sf->push(REG_RCX);

	//call rdi
	OpBuffer[obp++]=(char)0xFF;
	OpBuffer[obp++]=(char)0xD7;

	//mov rcx,qword ptr[rsp+offset]     ※スタックフレームを利用
	pobj_sf->pop(REG_RCX);

	//add rcx,rsi
	op_add64_reg(REG_RCX,REG_RSI);

	//sub rbx,1
	op_sub_RV(sizeof(_int64),REG_RBX,1);

	//jnz ↑
	OpBuffer[obp++]=(char)0x0F;
	OpBuffer[obp++]=(char)0x85;
	*((long *)(OpBuffer+obp))=jnz_back-(obp+sizeof(long));
	obp+=sizeof(long);


	//////////////////////////////////////////
	// オブジェクトメンバ変数用のメモリを解放
	//////////////////////////////////////////

	//mov rcx,qword ptr[rsp+offset]     ※スタックフレームを利用
	pobj_sf->pop(REG_RCX);

	if( isSweeping ){
		//call _System_GC_free_for_SweepingDelete
		extern SUBINFO *pSub_System_GC_free_for_SweepingDelete;
		op_call(pSub_System_GC_free_for_SweepingDelete);
	}
	else{
		//call free
		extern SUBINFO *pSub_free;
		op_call(pSub_free);
	}
}