Context Navigation

source: dev/trunk/abdev/BasicCompiler32/NumOpe_Relation.cpp@ 238

Last change on this file since 238 was 238, checked in by dai_9181, 17 years ago

File size: 28.8 KB

Rev	Line
[206]	1	#include "stdafx.h"
	2
[225]	3	#include <Compiler.h>
	4
[3]	5	#include "../BasicCompiler_Common/common.h"
	6	#include "Opcode.h"
	7
[97]	8	void AutoExtendToBigType( int *type_stack,int sp, int reg1, int reg2 ){
	9	/*
	10	int bigSize = GetTypeSize( type_stack[sp-1], -1 );
	11	if( bigSize != GetTypeSize( type_stack[sp-2], -1 ) ){
	12	int extReg = reg2;
	13	int oldType = type_stack[sp-2];
	14	if( bigSize < GetTypeSize( type_stack[sp-2], -1 ) ){
	15	bigSize = GetTypeSize( type_stack[sp-2], -1 );
	16	extReg = reg1;
	17	oldType = type_stack[sp-1];
	18	}
	19	if( bigSize == 2 ){
	20	ExtendTypeTo16( oldType, extReg );
	21	}
	22	else if( bigSize == 4 ){
	23	ExtendTypeTo32( oldType, extReg );
	24	}
	25	else{
	26	SetError();
	27	}
	28	}*/
	29	}
	30
	31
[3]	32	BOOL Calc_Relation_PE(int type_stack,LONG_PTR index_stack,int *pStackPointer){
	33	//value[sp-2]<=value[sp-1]
	34
	35	int sp;
	36	sp=*pStackPointer;
	37
	38	int AnswerType;
	39	AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
	40
	41	if(IsRealNumberType(AnswerType)){
	42	//////////////
	43	// 実数演算
	44	//////////////
	45
	46	if(type_stack[sp-1]==DEF_DOUBLE){
	47	//fld qword ptr[esp]
[225]	48	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	49
	50	//add esp,8
[225]	51	compiler.codeGenerator.op_add_esp(8);
[3]	52	}
	53	else if(type_stack[sp-1]==DEF_SINGLE){
	54	//fld dword ptr[esp]
[225]	55	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	56
	57	//add esp,4
[225]	58	compiler.codeGenerator.op_add_esp(4);
[3]	59	}
	60	else if(type_stack[sp-1]==DEF_INT64\|\|type_stack[sp-1]==DEF_QWORD){
	61	//64ビット整数値
	62
	63	//fild qword ptr[esp]
[225]	64	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	65
	66	//add esp,8
[225]	67	compiler.codeGenerator.op_add_esp(8);
[3]	68	}
	69	else{
	70	//その他整数型
	71
	72	//fild dword ptr[esp]
[225]	73	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	74
	75	//add esp,4
[225]	76	compiler.codeGenerator.op_add_esp(4);
[3]	77	}
	78
	79	if(type_stack[sp-2]==DEF_DOUBLE){
	80	//fld qword ptr[esp]
[225]	81	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	82
	83	//add esp,4
[225]	84	compiler.codeGenerator.op_add_esp(4);
[3]	85	}
	86	else if(type_stack[sp-2]==DEF_SINGLE){
	87	//fld dword ptr[esp]
[225]	88	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	89	}
	90	else if(type_stack[sp-2]==DEF_INT64\|\|type_stack[sp-2]==DEF_QWORD){
	91	//64ビット整数値
	92
	93	//fild qword ptr[esp]
[225]	94	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	95
	96	//add esp,4
[225]	97	compiler.codeGenerator.op_add_esp(4);
[3]	98	}
	99	else{
	100	//その他整数型
	101
	102	//fild dword ptr[esp]
[225]	103	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	104	}
	105
	106	//fcompp
[225]	107	compiler.codeGenerator.op_fcompp();
[3]	108
	109	//fnstsw ax
[225]	110	compiler.codeGenerator.op_fnstsw_ax();
[3]	111
[36]	112	//mov ecx,1
[225]	113	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	114
	115	//test ah,41h
[225]	116	compiler.codeGenerator.op_test_ah( (char)0x41 );
[3]	117
	118	//jne 5
[225]	119	compiler.codeGenerator.PutOld(
	120	(char)0x75,
	121	(char)0x02
	122	);
[3]	123
	124	//xor ecx,ecx（ecxを0にする）
[225]	125	compiler.codeGenerator.op_zero_reg(REG_ECX);
[3]	126
	127	//mov dword ptr[esp],ecx
[225]	128	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	129	}
	130	else if(Is64Type(AnswerType)){
	131	////////////////////
	132	// 64ビット整数演算
	133	////////////////////
	134
	135	// 第1項 <= 第2項
	136
	137	//第1項 edx:eax
	138	//第2項 ecx:ebx
	139	GetStackData_ToRegister(type_stack,sp);
	140
	141	//cmp edx,ecx
[225]	142	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	143
[238]	144	CodeGenerator::PertialSchedule *pFalsePertialSchedule1;
[3]	145	if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){
	146	//符号なし演算
	147
	148	//ja FalseSchedule1（偽へジャンプ）
[238]	149	pFalsePertialSchedule1 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
[3]	150	}
	151	else{
	152	//符号あり演算
	153
	154	//jg FalseSchedule1（偽へジャンプ）
[238]	155	pFalsePertialSchedule1 = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
[3]	156	}
	157
[238]	158	CodeGenerator::PertialSchedule *pTruePertialSchedule;
[3]	159	if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){
	160	//符号なし演算
	161
	162	//jb TrueSchedule（真へジャンプ）
[238]	163	pTruePertialSchedule = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
[3]	164	}
	165	else{
	166	//符号あり演算
	167
	168	//jl TrueSchedule（真へジャンプ）
[238]	169	pTruePertialSchedule = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
[3]	170	}
	171
	172	//cmp eax,ebx
[227]	173	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	174
	175	//ja FalseSchedule2（偽へジャンプ）
[238]	176	CodeGenerator::PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
[3]	177
	178	//TrueScheduleのジャンプ先の設定
[238]	179	compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule );
[3]	180
[36]	181	//mov eax,1
[227]	182	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	183
	184	//jmp 2（演算終了位置へジャンプ）
[238]	185	compiler.codeGenerator.op_jmp( 2 );
[3]	186
	187	//FalseScheduleのジャンプ先の設定
[238]	188	compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
	189	compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
[3]	190
	191	//xor eax,eax（eaxを0にする）
[225]	192	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	193
	194	//push eax
[225]	195	compiler.codeGenerator.op_push(REG_EAX);
[3]	196	}
	197	else{
	198	////////////////////
	199	// 32ビット整数演算
	200	////////////////////
	201
	202	//pop ebx
[225]	203	compiler.codeGenerator.op_pop(REG_EBX);
[3]	204
	205	//pop eax
[225]	206	compiler.codeGenerator.op_pop(REG_EAX);
[3]	207
[97]	208	// どちらかのサイズが足りない場合は自動拡張する
	209	AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
	210
[3]	211	//sub esp,4
[225]	212	compiler.codeGenerator.op_sub_esp(4);
[3]	213
[36]	214	//mov ecx,1
[227]	215	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	216
	217	//cmp eax,ebx
[227]	218	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	219
	220	if(IsSignedType(type_stack[sp-2])==0&&IsSignedType(type_stack[sp-1])==0){
	221	//符号なし演算
	222
[227]	223	//jbe 2（次のxorを飛び越す）
[238]	224	compiler.codeGenerator.op_jbe( 2 );
[3]	225	}
	226	else{
	227	//符号あり演算
	228
[227]	229	//jle 2（次のxorを飛び越す）
[238]	230	compiler.codeGenerator.op_jle( 2 );
[3]	231	}
	232
[227]	233	//xor ecx,ecx
	234	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	235
	236	//mov dword ptr[esp],ecx
[225]	237	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	238	}
	239
	240	sp--;
[36]	241	type_stack[sp-1]=DEF_BOOLEAN;
[3]	242
	243	*pStackPointer=sp;
	244	return 1;
	245	}
	246
	247	BOOL Calc_Relation_QE(int type_stack,LONG_PTR index_stack,int *pStackPointer){
	248	//value[sp-2]>=value[sp-1]
	249
	250	int sp;
	251	sp=*pStackPointer;
	252
	253	int AnswerType;
	254	AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
	255
	256	if(IsRealNumberType(AnswerType)){
	257	//浮動小数点演算
	258	if(type_stack[sp-1]==DEF_DOUBLE){
	259	//fld qword ptr[esp]
[225]	260	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	261
	262	//add esp,8
[225]	263	compiler.codeGenerator.op_add_esp(8);
[3]	264	}
	265	else if(type_stack[sp-1]==DEF_SINGLE){
	266	//fld dword ptr[esp]
[225]	267	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	268
	269	//add esp,4
[225]	270	compiler.codeGenerator.op_add_esp(4);
[3]	271	}
	272	else if(type_stack[sp-1]==DEF_INT64\|\|type_stack[sp-1]==DEF_QWORD){
	273	//64ビット整数値
	274
	275	//fild qword ptr[esp]
[225]	276	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	277
	278	//add esp,8
[225]	279	compiler.codeGenerator.op_add_esp(8);
[3]	280	}
	281	else{
	282	//その他整数型
	283
	284	//fild dword ptr[esp]
[225]	285	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	286
	287	//add esp,4
[225]	288	compiler.codeGenerator.op_add_esp(4);
[3]	289	}
	290
	291	if(type_stack[sp-2]==DEF_DOUBLE){
	292	//fld qword ptr[esp]
[225]	293	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	294
	295	//add esp,4
[225]	296	compiler.codeGenerator.op_add_esp(4);
[3]	297	}
	298	else if(type_stack[sp-2]==DEF_SINGLE){
	299	//fld dword ptr[esp]
[225]	300	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	301	}
	302	else if(type_stack[sp-2]==DEF_INT64\|\|type_stack[sp-2]==DEF_QWORD){
	303	//64ビット整数値
	304
	305	//fild qword ptr[esp]
[225]	306	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	307
	308	//add esp,4
[225]	309	compiler.codeGenerator.op_add_esp(4);
[3]	310	}
	311	else{
	312	//その他整数型
	313
	314	//fild dword ptr[esp]
[225]	315	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	316	}
	317
	318	//fcompp
[238]	319	compiler.codeGenerator.op_fcompp();
[3]	320
	321	//fnstsw ax
[225]	322	compiler.codeGenerator.op_fnstsw_ax();
[3]	323
[36]	324	//mov ecx,1
[227]	325	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	326
	327	//test ah,1
[225]	328	compiler.codeGenerator.op_test_ah( (char)0x01 );
[3]	329
[227]	330	//je 2（次のxorを飛び越す）
[3]	331	OpBuffer[obp++]=(char)0x74;
[227]	332	OpBuffer[obp++]=(char)0x02;
[3]	333
[227]	334	//xor ecx,ecx
	335	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	336
	337	//mov dword ptr[esp],ecx
[225]	338	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	339	}
	340	else if(Is64Type(AnswerType)){
	341	////////////////////
	342	// 64ビット整数演算
	343	////////////////////
	344	int TrueSchedule,
	345	FalseSchedule1,
	346	FalseSchedule2;
	347
	348	// 第1項 >= 第2項
	349
	350	//第1項 edx:eax
	351	//第2項 ecx:ebx
	352	GetStackData_ToRegister(type_stack,sp);
	353
	354	//cmp edx,ecx
[227]	355	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	356
	357	if(IsSignedType(AnswerType)){
	358	//符号あり演算
	359
	360	//jl FalseSchedule1（偽へジャンプ）
	361	OpBuffer[obp++]=(char)0x7C;
	362	}
	363	else{
	364	//符号なし演算
	365
	366	//jb FalseSchedule1（偽へジャンプ）
	367	OpBuffer[obp++]=(char)0x72;
	368	}
	369	FalseSchedule1=obp;
	370	obp++;
	371
	372	if(IsSignedType(AnswerType)){
	373	//符号あり演算
	374
	375	//jg TrueSchedule（真へジャンプ）
	376	OpBuffer[obp++]=(char)0x7F;
	377	}
	378	else{
	379	//符号なし演算
	380
	381	//ja TrueSchedule（真へジャンプ）
	382	OpBuffer[obp++]=(char)0x77;
	383	}
	384	TrueSchedule=obp;
	385	obp++;
	386
	387	//cmp eax,ebx
[227]	388	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	389
	390	//jb FalseSchedule2（偽へジャンプ）
	391	OpBuffer[obp++]=(char)0x72;
	392	FalseSchedule2=obp;
	393	obp++;
	394
	395	//TrueScheduleのジャンプ先の設定
	396	OpBuffer[TrueSchedule]=obp-(TrueSchedule+1);
	397
[36]	398	//mov eax,1
[227]	399	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	400
	401	//jmp 2（演算終了位置へジャンプ）
	402	OpBuffer[obp++]=(char)0xEB;
	403	OpBuffer[obp++]=(char)0x02;
	404
	405	//FalseScheduleのジャンプ先の設定
	406	OpBuffer[FalseSchedule1]=obp-(FalseSchedule1+1);
	407	OpBuffer[FalseSchedule2]=obp-(FalseSchedule2+1);
	408
	409	//xor eax,eax（eaxを0にする）
[225]	410	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	411
	412	//push eax
[225]	413	compiler.codeGenerator.op_push(REG_EAX);
[3]	414	}
	415	else{
	416	////////////////////
	417	// 32ビット整数演算
	418	////////////////////
	419
	420	//pop ebx
[225]	421	compiler.codeGenerator.op_pop(REG_EBX);
[3]	422
	423	//pop eax
[225]	424	compiler.codeGenerator.op_pop(REG_EAX);
[3]	425
[97]	426	// どちらかのサイズが足りない場合は自動拡張する
	427	AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
	428
[3]	429	//sub esp,4
[225]	430	compiler.codeGenerator.op_sub_esp(4);
[3]	431
[36]	432	//mov ecx,1
[227]	433	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	434
	435	//cmp eax,ebx
[227]	436	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	437
	438	if(IsSignedType(AnswerType)){
	439	//符号あり演算
	440
[227]	441	//jge 2（次のxorを飛び越す）符号有り
[3]	442	OpBuffer[obp++]=(char)0x7D;
[227]	443	OpBuffer[obp++]=(char)0x02;
[3]	444	}
	445	else{
	446	//符号なし演算
	447
[227]	448	//jae 2（次のxorを飛び越す）
[3]	449	OpBuffer[obp++]=(char)0x73;
[227]	450	OpBuffer[obp++]=(char)0x02;
[3]	451	}
	452
[227]	453	//xor ecx,ecx
	454	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	455
	456	//mov dword ptr[esp],ecx
[225]	457	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	458	}
	459
	460	sp--;
[36]	461	type_stack[sp-1]=DEF_BOOLEAN;
[3]	462
	463	*pStackPointer=sp;
	464	return 1;
	465	}
	466
	467	BOOL Calc_Relation_P(int type_stack,LONG_PTR index_stack,int *pStackPointer){
	468	//value[sp-2]<value[sp-1]
	469
	470	int sp;
	471	sp=*pStackPointer;
	472
	473	int AnswerType;
	474	AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
	475
	476	if(IsRealNumberType(AnswerType)){
	477	//////////////
	478	// 実数演算
	479	//////////////
	480
	481	if(type_stack[sp-1]==DEF_DOUBLE){
	482	//fld qword ptr[esp]
[225]	483	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	484
	485	//add esp,8
[225]	486	compiler.codeGenerator.op_add_esp(8);
[3]	487	}
	488	else if(type_stack[sp-1]==DEF_SINGLE){
	489	//fld dword ptr[esp]
[225]	490	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	491
	492	//add esp,4
[225]	493	compiler.codeGenerator.op_add_esp(4);
[3]	494	}
	495	else if(type_stack[sp-1]==DEF_INT64\|\|type_stack[sp-1]==DEF_QWORD){
	496	//64ビット整数値
	497
	498	//fild qword ptr[esp]
[225]	499	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	500
	501	//add esp,8
[225]	502	compiler.codeGenerator.op_add_esp(8);
[3]	503	}
	504	else{
	505	//その他整数型
	506
	507	//fild dword ptr[esp]
[225]	508	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	509
	510	//add esp,4
[225]	511	compiler.codeGenerator.op_add_esp(4);
[3]	512	}
	513
	514	if(type_stack[sp-2]==DEF_DOUBLE){
	515	//fld qword ptr[esp]
[225]	516	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	517
	518	//add esp,4
[225]	519	compiler.codeGenerator.op_add_esp(4);
[3]	520	}
	521	else if(type_stack[sp-2]==DEF_SINGLE){
	522	//fld dword ptr[esp]
[225]	523	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	524	}
	525	else if(type_stack[sp-2]==DEF_INT64\|\|type_stack[sp-2]==DEF_QWORD){
	526	//64ビット整数値
	527
	528	//fild qword ptr[esp]
[225]	529	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	530
	531	//add esp,4
[225]	532	compiler.codeGenerator.op_add_esp(4);
[3]	533	}
	534	else{
	535	//その他整数型
	536
	537	//fild dword ptr[esp]
[225]	538	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	539	}
	540
	541	//fcompp
[225]	542	compiler.codeGenerator.op_fcompp();
[3]	543
	544	//fnstsw ax
[225]	545	compiler.codeGenerator.op_fnstsw_ax();
[3]	546
[36]	547	//mov ecx,1
[227]	548	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	549
	550	//test ah,01h
[237]	551	compiler.codeGenerator.op_test_ah( (char)0x01 );
[3]	552
[227]	553	//jne 2
[3]	554	OpBuffer[obp++]=(char)0x75;
[237]	555	OpBuffer[obp++]=(char)0x02;
[3]	556
[227]	557	//xor ecx,ecx
	558	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	559
	560	//mov dword ptr[esp],ecx
[225]	561	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	562	}
	563	else if(Is64Type(AnswerType)){
	564	////////////////////
	565	// 64ビット整数演算
	566	////////////////////
	567	int TrueSchedule1,
	568	TrueSchedule2,
	569	FalseSchedule;
	570
	571	// 第1項 < 第2項
	572
	573	//第1項 edx:eax
	574	//第2項 ecx:ebx
	575	GetStackData_ToRegister(type_stack,sp);
	576
	577	//cmp edx,ecx
[227]	578	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	579
	580	if(IsSignedType(AnswerType)){
	581	//符号あり演算
	582
	583	//jl TrueSchedule1（真へジャンプ）
	584	OpBuffer[obp++]=(char)0x7C;
	585	}
	586	else{
	587	//符号なし演算
	588
	589	//jb TrueSchedule1（真へジャンプ）
	590	OpBuffer[obp++]=(char)0x72;
	591	}
	592	TrueSchedule1=obp;
	593	obp++;
	594
	595	if(IsSignedType(AnswerType)){
	596	//符号あり演算
	597
	598	//jg FalseSchedule（偽へジャンプ）
	599	OpBuffer[obp++]=(char)0x7F;
	600	}
	601	else{
	602	//符号なし演算
	603
	604	//ja FalseSchedule（偽へジャンプ）
	605	OpBuffer[obp++]=(char)0x77;
	606	}
	607	FalseSchedule=obp;
	608	obp++;
	609
	610	//cmp eax,ebx
[227]	611	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	612
	613	//jb TrueSchedule2（真へジャンプ）
	614	OpBuffer[obp++]=(char)0x72;
	615	TrueSchedule2=obp;
	616	obp++;
	617
	618	//FalseScheduleのジャンプ先の設定
	619	OpBuffer[FalseSchedule]=obp-(FalseSchedule+1);
	620
	621	//xor eax,eax（eaxを0にする）
[225]	622	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	623
	624	//jmp 5（演算終了位置へジャンプ）
	625	OpBuffer[obp++]=(char)0xEB;
	626	OpBuffer[obp++]=(char)0x05;
	627
	628	//TrueScheduleのジャンプ先の設定
	629	OpBuffer[TrueSchedule1]=obp-(TrueSchedule1+1);
	630	OpBuffer[TrueSchedule2]=obp-(TrueSchedule2+1);
	631
[36]	632	//mov eax,1
[227]	633	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	634
	635	//push eax
[225]	636	compiler.codeGenerator.op_push(REG_EAX);
[3]	637	}
	638	else{
	639	///////////////////
	640	//32ビット整数演算
	641	///////////////////
	642
	643	//pop ebx
[225]	644	compiler.codeGenerator.op_pop(REG_EBX);
[3]	645
	646	//pop eax
[225]	647	compiler.codeGenerator.op_pop(REG_EAX);
[3]	648
[97]	649	// どちらかのサイズが足りない場合は自動拡張する
	650	AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
	651
[3]	652	//sub esp,4
[225]	653	compiler.codeGenerator.op_sub_esp(4);
[3]	654
[36]	655	//mov ecx,1
[227]	656	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	657
	658	//cmp eax,ebx
[227]	659	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	660
	661	if(IsSignedType(AnswerType)){
	662	//符号あり演算
	663
[227]	664	//jl 2（次のxorを飛び越す）
[3]	665	OpBuffer[obp++]=(char)0x7C;
[227]	666	OpBuffer[obp++]=(char)0x02;
[3]	667	}
	668	else{
	669	//符号なし演算
	670
[227]	671	//jb 2（次のxorを飛び越す）
[3]	672	OpBuffer[obp++]=(char)0x72;
[227]	673	OpBuffer[obp++]=(char)0x02;
[3]	674	}
	675
[227]	676	//xor ecx,ecx
	677	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	678
	679	//mov dword ptr[esp],ecx
[225]	680	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	681	}
	682
	683	sp--;
[36]	684	type_stack[sp-1]=DEF_BOOLEAN;
[3]	685
	686	*pStackPointer=sp;
	687	return 1;
	688	}
	689
	690	BOOL Calc_Relation_Q(int type_stack,LONG_PTR index_stack,int *pStackPointer){
	691	//value[sp-2]>value[sp-1]
	692
	693	int sp;
	694	sp=*pStackPointer;
	695
	696	int AnswerType;
	697	AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
	698
	699	if(IsRealNumberType(AnswerType)){
	700	//////////////
	701	// 実数演算
	702	//////////////
	703
	704	if(type_stack[sp-1]==DEF_DOUBLE){
	705	//fld qword ptr[esp]
[225]	706	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	707
	708	//add esp,8
[225]	709	compiler.codeGenerator.op_add_esp(8);
[3]	710	}
	711	else if(type_stack[sp-1]==DEF_SINGLE){
	712	//fld dword ptr[esp]
[225]	713	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	714
	715	//add esp,4
[225]	716	compiler.codeGenerator.op_add_esp(4);
[3]	717	}
	718	else if(type_stack[sp-1]==DEF_INT64\|\|type_stack[sp-1]==DEF_QWORD){
	719	//64ビット整数値
	720
	721	//fild qword ptr[esp]
[225]	722	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	723
	724	//add esp,8
[225]	725	compiler.codeGenerator.op_add_esp(8);
[3]	726	}
	727	else{ //Long、DWord
	728	//fild dword ptr[esp]
[225]	729	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	730
	731	//add esp,4
[225]	732	compiler.codeGenerator.op_add_esp(4);
[3]	733	}
	734
	735	if(type_stack[sp-2]==DEF_DOUBLE){
	736	//fld qword ptr[esp]
[225]	737	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	738
	739	//add esp,4
[225]	740	compiler.codeGenerator.op_add_esp(4);
[3]	741	}
	742	else if(type_stack[sp-2]==DEF_SINGLE){
	743	//fld dword ptr[esp]
[225]	744	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	745	}
	746	else if(type_stack[sp-2]==DEF_INT64\|\|type_stack[sp-2]==DEF_QWORD){
	747	//64ビット整数値
	748
	749	//fild qword ptr[esp]
[225]	750	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	751
	752	//add esp,4
[225]	753	compiler.codeGenerator.op_add_esp(4);
[3]	754	}
	755	else{ //Long、DWord
	756	//fild dword ptr[esp]
[225]	757	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	758	}
	759
	760	//fcompp
[225]	761	compiler.codeGenerator.op_fcompp();
[3]	762
	763	//fnstsw ax
[225]	764	compiler.codeGenerator.op_fnstsw_ax();
[3]	765
[36]	766	//mov ecx,1
[227]	767	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	768
	769	//test ah,41
[225]	770	compiler.codeGenerator.op_test_ah( (char)0x41 );
[3]	771
[227]	772	//je 2（次のxorを飛び越す）
[3]	773	OpBuffer[obp++]=(char)0x74;
[227]	774	OpBuffer[obp++]=(char)0x02;
[3]	775
[227]	776	//xor ecx,ecx
	777	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	778
	779	//mov dword ptr[esp],ecx
[225]	780	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	781	}
	782	else if(Is64Type(AnswerType)){
	783	////////////////////
	784	// 64ビット整数演算
	785	////////////////////
	786	int FalseSchedule,
	787	TrueSchedule1,
	788	TrueSchedule2;
	789
	790	// 第1項 > 第2項
	791
	792	//第1項 edx:eax
	793	//第2項 ecx:ebx
	794	GetStackData_ToRegister(type_stack,sp);
	795
	796	//cmp edx,ecx
[227]	797	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	798
	799	if(IsSignedType(AnswerType)){
	800	//符号有り
	801
	802	//jg TrueSchedule1（真へジャンプ）
	803	OpBuffer[obp++]=(char)0x7F;
	804	}
	805	else{
	806	//符号無し
	807
	808	//ja TrueSchedule1（真へジャンプ）
	809	OpBuffer[obp++]=(char)0x77;
	810	}
	811	TrueSchedule1=obp;
	812	obp++;
	813
	814	if(IsSignedType(AnswerType)){
	815	//符号有り
	816
	817	//jl FalseSchedule（偽へジャンプ）
	818	OpBuffer[obp++]=(char)0x7C;
	819	}
	820	else{
	821	//符号無し
	822
	823	//jb FalseSchedule（偽へジャンプ）
	824	OpBuffer[obp++]=(char)0x72;
	825	}
	826	FalseSchedule=obp;
	827	obp++;
	828
	829	//cmp eax,ebx
[227]	830	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	831
	832	//ja TrueSchedule2（真へジャンプ）
	833	OpBuffer[obp++]=(char)0x77;
	834	TrueSchedule2=obp;
	835	obp++;
	836
	837	//FalseScheduleのジャンプ先の設定
	838	OpBuffer[FalseSchedule]=obp-(FalseSchedule+1);
	839
	840	//xor eax,eax（eaxを0にする）
[225]	841	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	842
	843	//jmp 5（演算終了位置へジャンプ）
	844	OpBuffer[obp++]=(char)0xEB;
	845	OpBuffer[obp++]=(char)0x05;
	846
	847	//TrueScheduleのジャンプ先の設定
	848	OpBuffer[TrueSchedule1]=obp-(TrueSchedule1+1);
	849	OpBuffer[TrueSchedule2]=obp-(TrueSchedule2+1);
	850
[36]	851	//mov eax,1
[227]	852	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	853
	854	//push eax
[225]	855	compiler.codeGenerator.op_push(REG_EAX);
[3]	856	}
	857	else{
	858	////////////////////
	859	// 32ビット整数演算
	860	////////////////////
	861
	862	//pop ebx
[225]	863	compiler.codeGenerator.op_pop(REG_EBX);
[3]	864
	865	//pop eax
[225]	866	compiler.codeGenerator.op_pop(REG_EAX);
[3]	867
[97]	868	// どちらかのサイズが足りない場合は自動拡張する
	869	AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
	870
[3]	871	//sub esp,4
[225]	872	compiler.codeGenerator.op_sub_esp(4);
[3]	873
[36]	874	//mov ecx,1
[227]	875	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	876
	877	//cmp eax,ebx
[227]	878	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	879
	880	if(IsSignedType(AnswerType)){
[227]	881	//jg 2（次のxorを飛び越す）
[3]	882	OpBuffer[obp++]=(char)0x7F;
[227]	883	OpBuffer[obp++]=(char)0x02;
[3]	884	}
	885	else{
[227]	886	//ja 2（次のxorを飛び越す）
[3]	887	OpBuffer[obp++]=(char)0x77;
[227]	888	OpBuffer[obp++]=(char)0x02;
[3]	889	}
	890
[227]	891	//xor ecx,ecx
	892	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	893
	894	//mov dword ptr[esp],ecx
[225]	895	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	896	}
	897
	898	sp--;
[36]	899	type_stack[sp-1]=DEF_BOOLEAN;
[3]	900
	901	*pStackPointer=sp;
	902	return 1;
	903	}
	904
	905	BOOL Calc_Relation_NotEqual(int type,int pStackPointer){
	906	//value[sp-2]<>value[sp-1]
	907
	908	int sp;
	909	sp=*pStackPointer;
	910
	911	if(type[sp-2]==DEF_DOUBLE\|\|type[sp-2]==DEF_SINGLE\|\|
	912	type[sp-1]==DEF_DOUBLE\|\|type[sp-1]==DEF_SINGLE){
	913	//////////////
	914	// 実数演算
	915	//////////////
	916
	917	if(type[sp-1]==DEF_DOUBLE){
	918	//fld qword ptr[esp]
[225]	919	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	920
	921	//add esp,8
[225]	922	compiler.codeGenerator.op_add_esp(8);
[3]	923	}
	924	else if(type[sp-1]==DEF_SINGLE){
	925	//fld dword ptr[esp]
[225]	926	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	927
	928	//add esp,4
[225]	929	compiler.codeGenerator.op_add_esp(4);
[3]	930	}
	931	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	932	//64ビット整数値
	933
	934	//fild qword ptr[esp]
[225]	935	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	936
	937	//add esp,8
[225]	938	compiler.codeGenerator.op_add_esp(8);
[3]	939	}
	940	else{ //Long、DWord
	941	//fild dword ptr[esp]
[225]	942	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	943
	944	//add esp,4
[225]	945	compiler.codeGenerator.op_add_esp(4);
[3]	946	}
	947
	948	if(type[sp-2]==DEF_DOUBLE){
	949	//fld qword ptr[esp]
[225]	950	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	951
	952	//add esp,4
[225]	953	compiler.codeGenerator.op_add_esp(4);
[3]	954	}
	955	else if(type[sp-2]==DEF_SINGLE){
	956	//fld dword ptr[esp]
[225]	957	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	958	}
	959	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	960	//64ビット整数値
	961
	962	//fild qword ptr[esp]
[225]	963	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	964
	965	//add esp,4
[225]	966	compiler.codeGenerator.op_add_esp(4);
[3]	967	}
	968	else{ //Long、DWord
	969	//fild dword ptr[esp]
[225]	970	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	971	}
	972
	973	//fcompp
[225]	974	compiler.codeGenerator.op_fcompp();
[3]	975
	976	//fnstsw ax
[225]	977	compiler.codeGenerator.op_fnstsw_ax();
[3]	978
[36]	979	//mov ecx,1
[227]	980	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	981
	982	//test ah,40
[225]	983	compiler.codeGenerator.op_test_ah( (char)0x40 );
[3]	984
[227]	985	//je 2
[238]	986	compiler.codeGenerator.op_je( 2 );
[3]	987
[227]	988	//xor ecx,ecx
	989	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	990
	991	//mov dword ptr[esp],ecx
[225]	992	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	993	}
	994	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD\|\|
	995	type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	996	////////////////////
	997	// 64ビット整数演算
	998	////////////////////
	999
	1000	// 第1項 <> 第2項
	1001
	1002	//第1項 edx:eax
	1003	//第2項 ecx:ebx
	1004	GetStackData_ToRegister(type,sp);
	1005
	1006	//cmp eax,ebx
[227]	1007	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	1008
[238]	1009	//jne TrueSchedule1（真へジャンプ）
	1010	CodeGenerator::PertialSchedule *pTruePertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
[3]	1011
	1012	//cmp edx,ecx
[227]	1013	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	1014
[238]	1015	//jne TrueSchedule2（真へジャンプ）
	1016	CodeGenerator::PertialSchedule *pTruePertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
[3]	1017
	1018	//xor eax,eax（eaxを0にする）
[225]	1019	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	1020
	1021	//jmp 5（演算終了位置へジャンプ）
[238]	1022	compiler.codeGenerator.op_jmp( 5 );
[3]	1023
	1024	//TrueScheduleのジャンプ先の設定
[238]	1025	compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule1 );
	1026	compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule2 );
[3]	1027
[36]	1028	//mov eax,1
[227]	1029	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	1030
	1031	//push eax
[225]	1032	compiler.codeGenerator.op_push(REG_EAX);
[3]	1033	}
	1034	else{
	1035	////////////////////
	1036	// 32ビット整数演算
	1037	////////////////////
	1038
	1039	//pop eax
[225]	1040	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1041
	1042	//pop ebx
[225]	1043	compiler.codeGenerator.op_pop(REG_EBX);
[3]	1044
[97]	1045	// どちらかのサイズが足りない場合は自動拡張する
	1046	AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
	1047
[3]	1048	//sub esp,4
[225]	1049	compiler.codeGenerator.op_sub_esp(4);
[3]	1050
	1051	//xor eax,ebx
[238]	1052	compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
[3]	1053
[238]	1054	//je 5（次のmovを飛び越す）
	1055	compiler.codeGenerator.op_je( 5 );
[3]	1056
[36]	1057	//mov eax,1
[227]	1058	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	1059
	1060	//mov dword ptr[esp],eax
[225]	1061	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
[3]	1062	}
	1063
	1064	sp--;
[36]	1065	type[sp-1]=DEF_BOOLEAN;
[3]	1066
	1067	*pStackPointer=sp;
	1068	return 1;
	1069	}
	1070
	1071	BOOL Calc_Relation_Equal(int type,int pStackPointer){
	1072	//value[sp-2]=value[sp-1]
	1073
	1074	int sp;
	1075	sp=*pStackPointer;
	1076
	1077	if(type[sp-2]==DEF_DOUBLE\|\|type[sp-2]==DEF_SINGLE\|\|
	1078	type[sp-1]==DEF_DOUBLE\|\|type[sp-1]==DEF_SINGLE){
	1079	//////////////
	1080	// 実数演算
	1081	//////////////
	1082
	1083	if(type[sp-1]==DEF_DOUBLE){
	1084	//fld qword ptr[esp]
[225]	1085	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1086
	1087	//add esp,8
[225]	1088	compiler.codeGenerator.op_add_esp(8);
[3]	1089	}
	1090	else if(type[sp-1]==DEF_SINGLE){
	1091	//fld dword ptr[esp]
[225]	1092	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1093
	1094	//add esp,4
[225]	1095	compiler.codeGenerator.op_add_esp(4);
[3]	1096	}
	1097	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	1098	//64ビット整数値
	1099
	1100	//fild qword ptr[esp]
[225]	1101	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	1102
	1103	//add esp,8
[225]	1104	compiler.codeGenerator.op_add_esp(8);
[3]	1105	}
	1106	else{ //Long、DWord
	1107	//fild dword ptr[esp]
[225]	1108	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	1109
	1110	//add esp,4
[225]	1111	compiler.codeGenerator.op_add_esp(4);
[3]	1112	}
	1113
	1114	if(type[sp-2]==DEF_DOUBLE){
	1115	//fld qword ptr[esp]
[225]	1116	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1117
	1118	//add esp,4
[225]	1119	compiler.codeGenerator.op_add_esp(4);
[3]	1120	}
	1121	else if(type[sp-2]==DEF_SINGLE){
	1122	//fld dword ptr[esp]
[225]	1123	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1124	}
	1125	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	1126	//64ビット整数値
	1127
	1128	//fild qword ptr[esp]
[225]	1129	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	1130
	1131	//add esp,4
[225]	1132	compiler.codeGenerator.op_add_esp(4);
[3]	1133	}
	1134	else{ //Long、DWord
	1135	//fild dword ptr[esp]
[225]	1136	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	1137	}
	1138
	1139	//fcompp
[225]	1140	compiler.codeGenerator.op_fcompp();
[3]	1141
	1142	//fnstsw ax
[225]	1143	compiler.codeGenerator.op_fnstsw_ax();
[3]	1144
[36]	1145	//mov ecx,1
[227]	1146	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	1147
	1148	//test ah,40
[225]	1149	compiler.codeGenerator.op_test_ah( (char)0x40 );
[3]	1150
[227]	1151	//jne 2（次のxorを飛び越す）
[238]	1152	compiler.codeGenerator.op_jne( 2 );
[3]	1153
[227]	1154	//xor ecx,ecx
	1155	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	1156
	1157	//mov dword ptr[esp],ecx
[225]	1158	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	1159	}
	1160	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD\|\|
	1161	type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	1162	////////////////////
	1163	// 64ビット整数演算
	1164	////////////////////
	1165
	1166	// 第1項 == 第2項
	1167
	1168	//第1項 edx:eax
	1169	//第2項 ecx:ebx
	1170	GetStackData_ToRegister(type,sp);
	1171
	1172	//cmp eax,ebx
[227]	1173	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	1174
[238]	1175	//jne FalseSchedule1（偽へジャンプ）
	1176	CodeGenerator::PertialSchedule *pFalsePertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
[3]	1177
	1178	//cmp edx,ecx
[227]	1179	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	1180
[237]	1181	//jne FalseSchedule2（偽へジャンプ）
[238]	1182	CodeGenerator::PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
[3]	1183
[36]	1184	//mov eax,1
[227]	1185	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	1186
	1187	//jmp 2（演算終了位置へジャンプ）
[238]	1188	compiler.codeGenerator.op_jmp( 2 );
[3]	1189
	1190	//FalseScheduleのジャンプ先の設定
[238]	1191	compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
	1192	compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
[3]	1193
	1194	//xor eax,eax（eaxを0にする）
[225]	1195	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	1196
	1197	//push eax
[225]	1198	compiler.codeGenerator.op_push(REG_EAX);
[3]	1199	}
	1200	else{
	1201	////////////////////
	1202	// 32ビット整数演算
	1203	////////////////////
	1204
	1205	//pop eax
[225]	1206	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1207
	1208	//pop ebx
[225]	1209	compiler.codeGenerator.op_pop(REG_EBX);
[3]	1210
[97]	1211	// どちらかのサイズが足りない場合は自動拡張する
	1212	AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
	1213
[3]	1214	//sub esp,4
[225]	1215	compiler.codeGenerator.op_sub_esp(4);
[3]	1216
	1217	//xor eax,ebx
[238]	1218	compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
[3]	1219
[238]	1220	//je 4（次のxorとjmpを飛び越す）
	1221	compiler.codeGenerator.op_je( 4 );
[36]	1222
	1223	//xor eax,eax
[238]	1224	compiler.codeGenerator.op_xor_RR( REG_EAX );
[36]	1225
	1226	//jmp 5
[238]	1227	compiler.codeGenerator.op_jmp( 5 );
[3]	1228
[36]	1229	//mov eax,1
[227]	1230	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	1231
	1232	//mov dword ptr[esp],eax
[225]	1233	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
[3]	1234	}
	1235
	1236	sp--;
[36]	1237	type[sp-1]=DEF_BOOLEAN;
[3]	1238
	1239	*pStackPointer=sp;
	1240	return 1;
	1241	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: