Context Navigation

source: dev/BasicCompiler64/NumOpe.cpp@ 64

Last change on this file since 64 was 64, checked in by dai_9181, 19 years ago
すべてのオブジェクトを参照型に切り替えた。
File size: 20.9 KB

Rev	Line
[3]	1	#include "../BasicCompiler_Common/common.h"
	2	#include "Opcode.h"
	3
	4	void NewStringObject(int reg,LPSTR lpszText){
	5	///////////////////////////////////////////////////////
	6	// lpszTextを元にStringオブジェクトを生成し、
	7	// オブジェクトポインタをregに格納する
	8	///////////////////////////////////////////////////////
	9
	10
	11	//////////////////////////////////////////////////////
	12	///// レジスタ資源のバックアップ
	13	{ BACKUP_REGISTER_RESOURCE
	14	//////////////////////////////////////////////////////
	15
[64]	16	char parameter = (char )malloc( lstrlen( lpszText ) + 3 );
	17	lstrcpy( parameter, lpszText );
	18	SetStringQuotes( parameter );
	19
[3]	20	extern CClass *pobj_StringClass;
[64]	21	TYPEINFO baseTypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
	22	Operator_New( *pobj_StringClass, "", parameter, baseTypeInfo );
[3]	23
[64]	24	free( parameter );
[3]	25
[64]	26	//mov reg,rax
	27	op_mov_RR( reg, REG_RAX );
[3]	28
	29	/////////////////////////////////////////////
	30	////// レジスタ資源を復元
	31	RESTORE_REGISTER_RESOURCE
	32	}////////////////////////////////////////////
	33	}
	34
	35	void SetUseRegFromRax(int type,int UseReg,int XmmReg){
	36	if(IsRealNumberType(type)){
	37	//実数型
	38	if(XmmReg==REG_XMM4){
	39	if(type==DEF_DOUBLE){
	40	//movsd qword ptr[rsp+offset],xmm0 ※スタックフレームを利用
	41	pobj_sf->push(REG_XMM0,sizeof(double));
	42	}
	43	if(type==DEF_SINGLE){
	44	//movss dword ptr[rsp+offset],xmm0 ※スタックフレームを利用
	45	pobj_sf->push(REG_XMM0,sizeof(float));
	46	}
	47	}
	48	else{
	49	if(type==DEF_DOUBLE){
	50	//movsd xmm_reg,xmm0
	51	op_movsd_RR(XmmReg,REG_XMM0);
	52	}
	53	else if(type==DEF_SINGLE){
	54	//movss xmm_reg,xmm0
	55	op_movss_RR(XmmReg,REG_XMM0);
	56	}
	57	}
	58	}
	59	else{
	60	//整数型
	61	if(UseReg==REG_R14){
	62	//mov qword ptr[rsp+offset],rax ※スタックフレームを利用
	63	pobj_sf->push(REG_RAX);
	64	}
	65	else{
	66	//mov reg,rax
[64]	67	op_mov_RR(UseReg,REG_RAX);
[3]	68	}
	69	}
	70	}
	71
[15]	72	int NumOpe(int pReg,const char Command,int BaseType,LONG_PTR lpBaseIndex,LONG_PTR plpIndex,BOOL pbUseHeap){
[3]	73	extern HANDLE hHeap;
	74	int i,i2,i3,i4;
	75	char temporary[1024],temp2[1024],temp3[1024];
	76
	77	if(Command[0]=='\0'){
	78	SetError(1,NULL,cp);
	79	return 0;
	80	}
	81
[64]	82	if(Command[0]==1&& Command[1]==ESC_NEW ){
[3]	83	//New演算子（オブジェクト生成）
[64]	84	TYPEINFO baseTypeInfo = { BaseType, lpBaseIndex };
	85	int resultType = Operator_New(Command+2,plpIndex, baseTypeInfo );
	86
	87	//mov reg,rax
	88	op_mov_RR( *pReg, REG_RAX );
	89
	90	return resultType;
[3]	91	}
	92
	93
	94	/////////////////////////////////
	95	// 式要素を逆ポーランド式で取得
	96	/////////////////////////////////
	97
	98	char *values[255];
	99	long calc[255];
	100	long stack[255];
	101	int pnum;
	102	if(!GetNumOpeElements(Command,&pnum,values,calc,stack)){
	103	for(i=0;i<pnum;i++){
	104	if(values[i]) HeapDefaultFree(values[i]);
	105	}
	106	return 0;
	107	}
	108
	109
	110	BOOL bInitRegSwitch=0;
	111	if(!pobj_reg){
	112	bInitRegSwitch=1;
	113
	114	//作業用レジスタを取得
	115	pobj_reg=new CRegister(*pReg);
	116	}
	117
	118	//エラー時の復旧用
	119	CRegister objReg_Backup;
	120	objReg_Backup=*pobj_reg;
	121
	122
	123
	124	////////////////////////////////
	125	// 演算部分のコード生成を開始
	126	////////////////////////////////
	127
	128	BOOL bError;
	129	bError=0;
	130
	131	//リテラル値のみの計算かどうかを判別するためのフラグ
	132	BOOL bLiteralCalculation=1;
	133
	134	//リテラル演算の場合を考慮した演算前のバッファ位置
	135	int BeforeObp;
	136	BeforeObp=obp;
	137
	138	//リテラル演算の場合を考慮した演算前のプロシージャスケジュール位置
	139	//※64ビットの掛け算、除算などで特殊関数が呼ばれるため
	140	int Before_ProcAddrScheduleNum;
	141	Before_ProcAddrScheduleNum=pobj_SubAddrSchedule->num;
	142
	143	//リテラル演算の場合を考慮した演算前のデータテーブルスケジュール位置
	144	int Before_DataTableScheduleNum;
	145	Before_DataTableScheduleNum=pobj_DataTableSchedule->num;
	146
	147	//リテラル演算の場合を考慮した演算前の再配置スケジュール
	148	CReloc *pobj_BackReloc;
	149	pobj_BackReloc=new CReloc();
	150	pobj_BackReloc->copy(pobj_Reloc);
	151
	152	//リテラル演算の場合を考慮した演算前のスタックフレームスケジュール位置
	153	int Before_StackFrameScheduleNum;
	154	Before_StackFrameScheduleNum=pobj_sf->num;
	155
	156	double dbl;
	157	int sp;
	158	int type[255];
	159	LONG_PTR index_stack[255];
	160	BOOL bUseHeap[255];
	161	_int64 i64data;
	162	int UseReg,XmmReg;
	163	BOOL bXmm;
	164	for(i=0,sp=0;i<pnum;i++){
	165	int idCalc;
	166	idCalc=calc[i]%100;
	167
	168	if(idCalc){
	169	if(type[sp-2]==DEF_OBJECT){
	170	//オーバーロードされたオペレータを呼び出す
	171	TYPEINFO BaseTypeInfo={BaseType,lpBaseIndex};
	172	i2=CallOperatorProc(idCalc,&BaseTypeInfo,type,index_stack,bUseHeap,sp);
	173	if(i2==0){
	174	if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
	175	else GetCalcName(idCalc,temp2);
	176	sprintf(temporary,"Operator %s",temp2);
	177	SetError(27,temporary,cp);
	178	goto error;
	179	}
	180	else if(i2==-1) goto error;
	181
	182	continue;
	183	}
	184
	185	if(!CheckCalcType(idCalc,type,sp)) goto error;
	186	}
	187
	188	switch(idCalc){
	189	//数値
	190	case 0:
	191	index_stack[sp]=-1;
	192	bUseHeap[sp]=0;
	193
	194	UseReg=pobj_reg->GetNextReg();
	195	XmmReg=pobj_reg->GetNextXmmReg();
	196
	197	bXmm=0;
	198
	199	char *term;
	200	term=values[i];
	201
	202	if(term[0]=='\"'){
	203	//リテラル文字列
	204	if(!RemoveStringQuotes(term)){
	205	SetError(43,NULL,cp);
	206	goto error;
	207	}
	208	i3=lstrlen(term);
	209	StrLiteral:
	210
	211	if(BaseType==DEF_OBJECT){
	212	CClass *pobj_Class;
	213	pobj_Class=(CClass *)lpBaseIndex;
[35]	214	TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
	215	if(IsStringSubsituation(pobj_Class)
[64]	216	\|\| IsStringObjectType(BaseTypeInfo)){
[3]	217	//要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
	218
	219	//String型オブジェクトを生成
	220	NewStringObject(UseReg,term);
	221
	222	extern CClass *pobj_StringClass;
	223	type[sp]=DEF_OBJECT;
	224	index_stack[sp]=(LONG_PTR)pobj_StringClass;
	225	bUseHeap[sp]=1;
	226	bLiteralCalculation=0;
	227
	228	if(bXmm) pobj_reg->LockXmmReg();
	229	else pobj_reg->LockReg();
	230
	231	sp++;
	232	break;
	233	}
	234	}
	235
[64]	236	type[sp]=DEF_PTR_CHAR;
[3]	237	bLiteralCalculation=0;
	238
[56]	239	i2 = dataTable.AddString( term, i3 );
[3]	240
	241	//mov reg,i2
	242	op_mov_RV(sizeof(_int64),UseReg,i2);
	243	obp-=sizeof(long);
	244	pobj_DataTableSchedule->add();
	245	obp+=sizeof(long);
	246
	247	if(UseReg==REG_R14){
	248	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	249	pobj_sf->push(REG_R14);
	250	}
	251	}
	252	else if((term[0]=='e'\|\|term[0]=='E')&&
	253	(term[1]=='x'\|\|term[1]=='X')&&
	254	term[2]=='\"'){
	255	//拡張版リテラル文字列（エスケープシーケンス可能）
	256	if(!RemoveStringQuotes(term+2)){
	257	SetError(43,NULL,cp);
	258	goto error;
	259	}
	260	i3=FormatString_EscapeSequence(term+2);
	261	term+=2;
	262
	263	goto StrLiteral;
	264	}
	265	else if(IsVariableTopChar(term[0])\|\|
	266	term[0]=='*'\|\|
	267	(term[0]=='.'&&IsVariableTopChar(term[1]))){
	268	//////////////////
	269	// 何らかの識別子
	270
	271	//////////////////////////////////////
	272	// 関数（DLL、ユーザー定義、組み込み）
	273	//////////////////////////////////////
	274
	275	i2=GetCallProcName(term,temporary);
	276	if(term[i2]=='('){
	277	i4=GetStringInPare_RemovePare(temp2,term+i2+1);
	278
	279	int idProc;
	280	void *pInfo;
	281	idProc=GetProc(temporary,&pInfo);
	282
	283	if(idProc){
[49]	284	//閉じカッコ")"に続く文字がNULLでないとき
	285	if(term[i2+1+i4+1]!='\0'){
	286	if( term[i2+1+i4+1] == '.'
	287	\|\| term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
	288	goto NonProc;
	289	}
	290	else{
	291	SetError(42,NULL,cp);
	292	}
	293	}
[3]	294
	295
	296	//////////////////////////////////////////////////////
	297	///// レジスタ資源のバックアップ
	298	{ BACKUP_REGISTER_RESOURCE
	299	//////////////////////////////////////////////////////
	300
	301
	302	////////////////
	303	// 呼び出し
	304	////////////////
	305
	306	i2=CallProc(idProc,pInfo,temporary,temp2,&index_stack[sp]);
	307	if(i2==-1){
	308	//戻り値が存在しないとき
	309	for(i2=2;;i2++){
	310	if(term[i2]=='('\|\|term[i2]=='\0'){
	311	term[i2]=0;
	312	break;
	313	}
	314	}
	315	SetError(38,term,cp);
	316
	317	//レジスタ資源を復元
	318	RESTORE_REGISTER_RESOURCE
	319
	320	goto error;
	321	}
	322
	323
	324	/////////////////////
	325	// 戻り値の処理
	326	/////////////////////
	327
	328	//大きな型への暗黙の変換
	329	type[sp]=AutoBigCast(BaseType,i2);
	330	bLiteralCalculation=0;
	331
	332	SetUseRegFromRax(i2,UseReg,XmmReg);
	333
	334	if(IsRealNumberType(i2)) bXmm=1;
	335	else bXmm=0;
	336
	337	/////////////////////////////////////////////
	338	////// レジスタ資源を復元
	339	RESTORE_REGISTER_RESOURCE
	340	}////////////////////////////////////////////
	341
	342
	343	if(bXmm) pobj_reg->LockXmmReg();
	344	else pobj_reg->LockReg();
	345
[64]	346	if(i2==DEF_STRUCT){
	347	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
[3]	348	//※後にfreeする必要あり
	349	bUseHeap[sp]=1;
	350	}
	351
	352	sp++;
	353	break;
	354	}
	355	else if(GetConstCalcBuffer(temporary,temp2,temp3)){
	356	/////////////////////////
	357	// マクロ関数
	358	/////////////////////////
	359
	360	//閉じカッコ")"に続く文字がNULLでないときはエラーにする
	361	if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
	362
	363	//マクロ関数の場合
	364	i2=NumOpe(&UseReg,temp3,0,0,&index_stack[sp]);
	365
	366	if(!IS_LITERAL(index_stack[sp])){
	367	//リテラル値ではなかったとき
	368	bLiteralCalculation=0;
	369	}
	370
	371	type[sp]=i2;
	372
	373	if(IsRealNumberType(i2)) pobj_reg->LockXmmReg();
	374	else pobj_reg->LockReg();
	375
	376	sp++;
	377	break;
	378	}
	379	}
[49]	380	NonProc:
[3]	381
	382
[38]	383	//インデクサ（getアクセサ）
[3]	384	char variable[VN_SIZE],array_element[VN_SIZE];
	385	CClass *pobj_c;
	386	GetArrayElement(term,variable,array_element);
	387	if(array_element[0]){
	388	i2=GetVarType(variable,(LONG_PTR *)&pobj_c,0);
	389	if(i2==DEF_OBJECT){
	390	TYPEINFO RetTypeInfo;
[38]	391	CallIndexerGetterProc(UseReg,pobj_c,variable,array_element,RetTypeInfo);
[3]	392	type[sp]=RetTypeInfo.type;
	393	index_stack[sp]=RetTypeInfo.u.lpIndex;
	394	bLiteralCalculation=0;
	395
	396	if(IsRealNumberType(RetTypeInfo.type)) pobj_reg->LockXmmReg();
	397	else pobj_reg->LockReg();
	398	sp++;
	399	break;
	400	}
	401	}
	402
	403
	404	RELATIVE_VAR RelativeVar;
[11]	405	if(GetVarOffset(
	406	false, //エラー表示あり
	407	false, //読み込み専用
	408	term,
	409	&i2,&RelativeVar,&index_stack[sp])){
[3]	410	//////////
	411	// 変数
	412	//////////
	413
	414	//大きな型への暗黙の変換
	415	type[sp]=AutoBigCast(BaseType,i2);
	416	bLiteralCalculation=0;
	417
	418	if(type[sp]!=i2){
	419	//大きな型へ変換された場合（レジスタを0に初期化する）
	420
	421	//xor reg,reg
	422	op_zero_reg(UseReg);
	423	}
	424
	425	if(i2&FLAG_PTR){
	426	//配列ポインタ
	427	type[sp]=GetPtrType(i2^FLAG_PTR,index_stack[sp]);
	428
	429	SetVarPtrToReg(UseReg,&RelativeVar);
	430	}
	431	else if(IsRealNumberType(i2)){
	432	//実数型
	433	bXmm=1;
	434
	435	if(i2==DEF_DOUBLE)
	436	SetXmmReg_DoubleVariable(&RelativeVar,XmmReg);
	437	if(i2==DEF_SINGLE)
	438	SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
	439	}
[64]	440	else if(IsWholeNumberType(i2) \|\| i2==DEF_OBJECT){
[3]	441	//整数型
	442	SetReg_WholeVariable(i2,&RelativeVar,UseReg);
	443	}
[64]	444	else if(i2==DEF_STRUCT){
	445	//構造体ポインタをUseRegへ格納（構造体は値型）
[3]	446	SetVarPtrToReg(UseReg,&RelativeVar);
	447	}
	448	else SetError(11,term,cp);
	449
	450	if(bXmm==0&&UseReg==REG_R14){
	451	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	452	pobj_sf->push(REG_R14);
	453	}
	454	if(bXmm&&XmmReg==REG_XMM4){
	455	if(i2==DEF_DOUBLE){
	456	//movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
	457	pobj_sf->push(REG_XMM4,sizeof(double));
	458	}
	459	if(i2==DEF_SINGLE){
	460	//movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
	461	pobj_sf->push(REG_XMM4,sizeof(float));
	462	}
	463	}
	464
	465	if(bXmm) pobj_reg->LockXmmReg();
	466	else pobj_reg->LockReg();
	467	sp++;
	468	break;
	469	}
	470
	471
	472	//////////////
	473	// 定数の場合
	474	//////////////
	475
[9]	476	i3 = CDBConst::obj.GetType(term);
	477	if(i3){
	478	type[sp] = i3;
[3]	479	if(IsRealNumberType(i3)){
	480	//実数
[9]	481	double dbl = CDBConst::obj.GetDoubleData(term);
[3]	482	memcpy(&i64data,&dbl,sizeof(double));
	483	goto Literal;
	484	}
	485	else if(IsWholeNumberType(i3)){
	486	//整数
[9]	487	i64data = CDBConst::obj.GetWholeData(term);
[3]	488	goto Literal;
	489	}
[9]	490	/*else if(i3==DEF_STRING){
[3]	491	//リテラル文字列
	492
	493	//バイト数
	494	i3=(int)dbl;
	495
	496	memcpy(term,temporary,i3);
	497	goto StrLiteral;
[9]	498	}*/
[3]	499	else{
	500	SetError(1,NULL,0);
	501	goto error;
	502	}
	503	}
	504
	505
[9]	506
[3]	507	//////////////
	508	// 型名の場合
	509	//////////////
	510
	511	LONG_PTR lp;
	512	i3=GetTypeFixed(term,&lp);
	513	if(i3!=-1){
	514	type[sp]=i3\|FLAG_CAST;
	515	index_stack[sp]=lp;
	516	sp++;
	517	break;
	518	}
	519
	520
	521
	522	/////////////////////////////////
	523	// プロパティ用のメソッド
	524	/////////////////////////////////
	525
	526	//配列要素を排除
	527	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
	528	GetArrayElement(term,VarName,ArrayElements);
	529
	530	if(GetSubHash(VarName,0)){
	531
	532	//////////////////////////////////////////////////////
	533	///// レジスタ資源のバックアップ
	534	{ BACKUP_REGISTER_RESOURCE
	535	//////////////////////////////////////////////////////
	536
	537	TYPEINFO RetTypeInfo;
	538	CallPropertyMethod(term,NULL,&RetTypeInfo);
	539
	540	//大きな型への暗黙の変換
	541	type[sp]=AutoBigCast(BaseType,RetTypeInfo.type);
	542
	543	index_stack[sp]=RetTypeInfo.u.lpIndex;
	544	bLiteralCalculation=0;
	545
	546	SetUseRegFromRax(RetTypeInfo.type,UseReg,XmmReg);
	547
[19]	548	if(IsRealNumberType(type[sp])) bXmm=1;
[3]	549	else bXmm=0;
	550
	551	/////////////////////////////////////////////
	552	////// レジスタ資源を復元
	553	RESTORE_REGISTER_RESOURCE
	554	}////////////////////////////////////////////
	555
[64]	556	if(type[sp]==DEF_STRUCT){
	557	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
[3]	558	//※後にfreeする必要あり
	559	bUseHeap[sp]=1;
	560	}
	561
	562	if(bXmm) pobj_reg->LockXmmReg();
	563	else pobj_reg->LockReg();
	564	sp++;
	565	break;
	566	}
	567
	568
	569
	570	//該当する識別子が見当たらないときはエラー扱いにする
	571	bError=1;
	572	SetError(3,term,cp);
	573	type[sp]=DEF_DOUBLE;
	574	}
	575	else{
	576	//リテラル値
	577	type[sp]=GetLiteralValue(term,&i64data,BaseType);
	578	Literal:
	579	if(type[sp]==DEF_DOUBLE){
	580	//64ビット浮動小数型
	581	bXmm=1;
	582
	583	if(XmmReg==REG_XMM4){
	584	//mov r14,i64data
	585	op_mov64_ToReg(REG_R14,i64data);
	586
	587
	588	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	589	pobj_sf->push(REG_R14);
	590	}
	591	else{
[56]	592	i3 = dataTable.Add( i64data );
[3]	593
	594	//movlpd xmm_reg,qword ptr[data table offset]
	595	OpBuffer[obp++]=(char)0x66;
	596	OpBuffer[obp++]=(char)0x0F;
	597	OpBuffer[obp++]=(char)0x12;
	598	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
	599	OpBuffer[obp++]=(char)0x25;
	600	((long )(OpBuffer+obp))=i3;
	601	pobj_DataTableSchedule->add();
	602	obp+=sizeof(long);
	603	}
	604	}
	605	else if(type[sp]==DEF_SINGLE){
	606	//32ビット浮動小数型
	607	bXmm=1;
	608
	609	float flt;
	610	int i32data;
	611	memcpy(&dbl,&i64data,sizeof(double));
	612	flt=(float)dbl;
	613	memcpy(&i32data,&flt,sizeof(long));
	614
	615	if(XmmReg==REG_XMM4){
	616	//push term
	617	op_push_value(i32data);
	618	}
	619	else{
[56]	620	i3=dataTable.Add( i32data );
[3]	621
	622	//movss xmm_reg,dword ptr[data table offset]
	623	OpBuffer[obp++]=(char)0xF3;
	624	OpBuffer[obp++]=(char)0x0F;
	625	OpBuffer[obp++]=(char)0x10;
	626	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
	627	OpBuffer[obp++]=(char)0x25;
	628	((long )(OpBuffer+obp))=i3;
	629	pobj_DataTableSchedule->add();
	630	obp+=sizeof(long);
	631	}
	632	}
	633	else{
	634	//整数
	635
	636	index_stack[sp]=GetLiteralIndex(i64data);
	637
	638	//mov reg,i64data
	639	op_mov64_ToReg(UseReg,i64data);
	640
	641	if(UseReg==REG_R14){
	642	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
	643	pobj_sf->push(REG_R14);
	644	}
	645	}
	646	}
	647
	648	if(bXmm) pobj_reg->LockXmmReg();
	649	else pobj_reg->LockReg();
	650
	651	sp++;
	652	break;
	653
	654	//論理演算子
	655	case CALC_XOR:
	656	case CALC_OR:
	657	case CALC_AND:
	658	if(!CalcTwoTerm_Logical(idCalc,type,index_stack,&sp)) goto error;
	659	break;
	660	case CALC_NOT:
	661	//value[sp-1]=Not value[sp-1]
	662	//NOT演算子
	663	if(!Calc_Not(type,sp)) goto error;
	664	break;
	665
	666	//比較演算子
	667	case CALC_PE: //value[sp-2] <= value[sp-1]
	668	case CALC_QE: //value[sp-2] >= value[sp-1]
	669	case CALC_P: //value[sp-2] < value[sp-1]
	670	case CALC_Q: //value[sp-2] > value[sp-1]
	671	case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
	672	case CALC_EQUAL: //value[sp-2] = value[sp-1]
	673	if(!CalcTwoTerm_Relational(idCalc,type,index_stack,&sp)) goto error;
	674	break;
	675
	676	//ビットシフト
	677	case CALC_SHL: //value[sp-2] << value[sp-1]
	678	case CALC_SHR: //value[sp-2] >> value[sp-1]
	679	if(!Calc_Shift(idCalc,type,&sp)) goto error;
	680	break;
	681
	682	//算術演算
	683	case CALC_ADDITION:
	684	case CALC_SUBTRACTION:
	685	case CALC_PRODUCT:
	686	if(!CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp)) goto error;
	687	break;
	688	case CALC_MOD:
	689	//value[sp-2]%=value[sp-1]
	690	//剰余演算
	691	if(!Calc_Mod(type,index_stack,&sp)) goto error;
	692	break;
	693	case CALC_QUOTIENT:
	694	//value[sp-2]/=value[sp-1];
	695	//除算
	696	if(!Calc_Divide(type,&sp,BaseType)) goto error;
	697	break;
	698	case CALC_INTQUOTIENT:
	699	//value[sp-2]/=value[sp-1]
	700	//整数除算
	701	if(!Calc_IntDivide(type,index_stack,&sp)) goto error;
	702	break;
	703	case CALC_MINUSMARK:
	704	//value[sp-1]=-value[sp-1]
	705	//符号反転
	706	if(!Calc_MinusMark(type,sp)) goto error;
	707	break;
	708	case CALC_POWER:
	709	//べき乗演算（浮動小数点演算のみ）
	710	if(!Calc_Power(type,&sp)) goto error;
	711	break;
	712	case CALC_AS:
	713	//キャスト
	714	if(!Calc_Cast(type,index_stack,&sp)) goto error;
	715	break;
[41]	716	case CALC_BYVAL:
	717	//ポインタ型→参照型
	718	if( PTR_LEVEL( type[sp-1] ) <= 0 ){
	719	//ポインタ型ではないとき
	720	SetError( 3, NULL, cp );
	721	goto error;
	722	}
[3]	723
[41]	724	type[sp-1] = PTR_LEVEL_DOWN( type[sp-1] );
	725
	726	break;
	727
[3]	728	default:
	729	SetError(300,NULL,cp);
[41]	730	goto error;
[3]	731	}
	732	}
	733
	734	if(bError) goto error;
	735
	736	if(sp!=1){
	737	SetError(1,NULL,cp);
	738	goto error;
	739	}
	740
	741	if(bLiteralCalculation){
	742	//右辺値が数値の定数式の場合
	743	LONG_PTR lpClassIndex;
	744	i2=StaticCalculation(true, Command,BaseType,&i64data,&lpClassIndex);
	745
	746	obp=BeforeObp;
	747	pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
	748	pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
	749	pobj_Reloc->copy(pobj_BackReloc);
	750	pobj_sf->num=Before_StackFrameScheduleNum;
	751	*pobj_reg=objReg_Backup;
	752
	753	if(IsRealNumberType(i2)){
	754	if(IsRealNumberType(BaseType)) i2=BaseType;
	755
	756	XmmReg=pobj_reg->LockXmmReg();
	757
	758	if(i2==DEF_DOUBLE){
[56]	759	i3 = dataTable.Add( i64data );
[3]	760
	761	//movlpd xmm_reg,qword ptr[data table offset]
	762	OpBuffer[obp++]=(char)0x66;
	763	OpBuffer[obp++]=(char)0x0F;
	764	OpBuffer[obp++]=(char)0x12;
	765	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
	766	OpBuffer[obp++]=(char)0x25;
	767	((long )(OpBuffer+obp))=i3;
	768	pobj_DataTableSchedule->add();
	769	obp+=sizeof(long);
	770	}
	771	if(i2==DEF_SINGLE){
	772	memcpy(&dbl,&i64data,sizeof(_int64));
	773
	774	float flt;
	775	int i32data;
	776	flt=(float)dbl;
	777	memcpy(&i32data,&flt,sizeof(long));
	778
[56]	779	i3 = dataTable.Add( i32data );
[3]	780
	781	//movss xmm_reg,dword ptr[data table offset]
	782	OpBuffer[obp++]=(char)0xF3;
	783	OpBuffer[obp++]=(char)0x0F;
	784	OpBuffer[obp++]=(char)0x10;
	785	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
	786	OpBuffer[obp++]=(char)0x25;
	787	((long )(OpBuffer+obp))=i3;
	788	pobj_DataTableSchedule->add();
	789	obp+=sizeof(long);
	790	}
	791	}
	792	else{
	793	if(!Is64Type(i2)){
	794	//整数（符号有り/無し）
	795
	796	i3=(long)i64data;
	797
	798	if(GetTypeSize(i2,-1)==sizeof(char)) i3=i3&0x000000FF;
	799	if(GetTypeSize(i2,-1)==sizeof(short)) i3=i3&0x0000FFFF;
	800
	801	i64data=(_int64)i3;
	802	}
	803
	804	UseReg=pobj_reg->LockReg();
	805
	806	//mov reg,i64data
	807	op_mov64_ToReg(UseReg,i64data);
	808	}
	809
	810	type[0]=i2;
	811	index_stack[0]=lpClassIndex;
	812	}
	813	else{
	814	//右辺値が数値の定数式ではないとき
	815	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
	816	}
	817
	818	if(plpIndex) *plpIndex=index_stack[0];
	819	if(pbUseHeap) *pbUseHeap=bUseHeap[0];
	820
	821	if(IsRealNumberType(type[0]))
	822	*pReg=pobj_reg->UnlockXmmReg();
	823	else
	824	*pReg=pobj_reg->UnlockReg();
	825
	826
	827	if(bInitRegSwitch){
	828	//整合性をチェック（バグ回避）
	829	pobj_reg->bug_check();
	830
	831	//作業レジスタを解放
	832	delete pobj_reg;
	833	pobj_reg=0;
	834	}
	835
	836	int RetType;
	837	RetType=type[0];
	838	goto finish;
	839
	840
	841
	842	//////////////////
	843	// エラー処理
	844	//////////////////
	845
	846	error:
	847
	848	*pobj_reg=objReg_Backup;
	849
	850	if(bInitRegSwitch){
	851	//作業レジスタを解放
	852	delete pobj_reg;
	853	pobj_reg=0;
	854	}
	855
	856	RetType=-1;
	857	goto finish;
	858
	859
	860
	861
	862	finish:
	863
	864	for(i=0;i<pnum;i++){
	865	if(values[i]) HeapDefaultFree(values[i]);
	866	}
	867
	868	//再配置スケジュールバックアップ情報を解放
	869	delete pobj_BackReloc;
	870
	871	return RetType;
	872	}

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

Download in other formats: