Context Navigation

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

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

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

Download in other formats: