Context Navigation

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

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

File size: 29.4 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を飛び越す）
[240]	331	compiler.codeGenerator.op_je( 2 );
[3]	332
[227]	333	//xor ecx,ecx
	334	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	335
	336	//mov dword ptr[esp],ecx
[225]	337	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	338	}
	339	else if(Is64Type(AnswerType)){
	340	////////////////////
	341	// 64ビット整数演算
	342	////////////////////
	343
	344	// 第1項 >= 第2項
	345
	346	//第1項 edx:eax
	347	//第2項 ecx:ebx
	348	GetStackData_ToRegister(type_stack,sp);
	349
	350	//cmp edx,ecx
[227]	351	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	352
[240]	353	CodeGenerator::PertialSchedule *pFalsePertialSchedule1;
[3]	354	if(IsSignedType(AnswerType)){
	355	//符号あり演算
	356
	357	//jl FalseSchedule1（偽へジャンプ）
[240]	358	pFalsePertialSchedule1 = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
[3]	359	}
	360	else{
	361	//符号なし演算
	362
	363	//jb FalseSchedule1（偽へジャンプ）
[240]	364	pFalsePertialSchedule1 = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
[3]	365	}
	366
[240]	367	CodeGenerator::PertialSchedule *pTruePertialSchedule;
[3]	368	if(IsSignedType(AnswerType)){
	369	//符号あり演算
	370
	371	//jg TrueSchedule（真へジャンプ）
[240]	372	pTruePertialSchedule = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
[3]	373	}
	374	else{
	375	//符号なし演算
	376
	377	//ja TrueSchedule（真へジャンプ）
[240]	378	pTruePertialSchedule = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
[3]	379	}
	380
	381	//cmp eax,ebx
[227]	382	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	383
	384	//jb FalseSchedule2（偽へジャンプ）
[240]	385	CodeGenerator::PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
[3]	386
	387	//TrueScheduleのジャンプ先の設定
[240]	388	compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule );
[3]	389
[36]	390	//mov eax,1
[227]	391	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	392
	393	//jmp 2（演算終了位置へジャンプ）
[240]	394	compiler.codeGenerator.op_jmp( 2 );
[3]	395
	396	//FalseScheduleのジャンプ先の設定
[240]	397	compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
	398	compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
[3]	399
	400	//xor eax,eax（eaxを0にする）
[225]	401	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	402
	403	//push eax
[225]	404	compiler.codeGenerator.op_push(REG_EAX);
[3]	405	}
	406	else{
	407	////////////////////
	408	// 32ビット整数演算
	409	////////////////////
	410
	411	//pop ebx
[225]	412	compiler.codeGenerator.op_pop(REG_EBX);
[3]	413
	414	//pop eax
[225]	415	compiler.codeGenerator.op_pop(REG_EAX);
[3]	416
[97]	417	// どちらかのサイズが足りない場合は自動拡張する
	418	AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
	419
[3]	420	//sub esp,4
[225]	421	compiler.codeGenerator.op_sub_esp(4);
[3]	422
[36]	423	//mov ecx,1
[227]	424	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	425
	426	//cmp eax,ebx
[227]	427	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	428
	429	if(IsSignedType(AnswerType)){
	430	//符号あり演算
	431
[227]	432	//jge 2（次のxorを飛び越す）符号有り
[240]	433	compiler.codeGenerator.op_jge( 2 );
[3]	434	}
	435	else{
	436	//符号なし演算
	437
[227]	438	//jae 2（次のxorを飛び越す）
[240]	439	compiler.codeGenerator.op_jae( 2 );
[3]	440	}
	441
[227]	442	//xor ecx,ecx
	443	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	444
	445	//mov dword ptr[esp],ecx
[225]	446	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	447	}
	448
	449	sp--;
[36]	450	type_stack[sp-1]=DEF_BOOLEAN;
[3]	451
	452	*pStackPointer=sp;
	453	return 1;
	454	}
	455
	456	BOOL Calc_Relation_P(int type_stack,LONG_PTR index_stack,int *pStackPointer){
	457	//value[sp-2]<value[sp-1]
	458
	459	int sp;
	460	sp=*pStackPointer;
	461
	462	int AnswerType;
	463	AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
	464
	465	if(IsRealNumberType(AnswerType)){
	466	//////////////
	467	// 実数演算
	468	//////////////
	469
	470	if(type_stack[sp-1]==DEF_DOUBLE){
	471	//fld qword ptr[esp]
[225]	472	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	473
	474	//add esp,8
[225]	475	compiler.codeGenerator.op_add_esp(8);
[3]	476	}
	477	else if(type_stack[sp-1]==DEF_SINGLE){
	478	//fld dword ptr[esp]
[225]	479	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	480
	481	//add esp,4
[225]	482	compiler.codeGenerator.op_add_esp(4);
[3]	483	}
	484	else if(type_stack[sp-1]==DEF_INT64\|\|type_stack[sp-1]==DEF_QWORD){
	485	//64ビット整数値
	486
	487	//fild qword ptr[esp]
[225]	488	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	489
	490	//add esp,8
[225]	491	compiler.codeGenerator.op_add_esp(8);
[3]	492	}
	493	else{
	494	//その他整数型
	495
	496	//fild dword ptr[esp]
[225]	497	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	498
	499	//add esp,4
[225]	500	compiler.codeGenerator.op_add_esp(4);
[3]	501	}
	502
	503	if(type_stack[sp-2]==DEF_DOUBLE){
	504	//fld qword ptr[esp]
[225]	505	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	506
	507	//add esp,4
[225]	508	compiler.codeGenerator.op_add_esp(4);
[3]	509	}
	510	else if(type_stack[sp-2]==DEF_SINGLE){
	511	//fld dword ptr[esp]
[225]	512	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	513	}
	514	else if(type_stack[sp-2]==DEF_INT64\|\|type_stack[sp-2]==DEF_QWORD){
	515	//64ビット整数値
	516
	517	//fild qword ptr[esp]
[225]	518	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	519
	520	//add esp,4
[225]	521	compiler.codeGenerator.op_add_esp(4);
[3]	522	}
	523	else{
	524	//その他整数型
	525
	526	//fild dword ptr[esp]
[225]	527	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	528	}
	529
	530	//fcompp
[225]	531	compiler.codeGenerator.op_fcompp();
[3]	532
	533	//fnstsw ax
[225]	534	compiler.codeGenerator.op_fnstsw_ax();
[3]	535
[36]	536	//mov ecx,1
[227]	537	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	538
	539	//test ah,01h
[237]	540	compiler.codeGenerator.op_test_ah( (char)0x01 );
[3]	541
[227]	542	//jne 2
[240]	543	compiler.codeGenerator.op_jne( 2 );
[3]	544
[227]	545	//xor ecx,ecx
	546	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	547
	548	//mov dword ptr[esp],ecx
[225]	549	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	550	}
	551	else if(Is64Type(AnswerType)){
	552	////////////////////
	553	// 64ビット整数演算
	554	////////////////////
	555
	556	// 第1項 < 第2項
	557
	558	//第1項 edx:eax
	559	//第2項 ecx:ebx
	560	GetStackData_ToRegister(type_stack,sp);
	561
	562	//cmp edx,ecx
[227]	563	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	564
[240]	565	CodeGenerator::PertialSchedule *pTruePertialSchedule1;
[3]	566	if(IsSignedType(AnswerType)){
	567	//符号あり演算
	568
	569	//jl TrueSchedule1（真へジャンプ）
[240]	570	pTruePertialSchedule1 = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
[3]	571	}
	572	else{
	573	//符号なし演算
	574
	575	//jb TrueSchedule1（真へジャンプ）
[240]	576	pTruePertialSchedule1 = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
[3]	577	}
	578
[240]	579	CodeGenerator::PertialSchedule *pFalsePertialSchedule;
[3]	580	if(IsSignedType(AnswerType)){
	581	//符号あり演算
	582
	583	//jg FalseSchedule（偽へジャンプ）
[240]	584	pFalsePertialSchedule = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
[3]	585	}
	586	else{
	587	//符号なし演算
	588
	589	//ja FalseSchedule（偽へジャンプ）
[240]	590	pFalsePertialSchedule = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
[3]	591	}
	592
	593	//cmp eax,ebx
[227]	594	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	595
	596	//jb TrueSchedule2（真へジャンプ）
[240]	597	CodeGenerator::PertialSchedule *pTruePertialSchedule2 = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
[3]	598
	599	//FalseScheduleのジャンプ先の設定
[240]	600	compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule );
[3]	601
	602	//xor eax,eax（eaxを0にする）
[225]	603	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	604
	605	//jmp 5（演算終了位置へジャンプ）
[240]	606	compiler.codeGenerator.op_jmp( 5 );
[3]	607
	608	//TrueScheduleのジャンプ先の設定
[240]	609	compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule1 );
	610	compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule2 );
[3]	611
[36]	612	//mov eax,1
[227]	613	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	614
	615	//push eax
[225]	616	compiler.codeGenerator.op_push(REG_EAX);
[3]	617	}
	618	else{
	619	///////////////////
	620	//32ビット整数演算
	621	///////////////////
	622
	623	//pop ebx
[225]	624	compiler.codeGenerator.op_pop(REG_EBX);
[3]	625
	626	//pop eax
[225]	627	compiler.codeGenerator.op_pop(REG_EAX);
[3]	628
[97]	629	// どちらかのサイズが足りない場合は自動拡張する
	630	AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
	631
[3]	632	//sub esp,4
[225]	633	compiler.codeGenerator.op_sub_esp(4);
[3]	634
[36]	635	//mov ecx,1
[227]	636	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	637
	638	//cmp eax,ebx
[227]	639	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	640
	641	if(IsSignedType(AnswerType)){
	642	//符号あり演算
	643
[227]	644	//jl 2（次のxorを飛び越す）
[240]	645	compiler.codeGenerator.op_jl( 2 );
[3]	646	}
	647	else{
	648	//符号なし演算
	649
[227]	650	//jb 2（次のxorを飛び越す）
[240]	651	compiler.codeGenerator.op_jb( 2 );
[3]	652	}
	653
[227]	654	//xor ecx,ecx
	655	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	656
	657	//mov dword ptr[esp],ecx
[225]	658	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	659	}
	660
	661	sp--;
[36]	662	type_stack[sp-1]=DEF_BOOLEAN;
[3]	663
	664	*pStackPointer=sp;
	665	return 1;
	666	}
	667
	668	BOOL Calc_Relation_Q(int type_stack,LONG_PTR index_stack,int *pStackPointer){
	669	//value[sp-2]>value[sp-1]
	670
	671	int sp;
	672	sp=*pStackPointer;
	673
	674	int AnswerType;
	675	AnswerType=NeutralizationType(type_stack[sp-2],index_stack[sp-2],type_stack[sp-1],index_stack[sp-1]);
	676
	677	if(IsRealNumberType(AnswerType)){
	678	//////////////
	679	// 実数演算
	680	//////////////
	681
	682	if(type_stack[sp-1]==DEF_DOUBLE){
	683	//fld qword ptr[esp]
[225]	684	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	685
	686	//add esp,8
[225]	687	compiler.codeGenerator.op_add_esp(8);
[3]	688	}
	689	else if(type_stack[sp-1]==DEF_SINGLE){
	690	//fld dword ptr[esp]
[225]	691	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	692
	693	//add esp,4
[225]	694	compiler.codeGenerator.op_add_esp(4);
[3]	695	}
	696	else if(type_stack[sp-1]==DEF_INT64\|\|type_stack[sp-1]==DEF_QWORD){
	697	//64ビット整数値
	698
	699	//fild qword ptr[esp]
[225]	700	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	701
	702	//add esp,8
[225]	703	compiler.codeGenerator.op_add_esp(8);
[3]	704	}
	705	else{ //Long、DWord
	706	//fild dword ptr[esp]
[225]	707	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	708
	709	//add esp,4
[225]	710	compiler.codeGenerator.op_add_esp(4);
[3]	711	}
	712
	713	if(type_stack[sp-2]==DEF_DOUBLE){
	714	//fld qword ptr[esp]
[225]	715	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	716
	717	//add esp,4
[225]	718	compiler.codeGenerator.op_add_esp(4);
[3]	719	}
	720	else if(type_stack[sp-2]==DEF_SINGLE){
	721	//fld dword ptr[esp]
[225]	722	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	723	}
	724	else if(type_stack[sp-2]==DEF_INT64\|\|type_stack[sp-2]==DEF_QWORD){
	725	//64ビット整数値
	726
	727	//fild qword ptr[esp]
[225]	728	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	729
	730	//add esp,4
[225]	731	compiler.codeGenerator.op_add_esp(4);
[3]	732	}
	733	else{ //Long、DWord
	734	//fild dword ptr[esp]
[225]	735	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	736	}
	737
	738	//fcompp
[225]	739	compiler.codeGenerator.op_fcompp();
[3]	740
	741	//fnstsw ax
[225]	742	compiler.codeGenerator.op_fnstsw_ax();
[3]	743
[36]	744	//mov ecx,1
[227]	745	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	746
	747	//test ah,41
[225]	748	compiler.codeGenerator.op_test_ah( (char)0x41 );
[3]	749
[227]	750	//je 2（次のxorを飛び越す）
[240]	751	compiler.codeGenerator.op_je( 2 );
[3]	752
[227]	753	//xor ecx,ecx
	754	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	755
	756	//mov dword ptr[esp],ecx
[225]	757	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	758	}
	759	else if(Is64Type(AnswerType)){
	760	////////////////////
	761	// 64ビット整数演算
	762	////////////////////
	763
	764	// 第1項 > 第2項
	765
	766	//第1項 edx:eax
	767	//第2項 ecx:ebx
	768	GetStackData_ToRegister(type_stack,sp);
	769
	770	//cmp edx,ecx
[227]	771	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	772
[240]	773	CodeGenerator::PertialSchedule *pTruePertialSchedule1;
[3]	774	if(IsSignedType(AnswerType)){
	775	//符号有り
	776
	777	//jg TrueSchedule1（真へジャンプ）
[240]	778	pTruePertialSchedule1 = compiler.codeGenerator.op_jg( 0, sizeof(char), true );
[3]	779	}
	780	else{
	781	//符号無し
	782
	783	//ja TrueSchedule1（真へジャンプ）
[240]	784	pTruePertialSchedule1 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
[3]	785	}
	786
[240]	787	CodeGenerator::PertialSchedule *pFalsePertialSchedule;
[3]	788	if(IsSignedType(AnswerType)){
	789	//符号有り
	790
	791	//jl FalseSchedule（偽へジャンプ）
[240]	792	pFalsePertialSchedule = compiler.codeGenerator.op_jl( 0, sizeof(char), true );
[3]	793	}
	794	else{
	795	//符号無し
	796
	797	//jb FalseSchedule（偽へジャンプ）
[240]	798	pFalsePertialSchedule = compiler.codeGenerator.op_jb( 0, sizeof(char), true );
[3]	799	}
	800
	801	//cmp eax,ebx
[227]	802	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	803
	804	//ja TrueSchedule2（真へジャンプ）
[240]	805	CodeGenerator::PertialSchedule *pTruePertialSchedule2 = compiler.codeGenerator.op_ja( 0, sizeof(char), true );
[3]	806
	807	//FalseScheduleのジャンプ先の設定
[240]	808	compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule );
[3]	809
	810	//xor eax,eax（eaxを0にする）
[225]	811	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	812
	813	//jmp 5（演算終了位置へジャンプ）
[240]	814	compiler.codeGenerator.op_jmp( 5 );
[3]	815
	816	//TrueScheduleのジャンプ先の設定
[240]	817	compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule1 );
	818	compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule2 );
[3]	819
[36]	820	//mov eax,1
[227]	821	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	822
	823	//push eax
[225]	824	compiler.codeGenerator.op_push(REG_EAX);
[3]	825	}
	826	else{
	827	////////////////////
	828	// 32ビット整数演算
	829	////////////////////
	830
	831	//pop ebx
[225]	832	compiler.codeGenerator.op_pop(REG_EBX);
[3]	833
	834	//pop eax
[225]	835	compiler.codeGenerator.op_pop(REG_EAX);
[3]	836
[97]	837	// どちらかのサイズが足りない場合は自動拡張する
	838	AutoExtendToBigType( type_stack, sp, REG_EAX, REG_EBX );
	839
[3]	840	//sub esp,4
[225]	841	compiler.codeGenerator.op_sub_esp(4);
[3]	842
[36]	843	//mov ecx,1
[227]	844	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	845
	846	//cmp eax,ebx
[227]	847	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	848
	849	if(IsSignedType(AnswerType)){
[227]	850	//jg 2（次のxorを飛び越す）
[240]	851	compiler.codeGenerator.op_jg( 2 );
[3]	852	}
	853	else{
[227]	854	//ja 2（次のxorを飛び越す）
[240]	855	compiler.codeGenerator.op_ja( 2 );
[3]	856	}
	857
[227]	858	//xor ecx,ecx
	859	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	860
	861	//mov dword ptr[esp],ecx
[225]	862	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	863	}
	864
	865	sp--;
[36]	866	type_stack[sp-1]=DEF_BOOLEAN;
[3]	867
	868	*pStackPointer=sp;
	869	return 1;
	870	}
	871
	872	BOOL Calc_Relation_NotEqual(int type,int pStackPointer){
	873	//value[sp-2]<>value[sp-1]
	874
	875	int sp;
	876	sp=*pStackPointer;
	877
	878	if(type[sp-2]==DEF_DOUBLE\|\|type[sp-2]==DEF_SINGLE\|\|
	879	type[sp-1]==DEF_DOUBLE\|\|type[sp-1]==DEF_SINGLE){
	880	//////////////
	881	// 実数演算
	882	//////////////
	883
	884	if(type[sp-1]==DEF_DOUBLE){
	885	//fld qword ptr[esp]
[225]	886	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	887
	888	//add esp,8
[225]	889	compiler.codeGenerator.op_add_esp(8);
[3]	890	}
	891	else if(type[sp-1]==DEF_SINGLE){
	892	//fld dword ptr[esp]
[225]	893	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	894
	895	//add esp,4
[225]	896	compiler.codeGenerator.op_add_esp(4);
[3]	897	}
	898	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	899	//64ビット整数値
	900
	901	//fild qword ptr[esp]
[225]	902	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	903
	904	//add esp,8
[225]	905	compiler.codeGenerator.op_add_esp(8);
[3]	906	}
	907	else{ //Long、DWord
	908	//fild dword ptr[esp]
[225]	909	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	910
	911	//add esp,4
[225]	912	compiler.codeGenerator.op_add_esp(4);
[3]	913	}
	914
	915	if(type[sp-2]==DEF_DOUBLE){
	916	//fld qword ptr[esp]
[225]	917	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	918
	919	//add esp,4
[225]	920	compiler.codeGenerator.op_add_esp(4);
[3]	921	}
	922	else if(type[sp-2]==DEF_SINGLE){
	923	//fld dword ptr[esp]
[225]	924	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	925	}
	926	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	927	//64ビット整数値
	928
	929	//fild qword ptr[esp]
[225]	930	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	931
	932	//add esp,4
[225]	933	compiler.codeGenerator.op_add_esp(4);
[3]	934	}
	935	else{ //Long、DWord
	936	//fild dword ptr[esp]
[225]	937	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	938	}
	939
	940	//fcompp
[225]	941	compiler.codeGenerator.op_fcompp();
[3]	942
	943	//fnstsw ax
[225]	944	compiler.codeGenerator.op_fnstsw_ax();
[3]	945
[36]	946	//mov ecx,1
[227]	947	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	948
	949	//test ah,40
[225]	950	compiler.codeGenerator.op_test_ah( (char)0x40 );
[3]	951
[227]	952	//je 2
[238]	953	compiler.codeGenerator.op_je( 2 );
[3]	954
[227]	955	//xor ecx,ecx
	956	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	957
	958	//mov dword ptr[esp],ecx
[225]	959	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	960	}
	961	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD\|\|
	962	type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	963	////////////////////
	964	// 64ビット整数演算
	965	////////////////////
	966
	967	// 第1項 <> 第2項
	968
	969	//第1項 edx:eax
	970	//第2項 ecx:ebx
	971	GetStackData_ToRegister(type,sp);
	972
	973	//cmp eax,ebx
[227]	974	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	975
[238]	976	//jne TrueSchedule1（真へジャンプ）
	977	CodeGenerator::PertialSchedule *pTruePertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
[3]	978
	979	//cmp edx,ecx
[227]	980	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	981
[238]	982	//jne TrueSchedule2（真へジャンプ）
	983	CodeGenerator::PertialSchedule *pTruePertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
[3]	984
	985	//xor eax,eax（eaxを0にする）
[225]	986	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	987
	988	//jmp 5（演算終了位置へジャンプ）
[238]	989	compiler.codeGenerator.op_jmp( 5 );
[3]	990
	991	//TrueScheduleのジャンプ先の設定
[238]	992	compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule1 );
	993	compiler.codeGenerator.opfix_JmpPertialSchedule( pTruePertialSchedule2 );
[3]	994
[36]	995	//mov eax,1
[227]	996	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	997
	998	//push eax
[225]	999	compiler.codeGenerator.op_push(REG_EAX);
[3]	1000	}
	1001	else{
	1002	////////////////////
	1003	// 32ビット整数演算
	1004	////////////////////
	1005
	1006	//pop eax
[225]	1007	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1008
	1009	//pop ebx
[225]	1010	compiler.codeGenerator.op_pop(REG_EBX);
[3]	1011
[97]	1012	// どちらかのサイズが足りない場合は自動拡張する
	1013	AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
	1014
[3]	1015	//sub esp,4
[225]	1016	compiler.codeGenerator.op_sub_esp(4);
[3]	1017
	1018	//xor eax,ebx
[238]	1019	compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
[3]	1020
[238]	1021	//je 5（次のmovを飛び越す）
	1022	compiler.codeGenerator.op_je( 5 );
[3]	1023
[36]	1024	//mov eax,1
[227]	1025	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	1026
	1027	//mov dword ptr[esp],eax
[225]	1028	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
[3]	1029	}
	1030
	1031	sp--;
[36]	1032	type[sp-1]=DEF_BOOLEAN;
[3]	1033
	1034	*pStackPointer=sp;
	1035	return 1;
	1036	}
	1037
	1038	BOOL Calc_Relation_Equal(int type,int pStackPointer){
	1039	//value[sp-2]=value[sp-1]
	1040
	1041	int sp;
	1042	sp=*pStackPointer;
	1043
	1044	if(type[sp-2]==DEF_DOUBLE\|\|type[sp-2]==DEF_SINGLE\|\|
	1045	type[sp-1]==DEF_DOUBLE\|\|type[sp-1]==DEF_SINGLE){
	1046	//////////////
	1047	// 実数演算
	1048	//////////////
	1049
	1050	if(type[sp-1]==DEF_DOUBLE){
	1051	//fld qword ptr[esp]
[225]	1052	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1053
	1054	//add esp,8
[225]	1055	compiler.codeGenerator.op_add_esp(8);
[3]	1056	}
	1057	else if(type[sp-1]==DEF_SINGLE){
	1058	//fld dword ptr[esp]
[225]	1059	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1060
	1061	//add esp,4
[225]	1062	compiler.codeGenerator.op_add_esp(4);
[3]	1063	}
	1064	else if(type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	1065	//64ビット整数値
	1066
	1067	//fild qword ptr[esp]
[225]	1068	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	1069
	1070	//add esp,8
[225]	1071	compiler.codeGenerator.op_add_esp(8);
[3]	1072	}
	1073	else{ //Long、DWord
	1074	//fild dword ptr[esp]
[225]	1075	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	1076
	1077	//add esp,4
[225]	1078	compiler.codeGenerator.op_add_esp(4);
[3]	1079	}
	1080
	1081	if(type[sp-2]==DEF_DOUBLE){
	1082	//fld qword ptr[esp]
[225]	1083	compiler.codeGenerator.op_fld_ptr_esp(DEF_DOUBLE);
[3]	1084
	1085	//add esp,4
[225]	1086	compiler.codeGenerator.op_add_esp(4);
[3]	1087	}
	1088	else if(type[sp-2]==DEF_SINGLE){
	1089	//fld dword ptr[esp]
[225]	1090	compiler.codeGenerator.op_fld_ptr_esp(DEF_SINGLE);
[3]	1091	}
	1092	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD){
	1093	//64ビット整数値
	1094
	1095	//fild qword ptr[esp]
[225]	1096	compiler.codeGenerator.op_fld_ptr_esp(DEF_INT64);
[3]	1097
	1098	//add esp,4
[225]	1099	compiler.codeGenerator.op_add_esp(4);
[3]	1100	}
	1101	else{ //Long、DWord
	1102	//fild dword ptr[esp]
[225]	1103	compiler.codeGenerator.op_fld_ptr_esp(DEF_LONG);
[3]	1104	}
	1105
	1106	//fcompp
[225]	1107	compiler.codeGenerator.op_fcompp();
[3]	1108
	1109	//fnstsw ax
[225]	1110	compiler.codeGenerator.op_fnstsw_ax();
[3]	1111
[36]	1112	//mov ecx,1
[227]	1113	compiler.codeGenerator.op_mov_RV( REG_ECX, 1 );
[3]	1114
	1115	//test ah,40
[225]	1116	compiler.codeGenerator.op_test_ah( (char)0x40 );
[3]	1117
[227]	1118	//jne 2（次のxorを飛び越す）
[238]	1119	compiler.codeGenerator.op_jne( 2 );
[3]	1120
[227]	1121	//xor ecx,ecx
	1122	compiler.codeGenerator.op_xor_RR( REG_ECX );
[3]	1123
	1124	//mov dword ptr[esp],ecx
[225]	1125	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_ESP, 0, MOD_BASE );
[3]	1126	}
	1127	else if(type[sp-2]==DEF_INT64\|\|type[sp-2]==DEF_QWORD\|\|
	1128	type[sp-1]==DEF_INT64\|\|type[sp-1]==DEF_QWORD){
	1129	////////////////////
	1130	// 64ビット整数演算
	1131	////////////////////
	1132
	1133	// 第1項 == 第2項
	1134
	1135	//第1項 edx:eax
	1136	//第2項 ecx:ebx
	1137	GetStackData_ToRegister(type,sp);
	1138
	1139	//cmp eax,ebx
[227]	1140	compiler.codeGenerator.op_cmp_RR( REG_EAX, REG_EBX );
[3]	1141
[238]	1142	//jne FalseSchedule1（偽へジャンプ）
	1143	CodeGenerator::PertialSchedule *pFalsePertialSchedule1 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
[3]	1144
	1145	//cmp edx,ecx
[227]	1146	compiler.codeGenerator.op_cmp_RR( REG_EDX, REG_ECX );
[3]	1147
[237]	1148	//jne FalseSchedule2（偽へジャンプ）
[238]	1149	CodeGenerator::PertialSchedule *pFalsePertialSchedule2 = compiler.codeGenerator.op_jne( 0, sizeof(char), true );
[3]	1150
[36]	1151	//mov eax,1
[227]	1152	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	1153
	1154	//jmp 2（演算終了位置へジャンプ）
[238]	1155	compiler.codeGenerator.op_jmp( 2 );
[3]	1156
	1157	//FalseScheduleのジャンプ先の設定
[238]	1158	compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule1 );
	1159	compiler.codeGenerator.opfix_JmpPertialSchedule( pFalsePertialSchedule2 );
[3]	1160
	1161	//xor eax,eax（eaxを0にする）
[225]	1162	compiler.codeGenerator.op_zero_reg(REG_EAX);
[3]	1163
	1164	//push eax
[225]	1165	compiler.codeGenerator.op_push(REG_EAX);
[3]	1166	}
	1167	else{
	1168	////////////////////
	1169	// 32ビット整数演算
	1170	////////////////////
	1171
	1172	//pop eax
[225]	1173	compiler.codeGenerator.op_pop(REG_EAX);
[3]	1174
	1175	//pop ebx
[225]	1176	compiler.codeGenerator.op_pop(REG_EBX);
[3]	1177
[97]	1178	// どちらかのサイズが足りない場合は自動拡張する
	1179	AutoExtendToBigType( type, sp, REG_EAX, REG_EBX );
	1180
[3]	1181	//sub esp,4
[225]	1182	compiler.codeGenerator.op_sub_esp(4);
[3]	1183
	1184	//xor eax,ebx
[238]	1185	compiler.codeGenerator.op_xor_RR( REG_EAX, REG_EBX );
[3]	1186
[238]	1187	//je 4（次のxorとjmpを飛び越す）
	1188	compiler.codeGenerator.op_je( 4 );
[36]	1189
	1190	//xor eax,eax
[238]	1191	compiler.codeGenerator.op_xor_RR( REG_EAX );
[36]	1192
	1193	//jmp 5
[238]	1194	compiler.codeGenerator.op_jmp( 5 );
[3]	1195
[36]	1196	//mov eax,1
[227]	1197	compiler.codeGenerator.op_mov_RV( REG_EAX, 1 );
[3]	1198
	1199	//mov dword ptr[esp],eax
[225]	1200	compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EAX, REG_ESP, 0, MOD_BASE );
[3]	1201	}
	1202
	1203	sp--;
[36]	1204	type[sp-1]=DEF_BOOLEAN;
[3]	1205
	1206	*pStackPointer=sp;
	1207	return 1;
	1208	}

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

Download in other formats: