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

BOOL CalcTwoTerm_Logical(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer){
	//value[sp-2] xor= value[sp-1]
	//xor演算

	int sp;
	sp=*pStackPointer;

	if(IsRealNumberType(type[sp-2])||IsRealNumberType(type[sp-1])){
		//いずれかの項が実数のとき
		SetError(45,"xor",cp);
		return 0;
	}

	int reg1,reg2;

	if(Is64Type(type[sp-2])||Is64Type(type[sp-1])){
		//////////////////////
		// 64ビット整数演算
		//////////////////////

		SetTowTermToReg_Whole64Calc(type,sp,&reg1,&reg2);

		if(idCalc==CALC_XOR){
			//xor reg1,reg2
			op_xor_reg(sizeof(_int64),reg1,reg2);
		}
		else if(idCalc==CALC_OR){
			//or reg1,reg2
			op_or_reg(sizeof(_int64),reg1,reg2);
		}
		else if(idCalc==CALC_AND){
			//and reg1,reg2
			op_and_reg(sizeof(_int64),reg1,reg2);
		}

		if(reg1==REG_R14){
			//mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
			pobj_sf->push(REG_R14);
		}

		sp--;
		type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
	}
	else{
		//32ビット以下の整数演算

		SetTowTermToReg_Whole32Calc(type,sp,&reg1,&reg2);

		if(idCalc==CALC_ADDITION){
			//add reg1,reg2
			op_xor_reg(sizeof(long),reg1,reg2);
		}
		else if(idCalc==CALC_OR){
			//or reg1,reg2
			op_or_reg(sizeof(long),reg1,reg2);
		}
		else if(idCalc==CALC_AND){
			//and reg1,reg2
			op_and_reg(sizeof(long),reg1,reg2);
		}

		if(reg1==REG_R14){
			//mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
			pobj_sf->push(REG_R14);
		}

		sp--;
		type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
	}

	*pStackPointer=sp;
	return 1;
}

BOOL Calc_Not(int *type,int sp){
	//value[sp-1]=Not value[sp-1]
	//NOT演算子

	if(IsRealNumberType(type[sp-1])){
		//実数のとき
		SetError(45,"Not",cp);
		return 0;
	}

	int reg;

	if( type[sp - 1] == DEF_BOOLEAN ){
		SetOneTermToReg_Whole32Calc(type[sp-1],&reg);

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

		//cmp reg,0
		op_cmp_value(GetTypeSize(type[sp-1],-1),reg,0);

		//setne al
		op_setne( REG_RAX );

		//and rax,000000FFh
		op_and64_value(REG_RAX,(int)0xFF);

		//neg
		op_neg( REG_RAX );

		//sbb rax, rax
		op_sbb_RR( sizeof(_int64), REG_RAX, REG_RAX );

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

		if( reg != REG_RAX ){
			//mov reg,rax
			op_mov_RR( reg, REG_RAX );

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

		if(reg==REG_R14){
			//mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
			pobj_sf->push(REG_R14);
		}
	}
	else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
		SetOneTermToReg_Whole64Calc(type[sp-1],&reg);

		//not reg
		op_not_reg(sizeof(_int64),reg);

		if(reg==REG_R14){
			//mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
			pobj_sf->push(REG_R14);
		}
	}
	else if(IsWholeNumberType(type[sp-1])){
		SetOneTermToReg_Whole32Calc(type[sp-1],&reg);

		//not reg
		op_not_reg(sizeof(long),reg);

		if(reg==REG_R14){
			//mov qword ptr[rsp+offset],r14     ※スタックフレームを利用
			pobj_sf->push(REG_R14);
		}
	}

	return 1;
}