Context Navigation

source: dev/BasicCompiler64/NumOpe.cpp@ 69

Last change on this file since 69 was 69, checked in by dai_9181, 17 years ago
一時文字列をNewしたときに、bUseHeapフラグを立たせないようにした（bUseHeapが立つのは一時構造体のときのみ）。 DEF_PTR_CHARを廃止し、typeOfPtrCharを導入。
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 ) + 32 );
17	sprintf( parameter, "\"%s\"%c%c*Char", lpszText, 1, ESC_AS );
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(IsStringObjectType(BaseTypeInfo)){
216	//要求タイプがStringのとき
217
218	//String型オブジェクトを生成
219	NewStringObject(UseReg,term);
220
221	extern CClass *pobj_StringClass;
222	type[sp]=DEF_OBJECT;
223	index_stack[sp]=(LONG_PTR)pobj_StringClass;
224	bLiteralCalculation=0;
225
226	if(bXmm) pobj_reg->LockXmmReg();
227	else pobj_reg->LockReg();
228
229	sp++;
230	break;
231	}
232	}
233
234	type[sp]=typeOfPtrChar;
235	bLiteralCalculation=0;
236
237	i2 = dataTable.AddString( term, i3 );
238
239	//mov reg,i2
240	op_mov_RV(sizeof(_int64),UseReg,i2);
241	obp-=sizeof(long);
242	pobj_DataTableSchedule->add();
243	obp+=sizeof(long);
244
245	if(UseReg==REG_R14){
246	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
247	pobj_sf->push(REG_R14);
248	}
249	}
250	else if((term[0]=='e'\|\|term[0]=='E')&&
251	(term[1]=='x'\|\|term[1]=='X')&&
252	term[2]=='\"'){
253	//拡張版リテラル文字列（エスケープシーケンス可能）
254	if(!RemoveStringQuotes(term+2)){
255	SetError(43,NULL,cp);
256	goto error;
257	}
258	i3=FormatString_EscapeSequence(term+2);
259	term+=2;
260
261	goto StrLiteral;
262	}
263	else if(IsVariableTopChar(term[0])\|\|
264	term[0]=='*'\|\|
265	(term[0]=='.'&&IsVariableTopChar(term[1]))){
266	//////////////////
267	// 何らかの識別子
268
269	//////////////////////////////////////
270	// 関数（DLL、ユーザー定義、組み込み）
271	//////////////////////////////////////
272
273	i2=GetCallProcName(term,temporary);
274	if(term[i2]=='('){
275	i4=GetStringInPare_RemovePare(temp2,term+i2+1);
276
277	int idProc;
278	void *pInfo;
279	idProc=GetProc(temporary,&pInfo);
280
281	if(idProc){
282	//閉じカッコ")"に続く文字がNULLでないとき
283	if(term[i2+1+i4+1]!='\0'){
284	if( term[i2+1+i4+1] == '.'
285	\|\| term[i2+1+i4+1] == 1 && term[i2+1+i4+2] == ESC_PSMEM ){
286	goto NonProc;
287	}
288	else{
289	SetError(42,NULL,cp);
290	}
291	}
292
293
294	//////////////////////////////////////////////////////
295	///// レジスタ資源のバックアップ
296	{ BACKUP_REGISTER_RESOURCE
297	//////////////////////////////////////////////////////
298
299
300	////////////////
301	// 呼び出し
302	////////////////
303
304	i2=CallProc(idProc,pInfo,temporary,temp2,&index_stack[sp]);
305	if(i2==-1){
306	//戻り値が存在しないとき
307	for(i2=2;;i2++){
308	if(term[i2]=='('\|\|term[i2]=='\0'){
309	term[i2]=0;
310	break;
311	}
312	}
313	SetError(38,term,cp);
314
315	//レジスタ資源を復元
316	RESTORE_REGISTER_RESOURCE
317
318	goto error;
319	}
320
321
322	/////////////////////
323	// 戻り値の処理
324	/////////////////////
325
326	//大きな型への暗黙の変換
327	type[sp]=AutoBigCast(BaseType,i2);
328	bLiteralCalculation=0;
329
330	SetUseRegFromRax(i2,UseReg,XmmReg);
331
332	if(IsRealNumberType(i2)) bXmm=1;
333	else bXmm=0;
334
335	/////////////////////////////////////////////
336	////// レジスタ資源を復元
337	RESTORE_REGISTER_RESOURCE
338	}////////////////////////////////////////////
339
340
341	if(bXmm) pobj_reg->LockXmmReg();
342	else pobj_reg->LockReg();
343
344	if(i2==DEF_STRUCT){
345	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
346	//※後にfreeする必要あり
347	bUseHeap[sp]=1;
348	}
349
350	sp++;
351	break;
352	}
353	else if(GetConstCalcBuffer(temporary,temp2,temp3)){
354	/////////////////////////
355	// マクロ関数
356	/////////////////////////
357
358	//閉じカッコ")"に続く文字がNULLでないときはエラーにする
359	if(term[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
360
361	//マクロ関数の場合
362	i2=NumOpe(&UseReg,temp3,0,0,&index_stack[sp]);
363
364	if(!IS_LITERAL(index_stack[sp])){
365	//リテラル値ではなかったとき
366	bLiteralCalculation=0;
367	}
368
369	type[sp]=i2;
370
371	if(IsRealNumberType(i2)) pobj_reg->LockXmmReg();
372	else pobj_reg->LockReg();
373
374	sp++;
375	break;
376	}
377	}
378	NonProc:
379
380
381	//インデクサ（getアクセサ）
382	char variable[VN_SIZE],array_element[VN_SIZE];
383	CClass *pobj_c;
384	GetArrayElement(term,variable,array_element);
385	if(array_element[0]){
386	i2=GetVarType(variable,(LONG_PTR *)&pobj_c,0);
387	if(i2==DEF_OBJECT){
388	TYPEINFO RetTypeInfo;
389	CallIndexerGetterProc(UseReg,pobj_c,variable,array_element,RetTypeInfo);
390	type[sp]=RetTypeInfo.type;
391	index_stack[sp]=RetTypeInfo.u.lpIndex;
392	bLiteralCalculation=0;
393
394	if(IsRealNumberType(RetTypeInfo.type)) pobj_reg->LockXmmReg();
395	else pobj_reg->LockReg();
396	sp++;
397	break;
398	}
399	}
400
401
402	// Nothing
403	if( lstrcmp( term, "Nothing" ) == 0 ){
404	type[sp] = DEF_OBJECT;
405	if( BaseType == DEF_OBJECT ){
406	index_stack[sp] = lpBaseIndex;
407	}
408	else{
409	index_stack[sp] = (LONG_PTR)pobj_DBClass->GetObjectClass();
410	}
411
412	bLiteralCalculation = 0;
413
414	//xor reg,reg
415	op_zero_reg( UseReg );
416
417	if(UseReg==REG_R14){
418	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
419	pobj_sf->push(REG_R14);
420	}
421
422	pobj_reg->LockReg();
423	sp++;
424	break;
425	}
426
427
428	RELATIVE_VAR RelativeVar;
429	if(GetVarOffset(
430	false, //エラー表示あり
431	false, //読み込み専用
432	term,
433	&i2,&RelativeVar,&index_stack[sp])){
434	//////////
435	// 変数
436	//////////
437
438	//大きな型への暗黙の変換
439	type[sp]=AutoBigCast(BaseType,i2);
440	bLiteralCalculation=0;
441
442	if(type[sp]!=i2){
443	//大きな型へ変換された場合（レジスタを0に初期化する）
444
445	//xor reg,reg
446	op_zero_reg(UseReg);
447	}
448
449	if(i2&FLAG_PTR){
450	//配列ポインタ
451	type[sp]=GetPtrType(i2^FLAG_PTR,index_stack[sp]);
452
453	SetVarPtrToReg(UseReg,&RelativeVar);
454	}
455	else if(IsRealNumberType(i2)){
456	//実数型
457	bXmm=1;
458
459	if(i2==DEF_DOUBLE)
460	SetXmmReg_DoubleVariable(&RelativeVar,XmmReg);
461	if(i2==DEF_SINGLE)
462	SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
463	}
464	else if(IsWholeNumberType(i2) \|\| i2==DEF_OBJECT){
465	//整数型
466	SetReg_WholeVariable(i2,&RelativeVar,UseReg);
467	}
468	else if(i2==DEF_STRUCT){
469	//構造体ポインタをUseRegへ格納（構造体は値型）
470	SetVarPtrToReg(UseReg,&RelativeVar);
471	}
472	else SetError(11,term,cp);
473
474	if(bXmm==0&&UseReg==REG_R14){
475	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
476	pobj_sf->push(REG_R14);
477	}
478	if(bXmm&&XmmReg==REG_XMM4){
479	if(i2==DEF_DOUBLE){
480	//movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
481	pobj_sf->push(REG_XMM4,sizeof(double));
482	}
483	if(i2==DEF_SINGLE){
484	//movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
485	pobj_sf->push(REG_XMM4,sizeof(float));
486	}
487	}
488
489	if(bXmm) pobj_reg->LockXmmReg();
490	else pobj_reg->LockReg();
491	sp++;
492	break;
493	}
494
495
496	//////////////
497	// 定数の場合
498	//////////////
499
500	i3 = CDBConst::obj.GetType(term);
501	if(i3){
502	type[sp] = i3;
503	if(IsRealNumberType(i3)){
504	//実数
505	double dbl = CDBConst::obj.GetDoubleData(term);
506	memcpy(&i64data,&dbl,sizeof(double));
507	goto Literal;
508	}
509	else if(IsWholeNumberType(i3)){
510	//整数
511	i64data = CDBConst::obj.GetWholeData(term);
512	goto Literal;
513	}
514	/*else if(i3==DEF_STRING){
515	//リテラル文字列
516
517	//バイト数
518	i3=(int)dbl;
519
520	memcpy(term,temporary,i3);
521	goto StrLiteral;
522	}*/
523	else{
524	SetError(1,NULL,0);
525	goto error;
526	}
527	}
528
529
530
531	//////////////
532	// 型名の場合
533	//////////////
534
535	LONG_PTR lp;
536	i3=GetTypeFixed(term,&lp);
537	if(i3!=-1){
538	type[sp]=i3\|FLAG_CAST;
539	index_stack[sp]=lp;
540	sp++;
541	break;
542	}
543
544
545
546	/////////////////////////////////
547	// プロパティ用のメソッド
548	/////////////////////////////////
549
550	//配列要素を排除
551	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
552	GetArrayElement(term,VarName,ArrayElements);
553
554	if(GetSubHash(VarName,0)){
555
556	//////////////////////////////////////////////////////
557	///// レジスタ資源のバックアップ
558	{ BACKUP_REGISTER_RESOURCE
559	//////////////////////////////////////////////////////
560
561	TYPEINFO RetTypeInfo;
562	CallPropertyMethod(term,NULL,&RetTypeInfo);
563
564	//大きな型への暗黙の変換
565	type[sp]=AutoBigCast(BaseType,RetTypeInfo.type);
566
567	index_stack[sp]=RetTypeInfo.u.lpIndex;
568	bLiteralCalculation=0;
569
570	SetUseRegFromRax(RetTypeInfo.type,UseReg,XmmReg);
571
572	if(IsRealNumberType(type[sp])) bXmm=1;
573	else bXmm=0;
574
575	/////////////////////////////////////////////
576	////// レジスタ資源を復元
577	RESTORE_REGISTER_RESOURCE
578	}////////////////////////////////////////////
579
580	if(type[sp]==DEF_STRUCT){
581	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
582	//※後にfreeする必要あり
583	bUseHeap[sp]=1;
584	}
585
586	if(bXmm) pobj_reg->LockXmmReg();
587	else pobj_reg->LockReg();
588	sp++;
589	break;
590	}
591
592
593
594	//該当する識別子が見当たらないときはエラー扱いにする
595	bError=1;
596	SetError(3,term,cp);
597	type[sp]=DEF_DOUBLE;
598	}
599	else{
600	//リテラル値
601	type[sp]=GetLiteralValue(term,&i64data,BaseType);
602	Literal:
603	if(type[sp]==DEF_DOUBLE){
604	//64ビット浮動小数型
605	bXmm=1;
606
607	if(XmmReg==REG_XMM4){
608	//mov r14,i64data
609	op_mov64_ToReg(REG_R14,i64data);
610
611
612	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
613	pobj_sf->push(REG_R14);
614	}
615	else{
616	i3 = dataTable.Add( i64data );
617
618	//movlpd xmm_reg,qword ptr[data table offset]
619	OpBuffer[obp++]=(char)0x66;
620	OpBuffer[obp++]=(char)0x0F;
621	OpBuffer[obp++]=(char)0x12;
622	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
623	OpBuffer[obp++]=(char)0x25;
624	((long )(OpBuffer+obp))=i3;
625	pobj_DataTableSchedule->add();
626	obp+=sizeof(long);
627	}
628	}
629	else if(type[sp]==DEF_SINGLE){
630	//32ビット浮動小数型
631	bXmm=1;
632
633	float flt;
634	int i32data;
635	memcpy(&dbl,&i64data,sizeof(double));
636	flt=(float)dbl;
637	memcpy(&i32data,&flt,sizeof(long));
638
639	if(XmmReg==REG_XMM4){
640	//push term
641	op_push_value(i32data);
642	}
643	else{
644	i3=dataTable.Add( i32data );
645
646	//movss xmm_reg,dword ptr[data table offset]
647	OpBuffer[obp++]=(char)0xF3;
648	OpBuffer[obp++]=(char)0x0F;
649	OpBuffer[obp++]=(char)0x10;
650	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
651	OpBuffer[obp++]=(char)0x25;
652	((long )(OpBuffer+obp))=i3;
653	pobj_DataTableSchedule->add();
654	obp+=sizeof(long);
655	}
656	}
657	else{
658	//整数
659
660	index_stack[sp]=GetLiteralIndex(i64data);
661
662	//mov reg,i64data
663	op_mov64_ToReg(UseReg,i64data);
664
665	if(UseReg==REG_R14){
666	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
667	pobj_sf->push(REG_R14);
668	}
669	}
670	}
671
672	if(bXmm) pobj_reg->LockXmmReg();
673	else pobj_reg->LockReg();
674
675	sp++;
676	break;
677
678	//論理演算子
679	case CALC_XOR:
680	case CALC_OR:
681	case CALC_AND:
682	if(!CalcTwoTerm_Logical(idCalc,type,index_stack,&sp)) goto error;
683	break;
684	case CALC_NOT:
685	//value[sp-1]=Not value[sp-1]
686	//NOT演算子
687	if(!Calc_Not(type,sp)) goto error;
688	break;
689
690	//比較演算子
691	case CALC_PE: //value[sp-2] <= value[sp-1]
692	case CALC_QE: //value[sp-2] >= value[sp-1]
693	case CALC_P: //value[sp-2] < value[sp-1]
694	case CALC_Q: //value[sp-2] > value[sp-1]
695	case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
696	case CALC_EQUAL: //value[sp-2] = value[sp-1]
697	if(!CalcTwoTerm_Relational(idCalc,type,index_stack,&sp)) goto error;
698	break;
699
700	//ビットシフト
701	case CALC_SHL: //value[sp-2] << value[sp-1]
702	case CALC_SHR: //value[sp-2] >> value[sp-1]
703	if(!Calc_Shift(idCalc,type,&sp)) goto error;
704	break;
705
706	//算術演算
707	case CALC_ADDITION:
708	case CALC_SUBTRACTION:
709	case CALC_PRODUCT:
710	if(!CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp)) goto error;
711	break;
712	case CALC_MOD:
713	//value[sp-2]%=value[sp-1]
714	//剰余演算
715	if(!Calc_Mod(type,index_stack,&sp)) goto error;
716	break;
717	case CALC_QUOTIENT:
718	//value[sp-2]/=value[sp-1];
719	//除算
720	if(!Calc_Divide(type,&sp,BaseType)) goto error;
721	break;
722	case CALC_INTQUOTIENT:
723	//value[sp-2]/=value[sp-1]
724	//整数除算
725	if(!Calc_IntDivide(type,index_stack,&sp)) goto error;
726	break;
727	case CALC_MINUSMARK:
728	//value[sp-1]=-value[sp-1]
729	//符号反転
730	if(!Calc_MinusMark(type,sp)) goto error;
731	break;
732	case CALC_POWER:
733	//べき乗演算（浮動小数点演算のみ）
734	if(!Calc_Power(type,&sp)) goto error;
735	break;
736	case CALC_AS:
737	//キャスト
738	if(!Calc_Cast(type,index_stack,&sp)) goto error;
739	break;
740	case CALC_BYVAL:
741	//ポインタ型→参照型
742	if( PTR_LEVEL( type[sp-1] ) <= 0 ){
743	//ポインタ型ではないとき
744	SetError( 3, NULL, cp );
745	goto error;
746	}
747
748	type[sp-1] = PTR_LEVEL_DOWN( type[sp-1] );
749
750	break;
751
752	default:
753	SetError(300,NULL,cp);
754	goto error;
755	}
756	}
757
758	if(bError) goto error;
759
760	if(sp!=1){
761	SetError(1,NULL,cp);
762	goto error;
763	}
764
765	if(bLiteralCalculation){
766	//右辺値が数値の定数式の場合
767	LONG_PTR lpClassIndex;
768	i2=StaticCalculation(true, Command,BaseType,&i64data,&lpClassIndex);
769
770	obp=BeforeObp;
771	pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
772	pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
773	pobj_Reloc->copy(pobj_BackReloc);
774	pobj_sf->num=Before_StackFrameScheduleNum;
775	*pobj_reg=objReg_Backup;
776
777	if(IsRealNumberType(i2)){
778	if(IsRealNumberType(BaseType)) i2=BaseType;
779
780	XmmReg=pobj_reg->LockXmmReg();
781
782	if(i2==DEF_DOUBLE){
783	i3 = dataTable.Add( i64data );
784
785	//movlpd xmm_reg,qword ptr[data table offset]
786	OpBuffer[obp++]=(char)0x66;
787	OpBuffer[obp++]=(char)0x0F;
788	OpBuffer[obp++]=(char)0x12;
789	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
790	OpBuffer[obp++]=(char)0x25;
791	((long )(OpBuffer+obp))=i3;
792	pobj_DataTableSchedule->add();
793	obp+=sizeof(long);
794	}
795	if(i2==DEF_SINGLE){
796	memcpy(&dbl,&i64data,sizeof(_int64));
797
798	float flt;
799	int i32data;
800	flt=(float)dbl;
801	memcpy(&i32data,&flt,sizeof(long));
802
803	i3 = dataTable.Add( i32data );
804
805	//movss xmm_reg,dword ptr[data table offset]
806	OpBuffer[obp++]=(char)0xF3;
807	OpBuffer[obp++]=(char)0x0F;
808	OpBuffer[obp++]=(char)0x10;
809	OpBuffer[obp++]=(char)(0x04 \| REGISTER_OPERAND(XmmReg)<<3);
810	OpBuffer[obp++]=(char)0x25;
811	((long )(OpBuffer+obp))=i3;
812	pobj_DataTableSchedule->add();
813	obp+=sizeof(long);
814	}
815	}
816	else{
817	if(!Is64Type(i2)){
818	//整数（符号有り/無し）
819
820	i3=(long)i64data;
821
822	if(GetTypeSize(i2,-1)==sizeof(char)) i3=i3&0x000000FF;
823	if(GetTypeSize(i2,-1)==sizeof(short)) i3=i3&0x0000FFFF;
824
825	i64data=(_int64)i3;
826	}
827
828	UseReg=pobj_reg->LockReg();
829
830	//mov reg,i64data
831	op_mov64_ToReg(UseReg,i64data);
832	}
833
834	type[0]=i2;
835	index_stack[0]=lpClassIndex;
836	}
837	else{
838	//右辺値が数値の定数式ではないとき
839	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
840	}
841
842	if(plpIndex) *plpIndex=index_stack[0];
843	if(pbUseHeap) *pbUseHeap=bUseHeap[0];
844
845	if(IsRealNumberType(type[0]))
846	*pReg=pobj_reg->UnlockXmmReg();
847	else
848	*pReg=pobj_reg->UnlockReg();
849
850
851	if(bInitRegSwitch){
852	//整合性をチェック（バグ回避）
853	pobj_reg->bug_check();
854
855	//作業レジスタを解放
856	delete pobj_reg;
857	pobj_reg=0;
858	}
859
860	int RetType;
861	RetType=type[0];
862	goto finish;
863
864
865
866	//////////////////
867	// エラー処理
868	//////////////////
869
870	error:
871
872	*pobj_reg=objReg_Backup;
873
874	if(bInitRegSwitch){
875	//作業レジスタを解放
876	delete pobj_reg;
877	pobj_reg=0;
878	}
879
880	RetType=-1;
881	goto finish;
882
883
884
885
886	finish:
887
888	for(i=0;i<pnum;i++){
889	if(values[i]) HeapDefaultFree(values[i]);
890	}
891
892	//再配置スケジュールバックアップ情報を解放
893	delete pobj_BackReloc;
894
895	return RetType;
896	}

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

Download in other formats: