Context Navigation

source: dev/BasicCompiler64/NumOpe.cpp@ 67

Last change on this file since 67 was 67, checked in by dai_9181, 17 years ago
[32bit Compiler]op_push_value → op_push_V Nothingに対応。
File size: 21.4 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	char parameter = (char )malloc( lstrlen( lpszText ) + 3 );
17	lstrcpy( parameter, lpszText );
18	SetStringQuotes( parameter );
19
20	extern CClass *pobj_StringClass;
21	TYPEINFO baseTypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
22	Operator_New( *pobj_StringClass, "", parameter, baseTypeInfo );
23
24	free( parameter );
25
26	//mov reg,rax
27	op_mov_RR( reg, REG_RAX );
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
67	op_mov_RR(UseReg,REG_RAX);
68	}
69	}
70	}
71
72	int NumOpe(int pReg,const char Command,int BaseType,LONG_PTR lpBaseIndex,LONG_PTR plpIndex,BOOL pbUseHeap){
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
82	if(Command[0]==1&& Command[1]==ESC_NEW ){
83	//New演算子（オブジェクト生成）
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;
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;
214	TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
215	if(IsStringSubsituation(pobj_Class)
216	\|\| IsStringObjectType(BaseTypeInfo)){
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
236	type[sp]=DEF_PTR_CHAR;
237	bLiteralCalculation=0;
238
239	i2 = dataTable.AddString( term, i3 );
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){
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	}
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
346	if(i2==DEF_STRUCT){
347	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
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	}
380	NonProc:
381
382
383	//インデクサ（getアクセサ）
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;
391	CallIndexerGetterProc(UseReg,pobj_c,variable,array_element,RetTypeInfo);
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	// Nothing
405	if( lstrcmp( term, "Nothing" ) == 0 ){
406	type[sp] = DEF_OBJECT;
407	if( BaseType == DEF_OBJECT ){
408	index_stack[sp] = lpBaseIndex;
409	}
410	else{
411	index_stack[sp] = (LONG_PTR)pobj_DBClass->GetObjectClass();
412	}
413
414	bLiteralCalculation = 0;
415
416	//xor reg,reg
417	op_zero_reg( UseReg );
418
419	if(UseReg==REG_R14){
420	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
421	pobj_sf->push(REG_R14);
422	}
423
424	pobj_reg->LockReg();
425	sp++;
426	break;
427	}
428
429
430	RELATIVE_VAR RelativeVar;
431	if(GetVarOffset(
432	false, //エラー表示あり
433	false, //読み込み専用
434	term,
435	&i2,&RelativeVar,&index_stack[sp])){
436	//////////
437	// 変数
438	//////////
439
440	//大きな型への暗黙の変換
441	type[sp]=AutoBigCast(BaseType,i2);
442	bLiteralCalculation=0;
443
444	if(type[sp]!=i2){
445	//大きな型へ変換された場合（レジスタを0に初期化する）
446
447	//xor reg,reg
448	op_zero_reg(UseReg);
449	}
450
451	if(i2&FLAG_PTR){
452	//配列ポインタ
453	type[sp]=GetPtrType(i2^FLAG_PTR,index_stack[sp]);
454
455	SetVarPtrToReg(UseReg,&RelativeVar);
456	}
457	else if(IsRealNumberType(i2)){
458	//実数型
459	bXmm=1;
460
461	if(i2==DEF_DOUBLE)
462	SetXmmReg_DoubleVariable(&RelativeVar,XmmReg);
463	if(i2==DEF_SINGLE)
464	SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
465	}
466	else if(IsWholeNumberType(i2) \|\| i2==DEF_OBJECT){
467	//整数型
468	SetReg_WholeVariable(i2,&RelativeVar,UseReg);
469	}
470	else if(i2==DEF_STRUCT){
471	//構造体ポインタをUseRegへ格納（構造体は値型）
472	SetVarPtrToReg(UseReg,&RelativeVar);
473	}
474	else SetError(11,term,cp);
475
476	if(bXmm==0&&UseReg==REG_R14){
477	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
478	pobj_sf->push(REG_R14);
479	}
480	if(bXmm&&XmmReg==REG_XMM4){
481	if(i2==DEF_DOUBLE){
482	//movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
483	pobj_sf->push(REG_XMM4,sizeof(double));
484	}
485	if(i2==DEF_SINGLE){
486	//movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
487	pobj_sf->push(REG_XMM4,sizeof(float));
488	}
489	}
490
491	if(bXmm) pobj_reg->LockXmmReg();
492	else pobj_reg->LockReg();
493	sp++;
494	break;
495	}
496
497
498	//////////////
499	// 定数の場合
500	//////////////
501
502	i3 = CDBConst::obj.GetType(term);
503	if(i3){
504	type[sp] = i3;
505	if(IsRealNumberType(i3)){
506	//実数
507	double dbl = CDBConst::obj.GetDoubleData(term);
508	memcpy(&i64data,&dbl,sizeof(double));
509	goto Literal;
510	}
511	else if(IsWholeNumberType(i3)){
512	//整数
513	i64data = CDBConst::obj.GetWholeData(term);
514	goto Literal;
515	}
516	/*else if(i3==DEF_STRING){
517	//リテラル文字列
518
519	//バイト数
520	i3=(int)dbl;
521
522	memcpy(term,temporary,i3);
523	goto StrLiteral;
524	}*/
525	else{
526	SetError(1,NULL,0);
527	goto error;
528	}
529	}
530
531
532
533	//////////////
534	// 型名の場合
535	//////////////
536
537	LONG_PTR lp;
538	i3=GetTypeFixed(term,&lp);
539	if(i3!=-1){
540	type[sp]=i3\|FLAG_CAST;
541	index_stack[sp]=lp;
542	sp++;
543	break;
544	}
545
546
547
548	/////////////////////////////////
549	// プロパティ用のメソッド
550	/////////////////////////////////
551
552	//配列要素を排除
553	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
554	GetArrayElement(term,VarName,ArrayElements);
555
556	if(GetSubHash(VarName,0)){
557
558	//////////////////////////////////////////////////////
559	///// レジスタ資源のバックアップ
560	{ BACKUP_REGISTER_RESOURCE
561	//////////////////////////////////////////////////////
562
563	TYPEINFO RetTypeInfo;
564	CallPropertyMethod(term,NULL,&RetTypeInfo);
565
566	//大きな型への暗黙の変換
567	type[sp]=AutoBigCast(BaseType,RetTypeInfo.type);
568
569	index_stack[sp]=RetTypeInfo.u.lpIndex;
570	bLiteralCalculation=0;
571
572	SetUseRegFromRax(RetTypeInfo.type,UseReg,XmmReg);
573
574	if(IsRealNumberType(type[sp])) bXmm=1;
575	else bXmm=0;
576
577	/////////////////////////////////////////////
578	////// レジスタ資源を復元
579	RESTORE_REGISTER_RESOURCE
580	}////////////////////////////////////////////
581
582	if(type[sp]==DEF_STRUCT){
583	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
584	//※後にfreeする必要あり
585	bUseHeap[sp]=1;
586	}
587
588	if(bXmm) pobj_reg->LockXmmReg();
589	else pobj_reg->LockReg();
590	sp++;
591	break;
592	}
593
594
595
596	//該当する識別子が見当たらないときはエラー扱いにする
597	bError=1;
598	SetError(3,term,cp);
599	type[sp]=DEF_DOUBLE;
600	}
601	else{
602	//リテラル値
603	type[sp]=GetLiteralValue(term,&i64data,BaseType);
604	Literal:
605	if(type[sp]==DEF_DOUBLE){
606	//64ビット浮動小数型
607	bXmm=1;
608
609	if(XmmReg==REG_XMM4){
610	//mov r14,i64data
611	op_mov64_ToReg(REG_R14,i64data);
612
613
614	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
615	pobj_sf->push(REG_R14);
616	}
617	else{
618	i3 = dataTable.Add( i64data );
619
620	//movlpd xmm_reg,qword ptr[data table offset]
621	OpBuffer[obp++]=(char)0x66;
622	OpBuffer[obp++]=(char)0x0F;
623	OpBuffer[obp++]=(char)0x12;
624	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
625	OpBuffer[obp++]=(char)0x25;
626	((long )(OpBuffer+obp))=i3;
627	pobj_DataTableSchedule->add();
628	obp+=sizeof(long);
629	}
630	}
631	else if(type[sp]==DEF_SINGLE){
632	//32ビット浮動小数型
633	bXmm=1;
634
635	float flt;
636	int i32data;
637	memcpy(&dbl,&i64data,sizeof(double));
638	flt=(float)dbl;
639	memcpy(&i32data,&flt,sizeof(long));
640
641	if(XmmReg==REG_XMM4){
642	//push term
643	op_push_value(i32data);
644	}
645	else{
646	i3=dataTable.Add( i32data );
647
648	//movss xmm_reg,dword ptr[data table offset]
649	OpBuffer[obp++]=(char)0xF3;
650	OpBuffer[obp++]=(char)0x0F;
651	OpBuffer[obp++]=(char)0x10;
652	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
653	OpBuffer[obp++]=(char)0x25;
654	((long )(OpBuffer+obp))=i3;
655	pobj_DataTableSchedule->add();
656	obp+=sizeof(long);
657	}
658	}
659	else{
660	//整数
661
662	index_stack[sp]=GetLiteralIndex(i64data);
663
664	//mov reg,i64data
665	op_mov64_ToReg(UseReg,i64data);
666
667	if(UseReg==REG_R14){
668	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
669	pobj_sf->push(REG_R14);
670	}
671	}
672	}
673
674	if(bXmm) pobj_reg->LockXmmReg();
675	else pobj_reg->LockReg();
676
677	sp++;
678	break;
679
680	//論理演算子
681	case CALC_XOR:
682	case CALC_OR:
683	case CALC_AND:
684	if(!CalcTwoTerm_Logical(idCalc,type,index_stack,&sp)) goto error;
685	break;
686	case CALC_NOT:
687	//value[sp-1]=Not value[sp-1]
688	//NOT演算子
689	if(!Calc_Not(type,sp)) goto error;
690	break;
691
692	//比較演算子
693	case CALC_PE: //value[sp-2] <= value[sp-1]
694	case CALC_QE: //value[sp-2] >= value[sp-1]
695	case CALC_P: //value[sp-2] < value[sp-1]
696	case CALC_Q: //value[sp-2] > value[sp-1]
697	case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
698	case CALC_EQUAL: //value[sp-2] = value[sp-1]
699	if(!CalcTwoTerm_Relational(idCalc,type,index_stack,&sp)) goto error;
700	break;
701
702	//ビットシフト
703	case CALC_SHL: //value[sp-2] << value[sp-1]
704	case CALC_SHR: //value[sp-2] >> value[sp-1]
705	if(!Calc_Shift(idCalc,type,&sp)) goto error;
706	break;
707
708	//算術演算
709	case CALC_ADDITION:
710	case CALC_SUBTRACTION:
711	case CALC_PRODUCT:
712	if(!CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp)) goto error;
713	break;
714	case CALC_MOD:
715	//value[sp-2]%=value[sp-1]
716	//剰余演算
717	if(!Calc_Mod(type,index_stack,&sp)) goto error;
718	break;
719	case CALC_QUOTIENT:
720	//value[sp-2]/=value[sp-1];
721	//除算
722	if(!Calc_Divide(type,&sp,BaseType)) goto error;
723	break;
724	case CALC_INTQUOTIENT:
725	//value[sp-2]/=value[sp-1]
726	//整数除算
727	if(!Calc_IntDivide(type,index_stack,&sp)) goto error;
728	break;
729	case CALC_MINUSMARK:
730	//value[sp-1]=-value[sp-1]
731	//符号反転
732	if(!Calc_MinusMark(type,sp)) goto error;
733	break;
734	case CALC_POWER:
735	//べき乗演算（浮動小数点演算のみ）
736	if(!Calc_Power(type,&sp)) goto error;
737	break;
738	case CALC_AS:
739	//キャスト
740	if(!Calc_Cast(type,index_stack,&sp)) goto error;
741	break;
742	case CALC_BYVAL:
743	//ポインタ型→参照型
744	if( PTR_LEVEL( type[sp-1] ) <= 0 ){
745	//ポインタ型ではないとき
746	SetError( 3, NULL, cp );
747	goto error;
748	}
749
750	type[sp-1] = PTR_LEVEL_DOWN( type[sp-1] );
751
752	break;
753
754	default:
755	SetError(300,NULL,cp);
756	goto error;
757	}
758	}
759
760	if(bError) goto error;
761
762	if(sp!=1){
763	SetError(1,NULL,cp);
764	goto error;
765	}
766
767	if(bLiteralCalculation){
768	//右辺値が数値の定数式の場合
769	LONG_PTR lpClassIndex;
770	i2=StaticCalculation(true, Command,BaseType,&i64data,&lpClassIndex);
771
772	obp=BeforeObp;
773	pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
774	pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
775	pobj_Reloc->copy(pobj_BackReloc);
776	pobj_sf->num=Before_StackFrameScheduleNum;
777	*pobj_reg=objReg_Backup;
778
779	if(IsRealNumberType(i2)){
780	if(IsRealNumberType(BaseType)) i2=BaseType;
781
782	XmmReg=pobj_reg->LockXmmReg();
783
784	if(i2==DEF_DOUBLE){
785	i3 = dataTable.Add( i64data );
786
787	//movlpd xmm_reg,qword ptr[data table offset]
788	OpBuffer[obp++]=(char)0x66;
789	OpBuffer[obp++]=(char)0x0F;
790	OpBuffer[obp++]=(char)0x12;
791	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
792	OpBuffer[obp++]=(char)0x25;
793	((long )(OpBuffer+obp))=i3;
794	pobj_DataTableSchedule->add();
795	obp+=sizeof(long);
796	}
797	if(i2==DEF_SINGLE){
798	memcpy(&dbl,&i64data,sizeof(_int64));
799
800	float flt;
801	int i32data;
802	flt=(float)dbl;
803	memcpy(&i32data,&flt,sizeof(long));
804
805	i3 = dataTable.Add( i32data );
806
807	//movss xmm_reg,dword ptr[data table offset]
808	OpBuffer[obp++]=(char)0xF3;
809	OpBuffer[obp++]=(char)0x0F;
810	OpBuffer[obp++]=(char)0x10;
811	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
812	OpBuffer[obp++]=(char)0x25;
813	((long )(OpBuffer+obp))=i3;
814	pobj_DataTableSchedule->add();
815	obp+=sizeof(long);
816	}
817	}
818	else{
819	if(!Is64Type(i2)){
820	//整数（符号有り/無し）
821
822	i3=(long)i64data;
823
824	if(GetTypeSize(i2,-1)==sizeof(char)) i3=i3&0x000000FF;
825	if(GetTypeSize(i2,-1)==sizeof(short)) i3=i3&0x0000FFFF;
826
827	i64data=(_int64)i3;
828	}
829
830	UseReg=pobj_reg->LockReg();
831
832	//mov reg,i64data
833	op_mov64_ToReg(UseReg,i64data);
834	}
835
836	type[0]=i2;
837	index_stack[0]=lpClassIndex;
838	}
839	else{
840	//右辺値が数値の定数式ではないとき
841	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
842	}
843
844	if(plpIndex) *plpIndex=index_stack[0];
845	if(pbUseHeap) *pbUseHeap=bUseHeap[0];
846
847	if(IsRealNumberType(type[0]))
848	*pReg=pobj_reg->UnlockXmmReg();
849	else
850	*pReg=pobj_reg->UnlockReg();
851
852
853	if(bInitRegSwitch){
854	//整合性をチェック（バグ回避）
855	pobj_reg->bug_check();
856
857	//作業レジスタを解放
858	delete pobj_reg;
859	pobj_reg=0;
860	}
861
862	int RetType;
863	RetType=type[0];
864	goto finish;
865
866
867
868	//////////////////
869	// エラー処理
870	//////////////////
871
872	error:
873
874	*pobj_reg=objReg_Backup;
875
876	if(bInitRegSwitch){
877	//作業レジスタを解放
878	delete pobj_reg;
879	pobj_reg=0;
880	}
881
882	RetType=-1;
883	goto finish;
884
885
886
887
888	finish:
889
890	for(i=0;i<pnum;i++){
891	if(values[i]) HeapDefaultFree(values[i]);
892	}
893
894	//再配置スケジュールバックアップ情報を解放
895	delete pobj_BackReloc;
896
897	return RetType;
898	}

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

Download in other formats: