Context Navigation

source: dev/BasicCompiler64/NumOpe.cpp@ 35

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

File size: 21.2 KB

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

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

Download in other formats: