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

void GetStackData_ToRegister(int *type,int sp){
	/*NumOpeポーランドのスタック蓄積による演算内容（2つのデータ）を
		レジスタedx:eax、ecx:ebxに取得する*/

	if(type[sp-1]==DEF_DOUBLE){
		//fld qword ptr[esp]
		op_fld_ptr_esp(DEF_DOUBLE);

		//fistp qword ptr[esp]
		op_fistp_ptr_esp( sizeof(_int64) );

		//pop ebx
		op_pop(REG_EBX);

		//pop ecx
		op_pop(REG_ECX);
	}
	else if(type[sp-1]==DEF_SINGLE){
		//fld dword ptr[esp]
		op_fld_ptr_esp(DEF_SINGLE);

		//sub esp,4
		op_sub_esp(4);

		//fistp qword ptr[esp]
		op_fistp_ptr_esp( sizeof(_int64) );

		//pop ebx
		op_pop(REG_EBX);

		//pop ecx
		op_pop(REG_ECX);
	}
	else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
		//pop ebx
		op_pop(REG_EBX);

		//pop ecx
		op_pop(REG_ECX);
	}
	else{
		//pop eax
		op_pop(REG_EAX);

		if(IsSignedType(type[sp-1])){
			//符号拡張
			//edx:eax ← eax
				
			//cdq
			op_cdq();
		}
		else{
			//ビット拡張
			//edx:eax ← eax

			//xor edx,edx
			op_zero_reg(REG_EDX);
		}

		//mov ebx,eax
		OpBuffer[obp++]=(char)0x8B;
		OpBuffer[obp++]=(char)0xD8;

		//mov ecx,edx
		OpBuffer[obp++]=(char)0x8B;
		OpBuffer[obp++]=(char)0xCA;
	}

	//第1項を64ビットに対応させる
	if(type[sp-2]==DEF_DOUBLE){
		//fld qword ptr[esp]
		op_fld_ptr_esp(DEF_DOUBLE);

		//fistp qword ptr[esp]
		op_fistp_ptr_esp( sizeof(_int64) );

		//pop eax
		op_pop(REG_EAX);

		//pop edx
		op_pop(REG_EDX);
	}
	else if(type[sp-2]==DEF_SINGLE){
		//fld dword ptr[esp]
		op_fld_ptr_esp(DEF_SINGLE);

		//sub esp,4
		op_sub_esp(4);

		//fistp qword ptr[esp]
		op_fistp_ptr_esp( sizeof(_int64) );

		//pop eax
		op_pop(REG_EAX);

		//pop edx
		op_pop(REG_EDX);
	}
	else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
		//pop eax
		op_pop(REG_EAX);

		//pop edx
		op_pop(REG_EDX);
	}
	else{
		//pop eax
		op_pop(REG_EAX);

		if(IsSignedType(type[sp-2])){
			//符号拡張
			//edx:eax ← eax
				
			//cdq
			op_cdq();
		}
		else{
			//ビット拡張
			//edx:eax ← eax

			//xor edx,edx
			op_zero_reg(REG_EDX);
		}
	}
}

void FormatStackData_To64bit(int *type,int sp){
	//NumOpeポーランドのスタック蓄積による演算内容（2つのデータ）を64ビット整数型にする

	GetStackData_ToRegister(type,sp);

	//push ecx
	op_push(REG_ECX);

	//push ebx
	op_push(REG_EBX);

	//push edx
	op_push(REG_EDX);

	//push eax
	op_push(REG_EAX);
}

BOOL CalcTwoTerm_Arithmetic(int idCalc,int *type,LONG_PTR *index_stack,int *pStackPointer){
	/*	value[sp-2] = value[sp-2] + value[sp-1]
		value[sp-2] = value[sp-2] - value[sp-1]
		value[sp-2] = value[sp-2] * value[sp-1]		*/

	int sp;
	sp=*pStackPointer;

	int AnswerType;
	AnswerType=NeutralizationType(type[sp-2],index_stack[sp-2],type[sp-1],index_stack[sp-1]);

	if(type[sp-2]==DEF_DOUBLE||type[sp-2]==DEF_SINGLE||
		type[sp-1]==DEF_DOUBLE||type[sp-1]==DEF_SINGLE){
		/////////////
		// 実数演算
		/////////////

		if(type[sp-1]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,8
			op_add_esp(8);
		}
		else if(type[sp-1]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//add esp,4
			op_add_esp(4);
		}
		else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
			//64ビット整数値

			//fild qword ptr[esp]
			op_fld_ptr_esp(DEF_INT64);

			//add esp,8
			op_add_esp(8);
		}
		else{
			//その他整数型

			//fild dword ptr[esp]
			op_fld_ptr_esp(DEF_LONG);

			//add esp,4
			op_add_esp(4);
		}

		if(type[sp-2]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);
		}
		else if(type[sp-2]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);
		}
		else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
			//64ビット整数値
			op_fld_ptr_esp(DEF_INT64);
		}
		else{
			//その他整数型

			//fild dword ptr[esp]
			op_fld_ptr_esp(DEF_LONG);
		}

		if(GetTypeSize(type[sp-2],-1)==sizeof(_int64)){
			if(AnswerType==DEF_SINGLE){
				//add esp,4
				op_add_esp(4);
			}
		}
		else{
			if(AnswerType==DEF_DOUBLE){
				//sub esp,4
				op_sub_esp(4);
			}
		}

		if(idCalc==CALC_ADDITION){
			//faddp st(1),st
			OpBuffer[obp++]=(char)0xDE;
			OpBuffer[obp++]=(char)0xC1;
		}
		else if(idCalc==CALC_SUBTRACTION){
			//fsubrp st(1),st
			OpBuffer[obp++]=(char)0xDE;
			OpBuffer[obp++]=(char)0xE1;
		}
		else if(idCalc==CALC_PRODUCT){
			//fmulp st(1),st
			OpBuffer[obp++]=(char)0xDE;
			OpBuffer[obp++]=(char)0xC9;
		}

		if(AnswerType==DEF_DOUBLE){
			//fstp qword ptr[esp]
			OpBuffer[obp++]=(char)0xDD;
			OpBuffer[obp++]=(char)0x1C;
			OpBuffer[obp++]=(char)0x24;
		}
		else{
			//fstp dword ptr[esp]
			OpBuffer[obp++]=(char)0xD9;
			OpBuffer[obp++]=(char)0x1C;
			OpBuffer[obp++]=(char)0x24;
		}
	}
	else if(Is64Type(type[sp-2])||Is64Type(type[sp-1])){
		//////////////////////
		// 64ビット整数演算
		//////////////////////

		if(idCalc==CALC_PRODUCT){
			if(!((type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD)&&
				(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD))){
				//2つの項のどちらかが64ビット整数でないとき
				FormatStackData_To64bit(type,sp);
			}

			//call _allmul
			extern SUBINFO *pSub_allmul;
			op_call(pSub_allmul);

			//push edx
			op_push(REG_EDX);

			//push eax
			op_push(REG_EAX);
		}
		else{
			if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
				//第2項が64ビット整数値のとき

				//pop ebx
				op_pop(REG_EBX);

				//pop ecx
				op_pop(REG_ECX);
			}
			else{
				//第2項がその他整数値のとき

				//pop eax
				op_pop(REG_EAX);

				if(IsSignedType(type[sp-1])){
					//符号拡張
					//edx:eax ← eax
					
					//cdq
					op_cdq();
				}
				else{
					//ビット拡張
					//edx:eax ← eax

					//xor edx,edx
					op_zero_reg(REG_EDX);
				}

				//mov ebx,eax
				OpBuffer[obp++]=(char)0x8B;
				OpBuffer[obp++]=(char)0xD8;

				//mov ecx,edx
				OpBuffer[obp++]=(char)0x8B;
				OpBuffer[obp++]=(char)0xCA;
			}

			if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
				//第1項が64ビット整数値のとき

				if(idCalc==CALC_ADDITION){
					//add dword ptr[esp],ebx
					OpBuffer[obp++]=(char)0x01;
					OpBuffer[obp++]=(char)0x1C;
					OpBuffer[obp++]=(char)0x24;

					//adc dword ptr[esp+sizeof(long)],ecx
					OpBuffer[obp++]=(char)0x11;
					OpBuffer[obp++]=(char)0x4C;
					OpBuffer[obp++]=(char)0x24;
					OpBuffer[obp++]=(char)0x04;
				}
				else if(idCalc==CALC_SUBTRACTION){
					//sub dword ptr[esp],ebx
					OpBuffer[obp++]=(char)0x29;
					OpBuffer[obp++]=(char)0x1C;
					OpBuffer[obp++]=(char)0x24;

					//sbb dword ptr[esp+sizeof(long)],ecx
					OpBuffer[obp++]=(char)0x19;
					OpBuffer[obp++]=(char)0x4C;
					OpBuffer[obp++]=(char)0x24;
					OpBuffer[obp++]=(char)0x04;
				}
			}
			else{
				//第1項がその他整数値のとき

				//pop eax
				op_pop(REG_EAX);

				if(IsSignedType(type[sp-2])){
					//符号拡張
					//edx:eax ← eax

					//cdq
					op_cdq();
				}
				else{
					//ビット拡張
					//edx:eax ← eax

					//xor edx,edx
					op_zero_reg(REG_EDX);
				}

				if(idCalc==CALC_ADDITION){
					//add ebx,eax
					OpBuffer[obp++]=(char)0x03;
					OpBuffer[obp++]=(char)0xD8;

					//adc ecx,edx
					OpBuffer[obp++]=(char)0x13;
					OpBuffer[obp++]=(char)0xCA;
				}
				else if(idCalc==CALC_SUBTRACTION){
					//sub ebx,eax
					OpBuffer[obp++]=(char)0x2B;
					OpBuffer[obp++]=(char)0xC3;

					//sbb ecx,edx
					OpBuffer[obp++]=(char)0x1B;
					OpBuffer[obp++]=(char)0xD1;
				}

				//push ecx
				op_push(REG_ECX);

				//push ebx
				op_push(REG_EBX);
			}
		}
	}
	else{
		//////////////////////////
		//32ビット以下の整数演算
		//////////////////////////

		//pop ebx
		op_pop(REG_EBX);

		//pop eax
		op_pop(REG_EAX);

		//sub esp,4
		op_sub_esp(4);

		if(idCalc==CALC_ADDITION){
			//add eax,ebx
			OpBuffer[obp++]=(char)0x03;
			OpBuffer[obp++]=(char)0xC3;
		}
		else if(idCalc==CALC_SUBTRACTION){
			//sub eax,ebx
			OpBuffer[obp++]=(char)0x2B;
			OpBuffer[obp++]=(char)0xC3;
		}
		else if(idCalc==CALC_PRODUCT){
			//imul eax,ebx（64ビット演算ではないので、符号を考慮しない）
			OpBuffer[obp++]=(char)0x0F;
			OpBuffer[obp++]=(char)0xAF;
			OpBuffer[obp++]=(char)0xC3;
		}

		//mov dword ptr[esp],eax
		OpBuffer[obp++]=(char)0x89;
		OpBuffer[obp++]=(char)0x04;
		OpBuffer[obp++]=(char)0x24;
	}

	sp--;
	type[sp-1]=AnswerType;

	*pStackPointer=sp;

	return 1;
}

BOOL Calc_Mod(int *type,int *pStackPointer){
	//value[sp-2]%=value[sp-1]
	//剰余演算

	int sp;
	sp=*pStackPointer;

	if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD||
		type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
		////////////////
		// 64ビット演算
		////////////////

		//第2項を64ビットに対応させる
		FormatStackData_To64bit(type,sp);

		if(IsSignedType(type[sp-2])==0&&IsSignedType(type[sp-1])==0){
			//符号なし演算

			//call _aullrem
			extern SUBINFO *pSub_aullrem;
			op_call(pSub_aullrem);
		}
		else{
			//符号あり演算

			//call _allrem
			extern SUBINFO *pSub_allrem;
			op_call(pSub_allrem);
		}

		//push edx
		op_push(REG_EDX);

		//push eax
		op_push(REG_EAX);

		sp--;
		if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
		else type[sp-1]=DEF_INT64;
	}
	else{
		////////////////
		// 32ビット演算
		////////////////

		if(type[sp-1]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,4
			op_add_esp(4);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}
		else if(type[sp-1]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}

		//pop ebx
		op_pop(REG_EBX);

		if(type[sp-2]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,4
			op_add_esp(4);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}
		else if(type[sp-2]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}

		//pop eax
		op_pop(REG_EAX);

		//sub esp,4
		op_sub_esp(4);

		if(type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD){
			//xor edx,edx
			op_zero_reg(REG_EDX);

			//div ebx (eax=eax/ebx...edx)
			OpBuffer[obp++]=(char)0xF7;
			OpBuffer[obp++]=(char)0xF3;
		}
		else{
			//cdq
			op_cdq();

			//idiv ebx (eax=eax/ebx...edx)
			OpBuffer[obp++]=(char)0xF7;
			OpBuffer[obp++]=(char)0xFB;
		}

		//mov dword ptr[esp],edx
		OpBuffer[obp++]=(char)0x89;
		OpBuffer[obp++]=(char)0x14;
		OpBuffer[obp++]=(char)0x24;

		sp--;
		type[sp-1]=DEF_LONG;
	}

	*pStackPointer=sp;

	return 1;
}

BOOL Calc_Divide(int *type,int *pStackPointer,int BaseType){
	//value[sp-2]/=value[sp-1];
	//除算

	int sp;
	sp=*pStackPointer;

	///////////////////////
	// 浮動小数点演算のみ
	///////////////////////

	int AnswerType;
	if(type[sp-2]==DEF_DOUBLE||type[sp-1]==DEF_DOUBLE||BaseType==DEF_DOUBLE) AnswerType=DEF_DOUBLE;
	else AnswerType=DEF_SINGLE;

	if(type[sp-1]==DEF_DOUBLE){
		//fld qword ptr[esp]
		op_fld_ptr_esp(DEF_DOUBLE);

		//add esp,8
		op_add_esp(8);
	}
	else if(type[sp-1]==DEF_SINGLE){
		//fld dword ptr[esp]
		op_fld_ptr_esp(DEF_SINGLE);

		//add esp,4
		op_add_esp(4);
	}
	else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
		//64ビット整数値

		//fild qword ptr[esp]
		op_fld_ptr_esp(DEF_INT64);

		//add esp,8
		op_add_esp(8);
	}
	else if(type[sp-1]==DEF_DWORD){
		//pop eax
		op_pop(REG_EAX);

		//push 0
		op_push_value(0);

		//push eax
		op_push(REG_EAX);

		//fild qword ptr[esp]
		OpBuffer[obp++]=(char)0xDF;
		OpBuffer[obp++]=(char)0x2C;
		OpBuffer[obp++]=(char)0x24;

		//add esp,8
		op_add_esp(8);
	}
	else{
		//fild dword ptr[esp]
		op_fld_ptr_esp(DEF_LONG);

		//add esp,4
		op_add_esp(4);
	}

	if(type[sp-2]==DEF_DOUBLE){
		//fld qword ptr[esp]
		op_fld_ptr_esp(DEF_DOUBLE);
	}
	else if(type[sp-2]==DEF_SINGLE){
		//fld dword ptr[esp]
		op_fld_ptr_esp(DEF_SINGLE);
	}
	else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
		//64ビット整数値

		//fild qword ptr[esp]
		op_fld_ptr_esp(DEF_INT64);
	}
	else if(type[sp-2]==DEF_DWORD){
		//pop eax
		op_pop(REG_EAX);

		//push 0
		op_push_value(0);

		//push eax
		op_push(REG_EAX);

		//fild qword ptr[esp]
		OpBuffer[obp++]=(char)0xDF;
		OpBuffer[obp++]=(char)0x2C;
		OpBuffer[obp++]=(char)0x24;
	}
	else{	//Long
		//fild dword ptr[esp]
		op_fld_ptr_esp(DEF_LONG);
	}
                                                            //↓ここだけ例外DWord
	if(GetTypeSize(type[sp-2],-1)==sizeof(_int64)||type[sp-2]==DEF_DWORD){
		if(AnswerType==DEF_SINGLE){
			//add esp,4
			op_add_esp(4);
		}
	}
	else{
		if(AnswerType==DEF_DOUBLE){
			//sub esp,4
			op_sub_esp(4);
		}
	}

	//fdivrp st(1),st
	OpBuffer[obp++]=(char)0xDE;
	OpBuffer[obp++]=(char)0xF1;

	sp--;
	if(AnswerType==DEF_DOUBLE){
		//fstp qword ptr[esp]
		OpBuffer[obp++]=(char)0xDD;
		OpBuffer[obp++]=(char)0x1C;
		OpBuffer[obp++]=(char)0x24;

		type[sp-1]=DEF_DOUBLE;
	}
	else{
		//fstp dword ptr[esp]
		OpBuffer[obp++]=(char)0xD9;
		OpBuffer[obp++]=(char)0x1C;
		OpBuffer[obp++]=(char)0x24;

		type[sp-1]=DEF_SINGLE;
	}

	*pStackPointer=sp;

	return 1;
}

BOOL Calc_IntDivide(int *type,LONG_PTR *index_stack,int *pStackPointer){
	//value[sp-2]/=value[sp-1]
	//除算（整数）

	int sp;
	sp=*pStackPointer;

	if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD||
		type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
		////////////////
		// 64ビット演算
		////////////////

		//2つの項を64ビットに対応させる
		FormatStackData_To64bit(type,sp);

		if(IsSignedType(type[sp-2])==0&&IsSignedType(type[sp-1])==0){
			//符号なし演算

			//call _aulldiv
			extern SUBINFO *pSub_aulldiv;
			op_call(pSub_aulldiv);
		}
		else{
			//符号あり演算

			//call _alldiv
			extern SUBINFO *pSub_alldiv;
			op_call(pSub_alldiv);
		}

		//push edx
		op_push(REG_EDX);

		//push eax
		op_push(REG_EAX);

		sp--;
		if(type[sp-1]==DEF_QWORD&&type[sp]==DEF_QWORD) type[sp-1]=DEF_QWORD;
		else type[sp-1]=DEF_INT64;
	}
	else{
		////////////////
		// 32ビット演算
		////////////////

		if(type[sp-1]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,4
			op_add_esp(4);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}
		else if(type[sp-1]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}

		//pop ebx
		op_pop(REG_EBX);

		if(type[sp-2]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,4
			op_add_esp(4);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}
		else if(type[sp-2]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}

		//pop eax
		op_pop(REG_EAX);

		//sub esp,4
		op_sub_esp(4);

		if((type[sp-2]==DEF_DWORD&&type[sp-1]==DEF_DWORD)||
			(IS_POSITIVE_LITERAL(index_stack[sp-2])&&type[sp-1]==DEF_DWORD)||
			(type[sp-2]==DEF_DWORD&&IS_POSITIVE_LITERAL(index_stack[sp-1]))){
			//xor edx,edx
			op_zero_reg(REG_EDX);

			//div ebx (eax=eax/ebx...edx)
			OpBuffer[obp++]=(char)0xF7;
			OpBuffer[obp++]=(char)0xF3;
		}
		else{
			//cdq
			op_cdq();

			//idiv ebx (eax=eax/ebx...edx)
			OpBuffer[obp++]=(char)0xF7;
			OpBuffer[obp++]=(char)0xFB;
		}

		//mov dword ptr[esp],eax
		OpBuffer[obp++]=(char)0x89;
		OpBuffer[obp++]=(char)0x04;
		OpBuffer[obp++]=(char)0x24;

		sp--;

		//整数以外の型だったときはLong型にする
		if(!IsWholeNumberType(type[sp-1])) type[sp-1]=DEF_LONG;
	}

	*pStackPointer=sp;
	return 1;
}

BOOL Calc_MinusMark(int *type,int sp){
	//value[sp-1]=-value[sp-1]
	//符号反転

	if(type[sp-1]==DEF_DOUBLE){
		//fld qword ptr[esp]
		op_fld_ptr_esp(DEF_DOUBLE);

		//push -1
		op_push_value(-1);

		//fild dword ptr[esp]
		op_fld_ptr_esp(DEF_LONG);

		//add esp,4
		op_add_esp(4);

		//fmulp st(1),st
		OpBuffer[obp++]=(char)0xDE;
		OpBuffer[obp++]=(char)0xC9;

		//fstp qword ptr[esp]
		OpBuffer[obp++]=(char)0xDD;
		OpBuffer[obp++]=(char)0x1C;
		OpBuffer[obp++]=(char)0x24;
	}
	else if(type[sp-1]==DEF_SINGLE){
		//fld dword ptr[esp]
		op_fld_ptr_esp(DEF_SINGLE);

		//push -1
		op_push_value(-1);

		//fild dword ptr[esp]
		op_fld_ptr_esp(DEF_LONG);

		//add esp,4
		op_add_esp(4);

		//fmulp st(1),st
		OpBuffer[obp++]=(char)0xDE;
		OpBuffer[obp++]=(char)0xC9;

		//fstp dword ptr[esp]
		OpBuffer[obp++]=(char)0xD9;
		OpBuffer[obp++]=(char)0x1C;
		OpBuffer[obp++]=(char)0x24;
	}
	else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
		//pop eax
		op_pop(REG_EAX);

		//neg eax
		OpBuffer[obp++]=(char)0xF7;
		OpBuffer[obp++]=(char)0xD8;

		//pop edx
		op_pop(REG_EDX);

		//adc edx,0
		OpBuffer[obp++]=(char)0x83;
		OpBuffer[obp++]=(char)0xD2;
		OpBuffer[obp++]=(char)0x00;

		//neg edx
		OpBuffer[obp++]=(char)0xF7;
		OpBuffer[obp++]=(char)0xDA;

		//push edx
		op_push(REG_EDX);

		//push eax
		op_push(REG_EAX);

		type[sp-1]=DEF_INT64;	//QWordはInt64へ
	}
	else if(IsWholeNumberType(type[sp-1])){
		//pop eax
		op_pop(REG_EAX);

		//imul eax,-1
		OpBuffer[obp++]=(char)0x6B;
		OpBuffer[obp++]=(char)0xC0;
		OpBuffer[obp++]=(char)0xFF;

		//push eax
		op_push(REG_EAX);

		type[sp-1]=GetSignedType(type[sp-1]);
	}

	return 1;
}

BOOL Calc_Power(int *type,int *pStackPointer){
	//べき乗（実数演算のみ）

	int sp;
	sp=*pStackPointer;

	if(type[sp-1]==DEF_DOUBLE){
		//fld qword ptr[esp]
		op_fld_ptr_esp(DEF_DOUBLE);

		//add esp,8
		op_add_esp(8);
	}
	else if(type[sp-1]==DEF_SINGLE){
		//fld dword ptr[esp]
		op_fld_ptr_esp(DEF_SINGLE);

		//add esp,4
		op_add_esp(4);
	}
	else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
		//64ビット整数値

		//fild qword ptr[esp]
		op_fld_ptr_esp(DEF_INT64);

		//add esp,8
		op_add_esp(8);
	}
	else{
		//32ビット整数値

		//fild dword ptr[esp]
		op_fld_ptr_esp(DEF_LONG);

		//add esp,4
		op_add_esp(4);
	}

	if(type[sp-2]==DEF_DOUBLE){
		//fld qword ptr[esp]
		op_fld_ptr_esp(DEF_DOUBLE);
	}
	else if(type[sp-2]==DEF_SINGLE){
		//fld dword ptr[esp]
		op_fld_ptr_esp(DEF_SINGLE);

		//sub esp,4
		op_sub_esp(4);
	}
	else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
		//64ビット整数値

		//fild qword ptr[esp]
		op_fld_ptr_esp(DEF_INT64);
	}
	else{
		//32ビット整数値

		//fild dword ptr[esp]
		op_fld_ptr_esp(DEF_LONG);

		//sub esp,4
		op_sub_esp(4);
	}

	//sub esp,8
	op_sub_esp(8);

	//fstp qword ptr[esp]
	OpBuffer[obp++]=(char)0xDD;
	OpBuffer[obp++]=(char)0x1C;
	OpBuffer[obp++]=(char)0x24;

	//fstp qword ptr[esp+8]
	OpBuffer[obp++]=(char)0xDD;
	OpBuffer[obp++]=(char)0x5C;
	OpBuffer[obp++]=(char)0x24;
	OpBuffer[obp++]=(char)0x08;

	//call pow
	extern SUBINFO *pSub_pow;
	op_call(pSub_pow);

	//sub esp,8
	op_sub_esp(8);

	//fstp qword ptr[esp]
	OpBuffer[obp++]=(char)0xDD;
	OpBuffer[obp++]=(char)0x1C;
	OpBuffer[obp++]=(char)0x24;

	sp--;
	type[sp-1]=DEF_DOUBLE;

	*pStackPointer=sp;
	return 1;
}

BOOL Calc_Cast(int *type,LONG_PTR *index_stack,int *pStackPointer){
	//キャスト

	int sp;
	sp=*pStackPointer;

	int CastType;
	CastType=type[sp-1];
	if((CastType&FLAG_CAST)==0){
		SetError(47,NULL,cp);
		return 0;
	}
	CastType=CastType&(~FLAG_CAST);

	if(IsPtrType(CastType)){
		ChangeTypeToLong(type[sp-2]);
	}
	else if(IsRealNumberType(CastType)){
		if(CastType==DEF_DOUBLE) ChangeTypeToDouble(type[sp-2]);
		else if(CastType==DEF_SINGLE) ChangeTypeToSingle(type[sp-2]);
	}
	else ChangeTypeToWhole(type[sp-2],CastType);

	type[sp-2]=CastType;
	index_stack[sp-2]=index_stack[sp-1];

	sp--;

	*pStackPointer=sp;
	return 1;
}

BOOL Calc_SHL(int *type,int *pStackPointer){
	//左ビットシフト
	//value[sp-2]=value[sp-2]<<value[sp-1]

	int sp;
	sp=*pStackPointer;

	if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
		////////////////
		// 64ビット演算
		////////////////

		//2項目は32ビット整数として利用
		if(type[sp-1]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,4
			op_add_esp(4);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );

			//pop ecx
			op_pop(REG_ECX);
		}
		else if(type[sp-1]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );

			//pop ecx
			op_pop(REG_ECX);
		}
		else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
			//pop ecx
			op_pop(REG_ECX);

			//add esp,4
			op_add_esp(4);
		}
		else{
			//pop ecx
			op_pop(REG_ECX);
		}

		//第1項を64ビットに対応させる
		if(type[sp-2]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//fistp qword ptr[esp]
			op_fistp_ptr_esp( sizeof(_int64) );

			//pop eax
			op_pop(REG_EAX);

			//pop edx
			op_pop(REG_EDX);
		}
		else if(type[sp-2]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//sub esp,4
			op_sub_esp(4);

			//fistp qword ptr[esp]
			op_fistp_ptr_esp( sizeof(_int64) );

			//pop eax
			op_pop(REG_EAX);

			//pop edx
			op_pop(REG_EDX);
		}
		else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
			//pop eax
			op_pop(REG_EAX);

			//pop edx
			op_pop(REG_EDX);
		}
		else{
			//pop eax
			op_pop(REG_EAX);

			if(IsSignedType(type[sp-2])){
				//符号拡張
				//edx:eax ← eax
					
				//cdq
				op_cdq();
			}
			else{
				//ビット拡張
				//edx:eax ← eax

				//xor edx,edx
				op_zero_reg(REG_EDX);
			}
		}

		//call _allshl
		extern SUBINFO *pSub_allshl;
		op_call(pSub_allshl);

		//push edx
		op_push(REG_EDX);

		//push eax
		op_push(REG_EAX);

		sp--;
	}
	else{
		////////////////
		// 32ビット演算
		////////////////

		//2項目は32ビット整数として利用
		if(type[sp-1]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,4
			op_add_esp(4);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );

			//pop ecx
			op_pop(REG_ECX);
		}
		else if(type[sp-1]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );

			//pop ecx
			op_pop(REG_ECX);
		}
		else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
			//pop ecx
			op_pop(REG_ECX);

			//add esp,4
			op_add_esp(4);
		}
		else{
			//pop ecx
			op_pop(REG_ECX);
		}

		if(type[sp-2]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,4
			op_add_esp(4);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}
		else if(type[sp-2]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}

		//pop eax
		op_pop(REG_EAX);

		//sub esp,4
		op_sub_esp(4);

		//shl eax,cl
		OpBuffer[obp++]=(char)0xD3;
		OpBuffer[obp++]=(char)0xE0;

		//mov dword ptr[esp],eax
		OpBuffer[obp++]=(char)0x89;
		OpBuffer[obp++]=(char)0x04;
		OpBuffer[obp++]=(char)0x24;

		sp--;

		//32ビット型にする
		if(IsSignedType(type[sp-1])) type[sp-1]=DEF_LONG;
		else type[sp-1]=DEF_DWORD;
	}

	*pStackPointer=sp;
	return 1;
}

BOOL Calc_SHR(int *type,int *pStackPointer){
	//右ビットシフト
	//value[sp-2]=value[sp-2]>>value[sp-1]

	int sp;
	sp=*pStackPointer;

	if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
		////////////////
		// 64ビット演算
		////////////////

		//2項目は32ビット整数として利用
		if(type[sp-1]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,4
			op_add_esp(4);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );

			//pop ecx
			op_pop(REG_ECX);
		}
		else if(type[sp-1]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );

			//pop ecx
			op_pop(REG_ECX);
		}
		else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
			//pop ecx
			op_pop(REG_ECX);

			//add esp,4
			op_add_esp(4);
		}
		else{
			//pop ecx
			op_pop(REG_ECX);
		}

		//第1項を64ビットに対応させる
		if(type[sp-2]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//fistp qword ptr[esp]
			op_fistp_ptr_esp( sizeof(_int64) );

			//pop eax
			op_pop(REG_EAX);

			//pop edx
			op_pop(REG_EDX);
		}
		else if(type[sp-2]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//sub esp,4
			op_sub_esp(4);

			//fistp qword ptr[esp]
			op_fistp_ptr_esp( sizeof(_int64) );

			//pop eax
			op_pop(REG_EAX);

			//pop edx
			op_pop(REG_EDX);
		}
		else if(type[sp-2]==DEF_INT64||type[sp-2]==DEF_QWORD){
			//pop eax
			op_pop(REG_EAX);

			//pop edx
			op_pop(REG_EDX);
		}
		else{
			//pop eax
			op_pop(REG_EAX);

			if(IsSignedType(type[sp-2])){
				//符号拡張
				//edx:eax ← eax

				//cdq
				op_cdq();
			}
			else{
				//ビット拡張
				//edx:eax ← eax

				//xor edx,edx
				op_zero_reg(REG_EDX);
			}
		}

		if(type[sp-2]==DEF_QWORD){
			//符号なし演算

			//call _aullshr
			extern SUBINFO *pSub_aullshr;
			op_call(pSub_aullshr);
		}
		else{
			//符号あり演算

			//call _allshr
			extern SUBINFO *pSub_allshr;
			op_call(pSub_allshr);
		}

		//push edx
		op_push(REG_EDX);

		//push eax
		op_push(REG_EAX);

		sp--;
	}
	else{
		////////////////
		// 32ビット演算
		////////////////

		//2項目は32ビット整数として利用
		if(type[sp-1]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,4
			op_add_esp(4);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );

			//pop ecx
			op_pop(REG_ECX);
		}
		else if(type[sp-1]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );

			//pop ecx
			op_pop(REG_ECX);
		}
		else if(type[sp-1]==DEF_INT64||type[sp-1]==DEF_QWORD){
			//pop ecx
			op_pop(REG_ECX);

			//add esp,4
			op_add_esp(4);
		}
		else{
			//pop ecx
			op_pop(REG_ECX);
		}

		if(type[sp-2]==DEF_DOUBLE){
			//fld qword ptr[esp]
			op_fld_ptr_esp(DEF_DOUBLE);

			//add esp,4
			op_add_esp(4);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}
		else if(type[sp-2]==DEF_SINGLE){
			//fld dword ptr[esp]
			op_fld_ptr_esp(DEF_SINGLE);

			//fistp dword ptr[esp]
			op_fistp_ptr_esp( sizeof(long) );
		}

		//pop eax
		op_pop(REG_EAX);

		//sub esp,4
		op_sub_esp(4);

		if(type[sp-2]==DEF_DWORD){
			//shr eax,cl
			OpBuffer[obp++]=(char)0xD3;
			OpBuffer[obp++]=(char)0xE8;
		}
		else{
			//sar eax,cl
			OpBuffer[obp++]=(char)0xD3;
			OpBuffer[obp++]=(char)0xF8;
		}

		//mov dword ptr[esp],eax
		OpBuffer[obp++]=(char)0x89;
		OpBuffer[obp++]=(char)0x04;
		OpBuffer[obp++]=(char)0x24;

		sp--;

		//整数以外の型だったときはLong型にする
		if(!IsWholeNumberType(type[sp-1])) type[sp-1]=DEF_LONG;
	}

	*pStackPointer=sp;
	return 1;
}