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

int ParamImpl::NewTempParameters( const string &procName, const Parameters &params, int SecondParmNum ){
	if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();

	///////////////////////////////////////////////////////
	// 一時オブジェクトをあらかじめスタックに積んでおく
	///////////////////////////////////////////////////////

	useTempObject = false;

	//一時参照の数
	nCountOfTempObjects = 0;

	BOOL bEllipse;
	if(params.size()){
		if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
		else bEllipse=0;
	}
	else bEllipse=0;

	for(int i2=ParmsNum-1;i2>=0;i2--){
		useTempParameters[i2] = false;

		if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;

		if(i2==0){
			if( params[i2]->GetVarName() == "_System_LocalThis" ){
				//オブジェクトメンバの第一パラメータのThisポインタ
				continue;
			}
		}
		if( i2==0||i2==1 ){
			if( params[i2]->GetVarName() == procName ){
				//オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
				continue;
			}
		}

		Type DummyTypeInfo;
		BOOL bByVal;
		if(bEllipse){
			DummyTypeInfo.type=NumOpe_GetType_Old(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
			bByVal=1;
		}
		else{
			DummyTypeInfo.type=params[i2]->GetBasicType();
			DummyTypeInfo.u.lpIndex=params[i2]->GetIndex();
			bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
		}


		if( !bByVal ){
			//ポインタ参照
			if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
				//ポインタ指定
				continue;
			}

			LONG_PTR lpVarIndex;
			if( GetVarType( Parms[i2], &lpVarIndex, FALSE ) == -1 ){
				//変数ではないとき
				int reg = REG_RAX;
				int type = NumOpe( Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
				//↑ここでスタックに積む

				nCountOfTempObjects++;

				if( type != DEF_STRUCT ){
					//一時参照を作成

					//push esp
					op_push( REG_ESP );

					nCountOfTempObjects++;
				}

				bool result = CheckDifferentType(
					DummyTypeInfo.type,
					DummyTypeInfo.u.lpIndex,
					type,
					lpVarIndex,
					procName.c_str(),
					i2);

				if( result ){
					useTempParameters[i2] = true;
					useTempObject = true;

					types[i2].type = type;
					types[i2].u.lpIndex = lpVarIndex;
				}
			}
		}
	}

	return nCountOfTempObjects * PTR_SIZE;
}

void ParamImpl::DeleteTempParameters(){
	///////////////////////////////////////////////////////
	// 一時オブジェクトを破棄
	///////////////////////////////////////////////////////
	if( !useTempObject ) return;

	for(int i2=ParmsNum-1;i2>=0;i2--){
		if( useTempParameters[i2] ){
			if( types[i2].type == DEF_STRUCT ){
				// 構造体の一時メモリ

				//メモリを解放する

				//call free
				extern UserProc *pSub_free;
				op_call(pSub_free);
			}
			else{
				if( Is64Type( types[i2].type ) ){
					//pop ... 参照を消す
					//pop ... 上位32ビット
					//pop ... 下位32ビット
					op_add_esp( PTR_SIZE * 3 );
				}
				else{
					//pop ... 参照を消す
					//pop ... 値を消す
					op_add_esp( PTR_SIZE * 2 );
				}
			}
		}
	}
}

void ParamImpl::SetStructParameter(CClass *pobj_Class,LPSTR Parameter){
	int object_size = pobj_Class->GetSize();

	//push object_size
	op_push_V(object_size);

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

	//push eax
	op_push(REG_EAX);


	Type BaseType={DEF_STRUCT,(LONG_PTR)pobj_Class};
	Type CalcType;
	CalcType.type=NumOpe_GetType_Old(Parameter,&BaseType,&CalcType.u.lpIndex);

	/*
	TODO: 消す
	if( pobj_Class->GetCopyConstructorMethod()
		&& CalcType.type==DEF_OBJECT&&CalcType.u.pobj_Class==pobj_Class){
		////////////////////////////////////
		// コピーコンストラクタを呼び出す
		////////////////////////////////////

		//push eax
		op_push(REG_EAX);

		BOOL bUseHeap;
		CalcType.type=NumOpe(Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);

		//pop ecx
		op_pop(REG_ECX);

		//pop eax
		op_pop(REG_EAX);

		if(bUseHeap){
			//※解放用に退避
			//mov esi,ecx
			op_mov_RR(REG_ESI,REG_ECX);
		}

		//push ecx
		op_push(REG_ECX);

		//push eax
		op_push(REG_EAX);

		//call constructor
		op_call(pobj_Class->GetCopyConstructorMethod()->pUserProc);


		if(bUseHeap){
			FreeTempObject(REG_ESI,pobj_Class);
		}
	}
	else{*/


		//push eax
		op_push(REG_EAX);

/*
			TODO: 消す
			if( pobj_Class->GetConstructorMethod() ){
				////////////////////////////////
				// コンストラクタを呼び出す
				////////////////////////////////

				//push this
				op_push(REG_EAX);

				//call constructor
				op_call(pobj_Class->GetConstructorMethod()->pUserProc);
			}
*/

			BOOL bUseHeap;
			CalcType.type=NumOpe(Parameter,DEF_STRUCT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);



		SetStructVariable((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,bUseHeap);
	//}
}

int ParamImpl::SetParameter( const string &procName, const Parameters &params, int SecondParmNum ){
	if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();

	///////////////////////////////////////////////////////////
	// パラメータをレジスタ及びスタックフレームにセット
	///////////////////////////////////////////////////////////
	int i2,i3;

	BOOL bEllipse;
	if( params.size() ){
		if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
		else bEllipse=0;
	}
	else bEllipse=0;

	BOOL bHas_System_LocalThis=0;
	if(ParmsNum>=1){
		if( params[0]->GetVarName() == "_System_LocalThis" ){
			bHas_System_LocalThis=1;
		}
	}

	//戻り値用の変数名を取得
	const char *lpszVarNameToReturn = (procName[0]==1&&procName[1]==ESC_OPERATOR)?"_System_ReturnValue":procName.c_str();

	//パラメータをレジスタとスタックに格納
	int CalcType;
	LONG_PTR lpCalcIndex;
	BOOL bCalcUseHeap;
	int ParmSize=0;
	RELATIVE_VAR RelativeVar;
	int nCountOfNowTempObjects = 0;
	for(i2=ParmsNum-1;i2>=0;i2--){
		if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;

		if(i2==0){
			if( params[i2]->GetVarName() == "_System_LocalThis" ){
				//オブジェクトメンバの第一パラメータのThisポインタ
				continue;
			}
		}
		if(i2==0||i2==1){
			if( params[i2]->GetVarName() == lpszVarNameToReturn ){
				//オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
				continue;
			}
		}

		Type DummyTypeInfo;
		BOOL bByVal;
		if(bEllipse){
			DummyTypeInfo.type=NumOpe_GetType_Old(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
			bByVal=1;
		}
		else{
			DummyTypeInfo.type=params[i2]->GetBasicType();
			DummyTypeInfo.u.lpIndex=params[i2]->GetIndex();
			bByVal = (params[i2]->IsRef() == false ) ? TRUE:FALSE;
		}

		if(bByVal==1){
			//値参照

			if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
				char temp2[255];
				sprintf(temp2,"%s関数の第%dパラメータ",procName,i2+1);
				SetError(19,temp2,cp);
				continue;
			}

			if(DummyTypeInfo.type==DEF_STRUCT){
				SetStructParameter(DummyTypeInfo.u.pobj_Class,Parms[i2]);
				goto next;
			}


			extern LONG_PTR ProcPtr_BaseIndex;
			LONG_PTR back_ProcPtr_BaseIndex;
			back_ProcPtr_BaseIndex=ProcPtr_BaseIndex;
			if(DummyTypeInfo.type==DEF_PTR_PROC) ProcPtr_BaseIndex=DummyTypeInfo.u.lpIndex;
			else ProcPtr_BaseIndex=-1;

			CalcType=NumOpe(Parms[i2],DummyTypeInfo.type,DummyTypeInfo.u.lpIndex,&lpCalcIndex,&bCalcUseHeap);

			ProcPtr_BaseIndex=back_ProcPtr_BaseIndex;

			if(CalcType==-1) break;

			if(CalcType==DEF_OBJECT){
				if( DummyTypeInfo.type != DEF_OBJECT
					||
					DummyTypeInfo.type == DEF_OBJECT &&
					!DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpCalcIndex ) ){
						//キャスト演算子のオーバーロードに対応する
						CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
				}
			}

			if(!bEllipse){
				//型チェック
				if(bHas_System_LocalThis) i3=i2-1;
				else i3=i2;
				CheckDifferentType(
					DummyTypeInfo.type,
					DummyTypeInfo.u.lpIndex,
					CalcType,
					lpCalcIndex,
					procName.c_str(),
					i3);
			}

			if(DummyTypeInfo.type==DEF_DOUBLE){
				ChangeTypeToDouble(CalcType);
				ParmSize+=sizeof(long)*2;
			}
			else if(DummyTypeInfo.type==DEF_SINGLE){
				ChangeTypeToSingle(CalcType);
				ParmSize+=sizeof(long);
			}
			else if(DummyTypeInfo.type==DEF_INT64||DummyTypeInfo.type==DEF_QWORD){
				ChangeTypeToInt64(CalcType);
				ParmSize+=sizeof(long)*2;
			}
			else if(DummyTypeInfo.type==DEF_LONG||DummyTypeInfo.type==DEF_DWORD||DummyTypeInfo.type==DEF_OBJECT||DummyTypeInfo.type==DEF_STRUCT||
				(IsPtrType(DummyTypeInfo.type)/*&&DummyTypeInfo.type!=DEF_PTR_VOID&&DummyTypeInfo.type!=DEF_PTR_BYTE*/)){
				ChangeTypeToLong(CalcType);
				ParmSize+=sizeof(long);
			}
			else if(DummyTypeInfo.type==DEF_INTEGER||DummyTypeInfo.type==DEF_WORD || (isUnicode&&DummyTypeInfo.type==DEF_CHAR)){
				ChangeTypeToInteger(CalcType);
				ParmSize+=sizeof(long);
			}
			else if(DummyTypeInfo.type==DEF_SBYTE||DummyTypeInfo.type==DEF_BYTE||DummyTypeInfo.type==DEF_BOOLEAN || (isUnicode==false&&DummyTypeInfo.type==DEF_CHAR)){
				ChangeTypeToByte(CalcType);
				ParmSize+=sizeof(long);
			}
			else{
				SetError(300,NULL,cp);
			}
		}
		else{
			//ポインタ参照
			if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
				//ポインタ指定
				i3=NumOpe(Parms[i2]+2,0,0,0);

				ChangeTypeToLong(i3);
			}
			else{
				if( useTempParameters[i2] ){
					//一時オブジェクトをコピー

					if( types[i2].type != DEF_STRUCT ){
						// 一時参照のための領域を考慮する
						nCountOfNowTempObjects++;
					}

					nCountOfNowTempObjects++;

					//mov eax, dword ptr[esp+offset]
					op_mov_RM(
						sizeof(long),
						REG_EAX,
						REG_ESP,
						( ( ParmsNum - i2 - 1 ) + ( nCountOfTempObjects - nCountOfNowTempObjects ) ) * PTR_SIZE,
						MOD_BASE_DISP32 );

					//push eax
					op_push(REG_EAX);
				}
				else{
					//変数のアドレスを取得
					int VarType;
					LONG_PTR lpVarIndex;
					if(GetVarOffset(
						false,
						false,
						Parms[i2],
						&VarType,
						&RelativeVar,
						&lpVarIndex)){
							if(DummyTypeInfo.type!=DEF_ANY){
								//型チェックを行う
								if(DummyTypeInfo.type==VarType){
									if(DummyTypeInfo.type==DEF_OBJECT){
										if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
											SetError(11,Parms[i2],cp);
										}
									}
									else if(DummyTypeInfo.type==DEF_STRUCT){
										if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
											SetError(11,Parms[i2],cp);
										}
									}
								}
								else if((VarType&FLAG_PTR)&&((int)(VarType^FLAG_PTR)==DummyTypeInfo.type)){
									//仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
								}
								else{
									SetError(11,Parms[i2],cp);
								}
							}

							//変数アドレスをレジスタにセット
							SetVarPtrToEax(&RelativeVar);

							//push eax
							op_push(REG_EAX);
					}
				}
			}

			ParmSize+=PTR_SIZE;
		}

next:;
	}

	return ParmSize;
}