Context Navigation

source: dev/trunk/abdev/BasicCompiler64/NumOpe.cpp@ 253

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

File size: 30.5 KB

Line
1	#include "stdafx.h"
2
3	#include <jenga/include/smoothie/Smoothie.h>
4	#include <jenga/include/smoothie/LexicalAnalysis.h>
5
6	#include <Compiler.h>
7
8	#include "../BasicCompiler_Common/common.h"
9	#include "Opcode.h"
10
11	void NewStringObject(int reg, const char *str){
12	///////////////////////////////////////////////////////
13	// lpszTextを元にStringオブジェクトを生成し、
14	// オブジェクトポインタをregに格納する
15	///////////////////////////////////////////////////////
16
17
18	//////////////////////////////////////////////////////
19	///// レジスタ資源のバックアップ
20	{ BACKUP_REGISTER_RESOURCE
21	//////////////////////////////////////////////////////
22
23	char parameter = (char )malloc( lstrlen( str ) + 32 );
24	sprintf( parameter, "\"%s\"%c%c*Char", str, 1, ESC_AS );
25	SetStringQuotes( parameter );
26
27	Operator_New( compiler.GetMeta().GetClasses().GetStringClassPtr(), "", parameter, Type( DEF_OBJECT, compiler.GetMeta().GetClasses().GetStringClassPtr() ) );
28
29	free( parameter );
30
31	//mov reg,rax
32	compiler.codeGenerator.op_mov_RR( reg, REG_RAX );
33
34	/////////////////////////////////////////////
35	////// レジスタ資源を復元
36	RESTORE_REGISTER_RESOURCE
37	}////////////////////////////////////////////
38	}
39
40	void SetUseRegFromRax(int type,int UseReg,int XmmReg){
41	if(IsRealNumberType(type)){
42	//実数型
43	if(XmmReg==REG_XMM4){
44	if(type==DEF_DOUBLE){
45	//movsd qword ptr[rsp+offset],xmm0 ※スタックフレームを利用
46	pobj_sf->push(REG_XMM0,sizeof(double));
47	}
48	if(type==DEF_SINGLE){
49	//movss dword ptr[rsp+offset],xmm0 ※スタックフレームを利用
50	pobj_sf->push(REG_XMM0,sizeof(float));
51	}
52	}
53	else{
54	if(type==DEF_DOUBLE){
55	//movsd xmm_reg,xmm0
56	compiler.codeGenerator.op_movsd_RR(XmmReg,REG_XMM0);
57	}
58	else if(type==DEF_SINGLE){
59	//movss xmm_reg,xmm0
60	compiler.codeGenerator.op_movss_RR(XmmReg,REG_XMM0);
61	}
62	}
63	}
64	else{
65	//整数型
66	if(UseReg==REG_R14){
67	//mov qword ptr[rsp+offset],rax ※スタックフレームを利用
68	pobj_sf->push(REG_RAX);
69	}
70	else{
71	//mov reg,rax
72	compiler.codeGenerator.op_mov_RR(UseReg,REG_RAX);
73	}
74	}
75	}
76
77	void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){
78	switch( Type::GetBasicSize( bigBasicType ) ){
79	case sizeof(_int64):
80	ExtendTypeTo64(baseBasicType,reg);
81	break;
82	case sizeof(long):
83	ExtendTypeTo32(baseBasicType,reg);
84	break;
85	case sizeof(short):
86	ExtendTypeTo16(baseBasicType,reg);
87	break;
88	}
89	}
90
91
92	bool VarToReg( RELATIVE_VAR &relativeVar, const Type &baseType, Type &resultType ){
93	int UseReg=pobj_reg->GetNextReg();
94	int XmmReg=pobj_reg->GetNextXmmReg();
95
96	//大きな型への暗黙の変換
97	int bigType = AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
98
99	if(resultType.GetBasicType()&FLAG_PTR){
100	//配列ポインタ
101	resultType.SetBasicType( GetPtrType(resultType.GetBasicType()^FLAG_PTR) );
102
103	SetVarPtrToReg(UseReg,&relativeVar);
104	}
105	else if(resultType.IsReal()){
106	//実数型
107	if( resultType.IsDouble() )
108	SetXmmReg_DoubleVariable(&relativeVar,XmmReg);
109	if( resultType.IsSingle() )
110	SetXmmReg_SingleVariable(&relativeVar,XmmReg);
111	}
112	else if( resultType.IsWhole() \|\| resultType.IsObject()){
113	//整数型
114	SetReg_WholeVariable(resultType.GetBasicType(),&relativeVar,UseReg);
115	}
116	else if( resultType.IsStruct() ){
117	//構造体ポインタをUseRegへ格納（構造体は値型）
118	SetVarPtrToReg(UseReg,&relativeVar);
119	}
120	else{
121	return false;
122	}
123
124	if( resultType.GetBasicType() != bigType ){
125	// 大きな型へ変換された場合
126	// ※レジスタの値をキャストする
127	ExtendRegToBigType( UseReg, bigType, resultType.GetBasicType() );
128
129	resultType.SetBasicType( bigType );
130	}
131
132	return true;
133	}
134	bool TermMemberOpe( const CClass &objClass, const Type &baseType, Type &resultType, const char termFull, const char termLeft, const char *member ){
135
136	int UseReg=pobj_reg->GetNextReg();
137	int XmmReg=pobj_reg->GetNextXmmReg();
138
139
140	if( GetMemberType( objClass, member, resultType, 0, false ) ){
141	// メンバが見つかったとき
142
143	//オブジェクトポインタをr11にコピー
144	compiler.codeGenerator.op_mov_RR( REG_R11, UseReg );
145
146	RELATIVE_VAR relativeVar;
147	relativeVar.dwKind=VAR_DIRECTMEM;
148
149	if( !_member_offset(
150	true, //エラー表示あり
151	false, //読み込み専用
152	objClass,
153	member,&relativeVar,resultType,0)){
154	return false;
155	}
156
157	if( !VarToReg( relativeVar, baseType, resultType ) ){
158	SetError(11,termFull,cp);
159	}
160
161	return true;
162	}
163
164
165	///////////////////////////////////////////////////////////////////
166	// 動的メソッドを検索
167	///////////////////////////////////////////////////////////////////
168	vector<const UserProc *> userProcs;
169
170	char methodName[VN_SIZE], lpPtrOffset[VN_SIZE], parameter[VN_SIZE], dummy[1];
171	ReferenceKind refType;
172	lstrcpy( methodName, member );
173	GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
174
175	objClass.GetMethods().Enum( methodName, userProcs );
176	if(userProcs.size()){
177	//オーバーロードを解決
178	const UserProc *pUserProc = OverloadSolutionWithStrParam(termFull,userProcs,parameter,termLeft);
179
180	if( pUserProc ){
181
182	resultType = pUserProc->ReturnType();
183
184
185	//////////////////////////////////////////////////////
186	///// レジスタ資源のバックアップ
187	{ BACKUP_REGISTER_RESOURCE
188	//////////////////////////////////////////////////////
189
190	//オブジェクトポインタをスタックに入れておく
191	//mov qword ptr[rsp+offset],reg ※スタックフレームを利用
192	pobj_sf->push( UseReg );
193
194	if( !Opcode_CallProc(parameter,pUserProc,PROCFLAG_NEW,termLeft,0 ) ){
195	//レジスタ資源を復元
196	RESTORE_REGISTER_RESOURCE
197
198	return false;
199	}
200
201	pobj_sf->pop();
202
203	/////////////////////
204	// 戻り値の処理
205	/////////////////////
206
207	//大きな型への暗黙の変換
208	int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
209
210	if( resultType.GetBasicType() != bigType ){
211	// 大きな型へ変換された場合
212	// ※レジスタの値をキャストする
213	ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
214
215	resultType.SetBasicType( bigType );
216	}
217
218	SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
219
220
221	/////////////////////////////////////////////
222	////// レジスタ資源を復元
223	RESTORE_REGISTER_RESOURCE
224	}////////////////////////////////////////////
225
226	return true;
227	}
228	}
229
230	return false;
231	}
232	bool TermOpe( const char term, const Type &baseType, Type &resultType, bool &isLiteral, BOOL pbUseHeap, bool isWantObject, bool *pIsClassName, bool isProcedureCallOnly ){
233	char parameter[VN_SIZE];
234
235	// Withを解決
236	char termFull[VN_SIZE];
237	if(term[0]=='.'){
238	GetWithName(termFull);
239	lstrcat(termFull,term);
240	}
241	else lstrcpy(termFull,term);
242
243	char termLeft[VN_SIZE];
244	lstrcpy(termLeft,termFull);
245
246	// パース
247	char member[VN_SIZE];
248	ReferenceKind refType;
249	if( SplitMemberName( termFull, termLeft, member, refType ) ){
250	///////////////////////////////////////////////////////////////////
251	// オブジェクトとメンバに分解できるとき
252	// termLeft.member
253	///////////////////////////////////////////////////////////////////
254
255	isLiteral = false;
256
257	// オブジェクト側の型を取得
258	bool isClassName = false;
259	Type leftType;
260	if( GetTermType( termLeft, leftType, isLiteral, &isClassName ) ){
261	if( isClassName == false && compiler.GetMeta().GetBlittableTypes().IsExist( leftType ) ){
262	// 左側のオブジェクト部分がBlittable型のとき
263
264	char temporary[VN_SIZE];
265	lstrcpy( temporary, termLeft );
266	sprintf( termLeft, "%s(%s)",
267	compiler.GetMeta().GetBlittableTypes().Find( leftType ).GetCreateStaticMethodFullName().c_str(),
268	temporary );
269	}
270	}
271
272	if( !TermOpe( termLeft, baseType, leftType, isLiteral, pbUseHeap, true, &isClassName ) ){
273	goto globalArea;
274	}
275
276	if( isClassName ){
277	// 静的メンバ/メソッドの場合
278	goto globalArea;
279	}
280
281	if( !leftType.HasMember() ){
282	// メンバを持たない型の場合
283	return false;
284	}
285
286	return TermMemberOpe( leftType.GetClass(), baseType, resultType, termFull, termLeft, member );
287	}
288	globalArea:
289
290	//////////////////////////////////////////////
291	// クラス名かどうかをチェック（静的メンバ用）
292	//////////////////////////////////////////////
293
294	if( pIsClassName ){
295	if( compiler.GetMeta().GetClasses().Find( termFull ) ){
296	*pIsClassName = true;
297	return true;
298	}
299	}
300
301
302	/////////////////////////////////////////////////////////////////
303	// グローバル属性エリア
304	/////////////////////////////////////////////////////////////////
305
306	int UseReg=pobj_reg->GetNextReg();
307	int XmmReg=pobj_reg->GetNextXmmReg();
308
309
310	if(lstrcmpi(termFull,"This")==0 && isProcedureCallOnly == false ){
311	//Thisオブジェクト
312	resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
313
314	SetThisPtrToReg( UseReg );
315
316	isLiteral = false;
317
318	return true;
319	}
320
321
322	//////////////////////////////////////
323	// 関数（DLL、ユーザー定義、組み込み）
324	//////////////////////////////////////
325	char procName[VN_SIZE];
326	char temporary[8192];
327
328	int i2=GetCallProcName(termFull,procName);
329	if(termFull[i2]=='('){
330	int i4=GetStringInPare_RemovePare(parameter,termFull+i2+1);
331
332	void *pInfo;
333	int idProc=GetProc(procName,(void **)&pInfo);
334
335	if(idProc){
336	//閉じカッコ")"に続く文字がNULLでないとき
337	if(termFull[i2+1+i4+1]!='\0'){
338	SetError(42,NULL,cp);
339	}
340
341
342	//////////////////////////////////////////////////////
343	///// レジスタ資源のバックアップ
344	{ BACKUP_REGISTER_RESOURCE
345	//////////////////////////////////////////////////////
346
347
348	////////////////
349	// 呼び出し
350	////////////////
351
352	CallProc(idProc,pInfo,procName,parameter,resultType);
353
354
355	/////////////////////
356	// 戻り値の処理
357	/////////////////////
358
359	//大きな型への暗黙の変換
360	int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
361
362	if( resultType.GetBasicType() != bigType ){
363	// 大きな型へ変換された場合
364	// ※レジスタの値をキャストする
365	ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
366
367	resultType.SetBasicType( bigType );
368	}
369
370	SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
371
372	/////////////////////////////////////////////
373	////// レジスタ資源を復元
374	RESTORE_REGISTER_RESOURCE
375	}////////////////////////////////////////////
376
377	if(resultType.IsStruct()){
378	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
379	//※後にfreeする必要あり
380	// TODO: 解放はGCに任せる
381	*pbUseHeap = 1;
382	}
383
384	isLiteral = false;
385
386	return true;
387	}
388
389	ConstMacro *pConstMacro = compiler.GetMeta().GetGlobalConstMacros().Find( procName );
390	if( pConstMacro )
391	{
392	if( pConstMacro->GetCalcBuffer( parameter, temporary ) )
393	{
394	/////////////////////////
395	// マクロ関数
396	/////////////////////////
397
398	//閉じカッコ")"に続く文字がNULLでないときはエラーにする
399	if(termFull[i2+1+i4+1]!='\0') SetError(42,NULL,cp);
400
401	//マクロ関数の場合
402	NumOpe(&UseReg, temporary,Type(),resultType);
403
404	if(!IS_LITERAL(resultType.GetIndex())){
405	//リテラル値ではなかったとき
406	isLiteral = false;
407	}
408
409	return true;
410	}
411	}
412	}
413	else if( isProcedureCallOnly ){
414	// 関数呼び出し以外は受け付けない
415	return false;
416	}
417
418
419	////////////////////////////////
420	// インデクサ（getアクセサ）
421	////////////////////////////////
422
423	char VarName[VN_SIZE],ArrayElements[VN_SIZE];
424	GetArrayElement(termFull,VarName,ArrayElements);
425	if(ArrayElements[0]){
426	GetVarType(VarName,resultType,false);
427	if( resultType.IsObject() ){
428	CallIndexerGetterProc(UseReg,&resultType.GetClass(),VarName,ArrayElements,resultType);
429
430	isLiteral = false;
431
432	return true;
433	}
434	}
435
436
437	////////////////////////////////
438	// 変数
439	////////////////////////////////
440
441	RELATIVE_VAR relativeVar;
442	if(GetVarOffset(
443	false, //エラー表示なし
444	false, //読み込み専用
445	termFull,
446	&relativeVar,resultType)){
447	//////////
448	// 変数
449	//////////
450
451	if( !VarToReg( relativeVar, baseType, resultType ) ){
452	SetError(11,termFull,cp);
453	}
454
455	isLiteral = false;
456
457	return true;
458	}
459
460	/*
461	////////////////////////////////
462	// 型名
463	////////////////////////////////
464
465	if( Compiler::StringToType( termFull, resultType ) ){
466	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_CAST );
467	return true;
468	}*/
469
470
471	/////////////////////////////////
472	// プロパティ用のメソッド
473	/////////////////////////////////
474
475	//配列要素を排除
476	GetArrayElement(termFull,VarName,ArrayElements);
477
478	if(GetSubHash(VarName,0)){
479
480	//////////////////////////////////////////////////////
481	///// レジスタ資源のバックアップ
482	{ BACKUP_REGISTER_RESOURCE
483	//////////////////////////////////////////////////////
484
485	CallPropertyMethod(termFull,NULL,resultType);
486
487	//大きな型への暗黙の変換
488	int bigType = AutoBigCast(baseType.GetBasicType(), resultType.GetBasicType() );
489
490	if( resultType.GetBasicType() != bigType ){
491	// 大きな型へ変換された場合
492	// ※レジスタの値をキャストする
493	ExtendRegToBigType( REG_RAX, bigType, resultType.GetBasicType() );
494
495	resultType.SetBasicType( bigType );
496	}
497
498	SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
499
500	/////////////////////////////////////////////
501	////// レジスタ資源を復元
502	RESTORE_REGISTER_RESOURCE
503	}////////////////////////////////////////////
504
505	if(resultType.IsStruct()){
506	//構造体が戻ったときはヒープ領域にインスタンスが格納されている
507	//※後にfreeする必要あり
508	// TODO: 解放はGCに任せる
509	*pbUseHeap = 1;
510	}
511
512	isLiteral = false;
513
514	return true;
515	}
516
517
518	return false;
519	}
520
521	bool NumOpe( int *pReg,
522	const char *expression,
523	const Type &baseType,
524	Type &resultType,
525	BOOL *pbUseHeap ){
526
527	int i,i2,i3;
528	char temporary[1024],temp2[1024];
529
530	if(expression[0]=='\0'){
531	SetError(1,NULL,cp);
532	return false;
533	}
534
535	if(expression[0]==1&& expression[1]==ESC_NEW ){
536	//New演算子（オブジェクト生成）
537
538	if( pobj_BlockReg->check(REG_RAX) ){
539	SetError();
540	}
541
542	//////////////////////////////////////////////////////
543	///// レジスタ資源のバックアップ
544	{ BACKUP_REGISTER_RESOURCE
545	//////////////////////////////////////////////////////
546
547	if( !Operator_New( expression+2, baseType, resultType ) ){
548	return false;
549	}
550
551	/////////////////////////////////////////////
552	////// レジスタ資源を復元
553	RESTORE_REGISTER_RESOURCE
554	}////////////////////////////////////////////
555
556	//mov reg,rax
557	compiler.codeGenerator.op_mov_RR( *pReg, REG_RAX );
558
559	return true;
560	}
561
562	if( !baseType.IsNull() && expression[0] == '[' ){
563	// リテラル配列の場合
564
565	if( !baseType.IsPointer() ){
566	SetError(1,NULL,cp);
567	return false;
568	}
569	Type tempBaseType( baseType );
570	tempBaseType.PtrLevelDown();
571
572	char buffer = (char )malloc( lstrlen( expression ) + 1 );
573	lstrcpy( buffer, expression );
574	RemoveStringBracket( buffer );
575
576	void *binary = malloc( 1 );
577	int num = 0;
578
579	i = 0;
580	while( buffer[i] ){
581	i = GetOneParameter( buffer, i, temporary );
582	if( buffer[i] == ',' ){
583	i++;
584	}
585
586	Type resultType;
587	_int64 i64data;
588	if( !StaticCalculation( true, temporary, tempBaseType.GetBasicType(), &i64data, resultType ) ){
589	return false;
590	}
591	if( !resultType.IsWhole() ){
592	// TODO: 実数に未対応
593	SetError();
594	return false;
595	}
596
597	binary = realloc( binary, ( num + 1 ) * tempBaseType.GetSize() );
598	memcpy( (char )binary + (num tempBaseType.GetSize()), &i64data, tempBaseType.GetSize() );
599	num++;
600	}
601
602	i2 = compiler.GetDataTable().AddBinary( binary, num * tempBaseType.GetSize() );
603
604	//mov reg,i2
605	compiler.codeGenerator.op_mov_RV(sizeof(_int64),*pReg,i2, Schedule::DataTable );
606
607	free( buffer );
608
609	resultType = baseType;
610
611	return true;
612	}
613
614
615	/////////////////////////////////
616	// 式要素を逆ポーランド式で取得
617	/////////////////////////////////
618
619	char *values[255];
620	long calc[255];
621	long stack[255];
622	int pnum;
623	if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
624	for(i=0;i<pnum;i++){
625	if(values[i]) HeapDefaultFree(values[i]);
626	}
627	return 0;
628	}
629
630
631	BOOL bInitRegSwitch=0;
632	if(!pobj_reg){
633	bInitRegSwitch=1;
634
635	//作業用レジスタを取得
636	pobj_reg=new CRegister(*pReg);
637	}
638
639	//エラー時の復旧用
640	CRegister objReg_Backup;
641	objReg_Backup=*pobj_reg;
642
643
644
645	////////////////////////////////
646	// 演算部分のコード生成を開始
647	////////////////////////////////
648
649	BOOL bError;
650	bError=0;
651
652	//リテラル値のみの計算かどうかを判別するためのフラグ
653	BOOL bLiteralCalculation=1;
654
655	//リテラル演算の場合を考慮した演算前のバッファ位置
656	int BeforeObp;
657	BeforeObp=obp;
658
659	//リテラル演算の場合を考慮した演算前のプロシージャスケジュール位置
660	//※64ビットの掛け算、除算などで特殊関数が呼ばれるため
661	int Before_ProcAddrScheduleNum;
662	Before_ProcAddrScheduleNum=pobj_SubAddrSchedule->num;
663
664	//リテラル演算の場合を考慮した演算前のデータテーブルスケジュール位置
665	int Before_DataTableScheduleNum;
666	Before_DataTableScheduleNum=pobj_DataTableSchedule->num;
667
668	//リテラル演算の場合を考慮した演算前の再配置スケジュール
669	CReloc *pobj_BackReloc;
670	pobj_BackReloc=new CReloc();
671	pobj_BackReloc->copy(pobj_Reloc);
672
673	//リテラル演算の場合を考慮した演算前のスタックフレームスケジュール位置
674	int Before_StackFrameScheduleNum;
675	Before_StackFrameScheduleNum=pobj_sf->num;
676
677	double dbl;
678	int sp;
679	int type_stack[255];
680	LONG_PTR index_stack[255];
681	bool isNothing_stack[255];
682	BOOL bUseHeap[255];
683	_int64 i64data;
684	int UseReg,XmmReg;
685	BOOL bXmm;
686	for(i=0,sp=0;i<pnum;i++){
687	int idCalc;
688	idCalc=calc[i]%100;
689
690	if(idCalc){
691	if(type_stack[sp-2]==DEF_OBJECT){
692	if( idCalc == CALC_AS
693	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
694	&& index_stack[sp-1] == index_stack[sp-2]
695	\|\| isNothing_stack[sp-2] ){
696	// 同一の型、またはNothingに対するAsはAs演算子を呼び出さない
697	}
698	else if( idCalc == CALC_AS
699	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST )
700	&& ( ((CClass )index_stack[sp-1])->IsEqualsOrSubClass( (CClass )index_stack[sp-2] ) \|\| ((CClass )index_stack[sp-2])->IsEqualsOrSubClass( (CClass )index_stack[sp-1] )
701	)){
702	// ダウンキャストを許可する
703	}
704	else if( idCalc == CALC_AS
705	&& type_stack[sp-1] == ( DEF_OBJECT \| FLAG_CAST ) && ((CClass *)index_stack[sp-1])->IsInterface()
706	){
707	// インターフェイスへのキャスト
708	// TODO: 実装
709	CastToInterface( pobj_reg->GetLockingReg(), REG_R15, (CClass )index_stack[sp-2], (CClass )index_stack[sp-1] );
710	}
711	else{
712	//オーバーロードされたオペレータを呼び出す
713	i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,bUseHeap,sp);
714	if(i2==0){
715	if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
716	else GetCalcName(idCalc,temp2);
717	sprintf(temporary,"Operator %s",temp2);
718	SetError(27,temporary,cp);
719	goto error;
720	}
721	else if(i2==-1) goto error;
722
723	continue;
724	}
725	}
726
727	if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
728	}
729
730	switch(idCalc){
731	//数値
732	case 0:
733	index_stack[sp]=-1;
734	isNothing_stack[sp] = false;
735	bUseHeap[sp]=0;
736
737	UseReg=pobj_reg->GetNextReg();
738	XmmReg=pobj_reg->GetNextXmmReg();
739
740	bXmm=0;
741
742	char *term;
743	term=values[i];
744
745	if( calc[i+1]%100 == CALC_AS ){
746	// As演算子の右辺値
747	//型名
748	if( Compiler::StringToType( term, resultType ) ){
749	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_CAST );
750	}
751	else{
752	SetError(3, term, cp );
753	goto error;
754	}
755
756	type_stack[sp] = resultType.GetBasicType();
757	index_stack[sp] = resultType.GetIndex();
758	sp++;
759
760	break;
761	}
762
763	if(term[0]=='\"'){
764	//リテラル文字列
765	if(!RemoveStringQuotes(term)){
766	SetError(43,NULL,cp);
767	goto error;
768	}
769	i3=lstrlen(term);
770	StrLiteral:
771
772	if( baseType.IsObject() \|\| baseType.IsNull() ){
773	//要求タイプがオブジェクト、または未定のとき
774
775	//String型オブジェクトを生成
776	NewStringObject(UseReg,term);
777
778	type_stack[sp]=DEF_OBJECT;
779	index_stack[sp]=(LONG_PTR)compiler.GetMeta().GetClasses().GetStringClassPtr();
780	bLiteralCalculation=0;
781
782	if(bXmm) pobj_reg->LockXmmReg();
783	else pobj_reg->LockReg();
784
785	sp++;
786	break;
787	}
788
789	type_stack[sp]=typeOfPtrChar;
790	bLiteralCalculation=0;
791
792	i2 = compiler.GetDataTable().AddString( term, i3 );
793
794	//mov reg,i2
795	compiler.codeGenerator.op_mov_RV(sizeof(_int64),UseReg,i2, Schedule::DataTable);
796
797	if(UseReg==REG_R14){
798	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
799	pobj_sf->push(REG_R14);
800	}
801	}
802	else if((term[0]=='e'\|\|term[0]=='E')&&
803	(term[1]=='x'\|\|term[1]=='X')&&
804	term[2]=='\"'){
805	//拡張版リテラル文字列（エスケープシーケンス可能）
806	if(!RemoveStringQuotes(term+2)){
807	SetError(43,NULL,cp);
808	goto error;
809	}
810	i3=FormatString_EscapeSequence(term+2);
811	term+=2;
812
813	goto StrLiteral;
814	}
815	else if(IsVariableTopChar(term[0])\|\|
816	term[0]=='*'\|\|
817	(term[0]=='.'&&IsVariableTopChar(term[1]))){
818	//////////////////
819	// 何らかの識別子
820
821	bool isLiteral;
822	if( TermOpe( term, baseType, resultType, isLiteral, &bUseHeap[sp] ) ){
823	if(resultType.IsNull()){
824	//戻り値が存在しないとき
825	for(i2=0;;i2++){
826	if(term[i2]=='('\|\|term[i2]=='\0'){
827	term[i2]=0;
828	break;
829	}
830	}
831	SetError(38,term,cp);
832
833	goto error;
834	}
835
836	type_stack[sp] = resultType.GetBasicType();
837	index_stack[sp] = resultType.GetIndex();
838
839	if( !isLiteral ){
840	bLiteralCalculation=0;
841	}
842
843	if( resultType.GetBasicType() & FLAG_CAST ){
844	// 型名のみ
845	SetError();
846	}
847	else{
848	if( resultType.IsReal() == false && UseReg==REG_R14 ){
849	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
850	pobj_sf->push(REG_R14);
851	}
852	if( resultType.IsReal() && XmmReg==REG_XMM4 ){
853	if(resultType.IsDouble()){
854	//movsd qword ptr[rsp+offset],xmm4 ※スタックフレームを利用
855	pobj_sf->push(REG_XMM4,sizeof(double));
856	}
857	if(resultType.IsSingle()){
858	//movss dword ptr[rsp+offset],xmm4 ※スタックフレームを利用
859	pobj_sf->push(REG_XMM4,sizeof(float));
860	}
861	}
862
863	if( resultType.IsReal() ){
864	pobj_reg->LockXmmReg();
865	}
866	else{
867	pobj_reg->LockReg();
868	}
869	}
870
871	sp++;
872	break;
873	}
874
875
876	// Nothing
877	if( lstrcmp( term, "Nothing" ) == 0 ){
878	isNothing_stack[sp] = true;
879
880	type_stack[sp] = DEF_OBJECT;
881	if( baseType.IsObject() ){
882	index_stack[sp] = baseType.GetIndex();
883	}
884	else{
885	index_stack[sp] = (LONG_PTR)compiler.GetMeta().GetClasses().GetObjectClassPtr();
886	}
887
888	bLiteralCalculation = 0;
889
890	//xor reg,reg
891	compiler.codeGenerator.op_zero_reg( UseReg );
892
893	if(UseReg==REG_R14){
894	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
895	pobj_sf->push(REG_R14);
896	}
897
898	pobj_reg->LockReg();
899	sp++;
900	break;
901	}
902
903
904	//////////////
905	// 定数の場合
906	//////////////
907
908	i3 = compiler.GetMeta().GetGlobalConsts().GetBasicType(term);
909	if(i3){
910	if( compiler.GetMeta().GetGlobalConsts().IsStringPtr( term ) ){
911	//リテラル文字列
912
913	double dbl = compiler.GetMeta().GetGlobalConsts().GetDoubleData(term);
914	memcpy(&i64data,&dbl,sizeof(double));
915
916	//バイト数
917	i3=lstrlen((char *)i64data);
918
919	memcpy(term,(char *)i64data,i3);
920	term[i3]=0;
921	goto StrLiteral;
922	}
923
924	type_stack[sp] = i3;
925	if(IsRealNumberType(i3)){
926	//実数
927	double dbl = compiler.GetMeta().GetGlobalConsts().GetDoubleData(term);
928	memcpy(&i64data,&dbl,sizeof(double));
929	goto Literal;
930	}
931	else if(IsWholeNumberType(i3)){
932	//整数
933	i64data = compiler.GetMeta().GetGlobalConsts().GetWholeData(term);
934	goto Literal;
935	}
936	/*else if(i3==DEF_STRING){
937	//リテラル文字列
938
939	//バイト数
940	i3=(int)dbl;
941
942	memcpy(term,temporary,i3);
943	goto StrLiteral;
944	}*/
945	else{
946	SetError(1,NULL,0);
947	goto error;
948	}
949	}
950
951
952	//該当する識別子が見当たらないときはエラー扱いにする
953	bError=1;
954	SetError(3,term,cp);
955	type_stack[sp]=DEF_DOUBLE;
956	}
957	else{
958	//リテラル値
959	type_stack[sp]=GetLiteralValue(term,&i64data,baseType.GetBasicType());
960	Literal:
961	if(type_stack[sp]==DEF_DOUBLE){
962	//64ビット浮動小数型
963	bXmm=1;
964
965	if(XmmReg==REG_XMM4){
966	//mov r14,i64data
967	compiler.codeGenerator.op_mov_RV64(REG_R14,i64data);
968
969
970	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
971	pobj_sf->push(REG_R14);
972	}
973	else{
974	i3 = compiler.GetDataTable().Add( i64data );
975
976	//movlpd xmm_reg,qword ptr[data table offset]
977	compiler.codeGenerator.op_movlpd_RM( XmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
978	}
979	}
980	else if(type_stack[sp]==DEF_SINGLE){
981	//32ビット浮動小数型
982	bXmm=1;
983
984	float flt;
985	int i32data;
986	memcpy(&dbl,&i64data,sizeof(double));
987	flt=(float)dbl;
988	memcpy(&i32data,&flt,sizeof(long));
989
990	if(XmmReg==REG_XMM4){
991	SetError(); // TODO: 未実装
992	//push term
993	//compiler.codeGenerator.op_push_value(i32data);
994	}
995	else{
996	i3=compiler.GetDataTable().Add( i32data );
997
998	//movss xmm_reg,dword ptr[data table offset]
999	compiler.codeGenerator.op_movss_RM( XmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
1000	}
1001	}
1002	else{
1003	//整数
1004
1005	index_stack[sp]=GetLiteralIndex(i64data);
1006
1007	//mov reg,i64data
1008	compiler.codeGenerator.op_mov_RV64(UseReg,i64data);
1009
1010	if(UseReg==REG_R14){
1011	//mov qword ptr[rsp+offset],r14 ※スタックフレームを利用
1012	pobj_sf->push(REG_R14);
1013	}
1014	}
1015	}
1016
1017	if(bXmm) pobj_reg->LockXmmReg();
1018	else pobj_reg->LockReg();
1019
1020	sp++;
1021	break;
1022
1023	//論理演算子
1024	case CALC_XOR:
1025	case CALC_OR:
1026	case CALC_AND:
1027	if(!CalcTwoTerm_Logical(idCalc,type_stack,index_stack,&sp)) goto error;
1028	break;
1029	case CALC_NOT:
1030	//value[sp-1]=Not value[sp-1]
1031	//NOT演算子
1032	if(!Calc_Not(type_stack,sp)) goto error;
1033	break;
1034
1035	//比較演算子
1036	case CALC_PE: //value[sp-2] <= value[sp-1]
1037	case CALC_QE: //value[sp-2] >= value[sp-1]
1038	case CALC_P: //value[sp-2] < value[sp-1]
1039	case CALC_Q: //value[sp-2] > value[sp-1]
1040	case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
1041	case CALC_EQUAL: //value[sp-2] = value[sp-1]
1042	if(!CalcTwoTerm_Relational(idCalc,type_stack,index_stack,&sp)) goto error;
1043	break;
1044
1045	//ビットシフト
1046	case CALC_SHL: //value[sp-2] << value[sp-1]
1047	case CALC_SHR: //value[sp-2] >> value[sp-1]
1048	if(!Calc_Shift(idCalc,type_stack,&sp)) goto error;
1049	break;
1050
1051	//算術演算
1052	case CALC_ADDITION:
1053	case CALC_SUBTRACTION:
1054	case CALC_PRODUCT:
1055	if(!CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp)) goto error;
1056	break;
1057	case CALC_MOD:
1058	//value[sp-2]%=value[sp-1]
1059	//剰余演算
1060	if(!Calc_Mod(type_stack,index_stack,&sp)) goto error;
1061	break;
1062	case CALC_QUOTIENT:
1063	//value[sp-2]/=value[sp-1];
1064	//除算
1065	if(!Calc_Divide(type_stack,&sp,baseType.GetBasicType())) goto error;
1066	break;
1067	case CALC_INTQUOTIENT:
1068	//value[sp-2]/=value[sp-1]
1069	//整数除算
1070	if(!Calc_IntDivide(type_stack,index_stack,&sp)) goto error;
1071	break;
1072	case CALC_MINUSMARK:
1073	//value[sp-1]=-value[sp-1]
1074	//符号反転
1075	if(!Calc_MinusMark(type_stack,sp)) goto error;
1076	break;
1077	case CALC_POWER:
1078	//べき乗演算（浮動小数点演算のみ）
1079	if(!Calc_Power(type_stack,&sp)) goto error;
1080	break;
1081	case CALC_AS:
1082	//キャスト
1083	if(!Calc_Cast(type_stack,index_stack,&sp)) goto error;
1084	break;
1085	case CALC_BYVAL:
1086	//ポインタ型→参照型
1087	if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
1088	//ポインタ型ではないとき
1089	SetError( 3, NULL, cp );
1090	goto error;
1091	}
1092
1093	type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
1094
1095	break;
1096
1097	default:
1098	SetError(300,NULL,cp);
1099	goto error;
1100	}
1101	}
1102
1103	if(bError) goto error;
1104
1105	if(sp!=1){
1106	SetError(1,NULL,cp);
1107	goto error;
1108	}
1109
1110	if(bLiteralCalculation){
1111	//右辺値が数値の定数式の場合
1112	Type resultType;
1113	StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
1114
1115	obp=BeforeObp;
1116	pobj_SubAddrSchedule->num=Before_ProcAddrScheduleNum;
1117	pobj_DataTableSchedule->num=Before_DataTableScheduleNum;
1118	pobj_Reloc->copy(pobj_BackReloc);
1119	pobj_sf->num=Before_StackFrameScheduleNum;
1120	*pobj_reg=objReg_Backup;
1121
1122	if(resultType.IsReal()){
1123	if(baseType.IsReal()) resultType=baseType;
1124
1125	XmmReg=pobj_reg->LockXmmReg();
1126
1127	if(resultType.IsDouble()){
1128	i3 = compiler.GetDataTable().Add( i64data );
1129
1130	//movlpd xmm_reg,qword ptr[data table offset]
1131	compiler.codeGenerator.op_movlpd_RM( XmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
1132	}
1133	if(resultType.IsSingle()){
1134	memcpy(&dbl,&i64data,sizeof(_int64));
1135
1136	float flt;
1137	int i32data;
1138	flt=(float)dbl;
1139	memcpy(&i32data,&flt,sizeof(long));
1140
1141	i3 = compiler.GetDataTable().Add( i32data );
1142
1143	//movss xmm_reg,dword ptr[data table offset]
1144	compiler.codeGenerator.op_movss_RM( XmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
1145	}
1146	}
1147	else{
1148	if(!resultType.Is64()){
1149	//整数（符号有り/無し）
1150
1151	i3=(long)i64data;
1152
1153	if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
1154	if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
1155
1156	i64data=(_int64)i3;
1157	}
1158
1159	UseReg=pobj_reg->LockReg();
1160
1161	//mov reg,i64data
1162	compiler.codeGenerator.op_mov_RV64(UseReg,i64data);
1163	}
1164
1165	type_stack[0]=resultType.GetBasicType();
1166	index_stack[0]=resultType.GetIndex();
1167	}
1168	else{
1169	//右辺値が数値の定数式ではないとき
1170	if(IS_LITERAL(index_stack[0])) index_stack[0]=-1;
1171	}
1172
1173	if(pbUseHeap) *pbUseHeap=bUseHeap[0];
1174
1175	if(IsRealNumberType(type_stack[0]))
1176	*pReg=pobj_reg->UnlockXmmReg();
1177	else
1178	*pReg=pobj_reg->UnlockReg();
1179
1180
1181	if(bInitRegSwitch){
1182	//整合性をチェック（バグ回避）
1183	pobj_reg->bug_check();
1184
1185	//作業レジスタを解放
1186	delete pobj_reg;
1187	pobj_reg=0;
1188	}
1189
1190	resultType.SetType( type_stack[0], index_stack[0] );
1191
1192	bool isSuccessful = true;
1193	goto finish;
1194
1195
1196
1197	//////////////////
1198	// エラー処理
1199	//////////////////
1200
1201	error:
1202
1203	*pobj_reg=objReg_Backup;
1204
1205	if(bInitRegSwitch){
1206	//作業レジスタを解放
1207	delete pobj_reg;
1208	pobj_reg=0;
1209	}
1210
1211	isSuccessful = false;
1212	goto finish;
1213
1214
1215
1216
1217	finish:
1218
1219	for(i=0;i<pnum;i++){
1220	if(values[i]) HeapDefaultFree(values[i]);
1221	}
1222
1223	//再配置スケジュールバックアップ情報を解放
1224	delete pobj_BackReloc;
1225
1226	return isSuccessful;
1227	}

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

Download in other formats: