Context Navigation

source: dev/BasicCompiler64/NumOpe.cpp@ 68

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

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

Download in other formats: