Context Navigation

source: dev/trunk/abdev/BasicCompiler64/Compile_Var.cpp@ 316

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

File size: 34.7 KB

Line
1	#include "stdafx.h"
2
3	#include <jenga/include/smoothie/Smoothie.h>
4	#include <jenga/include/smoothie/LexicalAnalysis.h>
5
6	#include <CodeGenerator.h>
7	#include <Compiler.h>
8	#include <Variable.h>
9
10	#include "../BasicCompiler_Common/common.h"
11	#include "Opcode.h"
12
13	//変数
14	// TODO: xml未完成
15	int AllGlobalVarSize;
16	int AllInitGlobalVarSize;
17
18	int AllLocalVarSize;
19
20
21	void SetRelativeOffset( Type &resultType, RELATIVE_VAR pRelativeVar,const char lpPtrOffset){
22	/////////////////////////////////////////////
23	// 先頭ポインタをr12に取得してメモリへ退避
24	/////////////////////////////////////////////
25
26	SetReg_WholeVariable(Type(DEF_INT64),pRelativeVar,REG_R11);
27
28	//mov qword ptr[rsp+offset],r11 ※スタックフレームを利用
29	pobj_sf->push(REG_R11);
30
31
32	////////////////////////////////
33	// 添え字を計算する
34	////////////////////////////////
35
36	int reg=REG_NON;
37	Type type;
38	NumOpe( &reg, lpPtrOffset, Type(), type );
39	if( !type.IsWhole() ){
40	SetError(46,NULL,cp);
41	}
42	ExtendTypeTo64(type.GetBasicType(),reg);
43
44	if(reg==REG_R14){
45	//mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
46	pobj_sf->pop(REG_R14);
47	}
48
49	if( resultType.PtrLevel() ){
50	resultType.PtrLevelDown();
51
52	int typeSize = resultType.GetSize();
53	if(typeSize>=2){
54	//imul reg,i2
55	compiler.codeGenerator.op_imul_RV(sizeof(_int64),reg,typeSize);
56	}
57	}
58	else{
59	//エラー
60	SetError(1,NULL,cp);
61	return;
62	}
63
64
65	//////////////////////////////
66	// 先頭ポインタに添え字を加算
67	//////////////////////////////
68
69	//mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
70	pobj_sf->pop(REG_R11);
71
72	//add r11,reg
73	compiler.codeGenerator.op_add_RR(REG_R11,reg);
74	}
75	void SetRelativeOffset( RELATIVE_VAR &relativeVar ){
76	if(relativeVar.dwKind==VAR_DIRECTMEM){
77	//mov r11,qword ptr[r11]
78	compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
79	}
80	else{
81	//直接参照に切り替え
82	SetVarPtrToReg(REG_R12,&relativeVar);
83	relativeVar.dwKind=VAR_DIRECTMEM;
84
85	//mov r11,qword ptr[r12]
86	compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
87	}
88	}
89	bool GetArrayOffset(const Subscripts &subscripts,char *array, const Type &type){
90	extern HANDLE hHeap;
91	int i,i2,i3,i4;
92	char temporary[VN_SIZE],*pParm[MAX_PARMS];
93
94	for(i=0,i2=0,i3=0;;i++,i2++){
95	if(array[i]=='('){
96	i4=GetStringInPare(temporary+i2,array+i);
97	i+=i4-1;
98	i2+=i4-1;
99	continue;
100	}
101	if(array[i]=='['){
102	i4=GetStringInBracket(temporary+i2,array+i);
103	i+=i4-1;
104	i2+=i4-1;
105	continue;
106	}
107	if(array[i]==','\|\|array[i]=='\0'){
108	if( i3 >= (int)subscripts.size() )
109	{
110	for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
111	return false;
112	}
113
114	temporary[i2]=0;
115
116	pParm[i3]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
117	lstrcpy(pParm[i3],temporary);
118
119	i3++;
120
121	if(array[i]=='\0'){
122	if( i3 < (int)subscripts.size() )
123	{
124	for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
125	return false;
126	}
127	break;
128	}
129
130	i2=-1;
131	continue;
132	}
133	temporary[i2]=array[i];
134	}
135
136	//mov qword ptr[rsp+offset],r11 ※スタックフレームを利用
137	pobj_sf->push(REG_R11);
138
139	//xor r12,r12
140	compiler.codeGenerator.op_zero_reg(REG_R12);
141
142	for(i=i3-1;i>=0;i--){
143	//mov qword ptr[rsp+offset],r12 ※スタックフレームを利用
144	pobj_sf->push(REG_R12);
145
146	int reg=REG_NON;
147	Type type;
148	BOOL bUseHeap;
149	NumOpe( &reg, pParm[i], Type( DEF_LONG ), type, &bUseHeap );
150	if( type.IsObject() ){
151	//キャスト演算子のオーバーロードに対応する
152	CallCastOperatorProc(reg,
153	type,
154	bUseHeap, Type(DEF_LONG) );
155	type.SetBasicType( DEF_LONG );
156	}
157
158	if( !type.IsWhole() ){
159	SetError(46,NULL,cp);
160	}
161	ExtendTypeTo64( type.GetBasicType(), reg );
162
163	if(reg==REG_R14){
164	//mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
165	pobj_sf->pop(REG_R14);
166	}
167
168	//mov r12,qword ptr[rsp+offset] ※スタックフレームを利用
169	pobj_sf->pop(REG_R12);
170
171	for(i2=i+1,i4=1;i2<i3;i2++) i4*=subscripts[i2]+1;
172
173	//imul reg,i4
174	compiler.codeGenerator.op_imul_RV(sizeof(_int64),reg,i4);
175
176	//add r12,reg
177	compiler.codeGenerator.op_add_RR(REG_R12,reg);
178
179	HeapDefaultFree(pParm[i]);
180	}
181
182	//imul r12,TypeSize
183	compiler.codeGenerator.op_imul_RV( sizeof(_int64), REG_R12, type.GetSize() );
184
185	//mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
186	pobj_sf->pop(REG_R11);
187
188	//add r11,r12
189	compiler.codeGenerator.op_add_RR( REG_R11, REG_R12 );
190
191	return true;
192	}
193	bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const Type &classType, const char member, RELATIVE_VAR pRelativeVar, Type &resultType, BOOL bPrivateAccess)
194	{
195	const CClass &objClass = classType.GetClass();
196
197	//////////////////////////////////////
198	// クラス、配列の構成要素を解析する
199	//////////////////////////////////////
200
201	char VarName[VN_SIZE]; //変数名
202	char array[VN_SIZE]; //第1次配列
203	char lpPtrOffset[VN_SIZE]; //第2次配列
204	char NestMember[VN_SIZE]; //入れ子メンバ
205	ReferenceKind refType;
206	lstrcpy(VarName,member);
207	if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
208
209
210	////////////////////////////
211	// メンバオフセットを取得
212	////////////////////////////
213
214	int memberIndex;
215	int offset = objClass.GetMemberOffset( VarName, &memberIndex );
216	if( memberIndex == objClass.GetDynamicMembers().size() ){
217	if(isErrorEnabled) SetError(103,VarName,cp);
218	return false;
219	}
220
221	CMember *pMember = objClass.GetDynamicMembers()[memberIndex];
222
223
224	//アクセシビリティをチェック
225	if(&objClass==compiler.pCompilingClass){
226	//同一クラスオブジェクトの場合はプライベートアクセスを容認する
227	if(pMember->IsNoneAccess()){
228	if(isErrorEnabled) SetError(107,VarName,cp);
229	return false;
230	}
231	}
232	else{
233	if((bPrivateAccess==0&&pMember->IsPrivate())\|\|
234	pMember->IsNoneAccess()){
235	if(isErrorEnabled) SetError(107,VarName,cp);
236	return false;
237	}
238	else if(bPrivateAccess==0&&pMember->IsProtected()){
239	if(isErrorEnabled) SetError(108,VarName,cp);
240	return false;
241	}
242	}
243
244	//Const定義の場合は書き込みアクセスを制限する
245	//※コンストラクタをコンパイル中の場合は例外的に許可する
246	if( pMember->IsConst() && //定数メンバである
247	isWriteAccess && //書き込みアクセスを要求されている
248	objClass.IsCompilingConstructor() == false //コンストラクタコンパイル中を除く
249	){
250	//Const定義の変数に書き込みアクセスをしようとした場合
251	SetError(61,VarName,cp);
252	}
253
254	resultType = pMember->GetType();
255
256	// 型パラメータを解決
257	ResolveFormalGenericTypeParameter( resultType, classType );
258
259	//ポインタ変数の場合
260	if( resultType.IsPointer() ){
261	if( pMember->GetSubscripts().size() == 0 ){
262	lstrcpy(lpPtrOffset,array);
263	array[0]=0;
264	}
265	}
266	else{
267	if(lpPtrOffset[0]){
268	if(isErrorEnabled) SetError(16,member,cp);
269	return false;
270	}
271	}
272
273	if(offset){
274	//add r11,offset
275	compiler.codeGenerator.op_add_RV( REG_R11, offset );
276	}
277
278	if(array[0]){
279	//配列オフセット
280	if(!GetArrayOffset(pMember->GetSubscripts(),array,pMember->GetType())){
281	if(isErrorEnabled) SetError(14,member,cp);
282	}
283	}
284	else if( pMember->GetSubscripts().size() > 0 ){
285	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_PTR );
286	}
287
288	if(NestMember[0]){
289	//入れ子構造の場合
290
291	if( resultType.IsObject() \|\| resultType.IsStruct() ){
292	if( refType != RefDot ){
293	if(isErrorEnabled) SetError(104,member,cp);
294	return false;
295	}
296
297	if( resultType.IsObject() ){
298	// 参照内容へのポインタを抽出
299	SetRelativeOffset( *pRelativeVar );
300	}
301	}
302	else if( resultType.IsObjectPtr() \|\| resultType.IsStructPtr() ){
303	//構造体ポインタ型メンバ変数
304
305	if(lpPtrOffset[0]){
306	//pObj[n].member
307	if( ( resultType.IsObjectPtr() \|\| resultType.IsStructPtr() )
308	&& refType != RefDot ){
309	if(isErrorEnabled) SetError(104,member,cp);
310	return false;
311	}
312
313	//直接参照に切り替え
314	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
315	pRelativeVar->dwKind=VAR_DIRECTMEM;
316
317	lpPtrOffset[0]=0;
318	}
319	else{
320	//pObj->member
321	if( (resultType.IsObjectPtr() \|\| resultType.IsStructPtr() )
322	&& refType != RefPointer ){
323	if(isErrorEnabled) SetError(104,member,cp);
324	return false;
325	}
326
327	SetRelativeOffset( *pRelativeVar );
328	}
329	}
330	else if( resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_OBJECT,2)
331	\|\| resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_STRUCT,2)){
332	//構造体ポインタのポインタ型メンバ変数
333
334	if(lpPtrOffset[0]){
335	//ppObj[n]->member
336	if( refType != RefPointer ){
337	if(isErrorEnabled) SetError(104,member,cp);
338	return false;
339	}
340
341	//直接参照に切り替え
342	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
343	pRelativeVar->dwKind=VAR_DIRECTMEM;
344
345	lpPtrOffset[0]=0;
346
347	//mov r11,qword ptr[r11]
348	compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
349	}
350	else{
351	if(isErrorEnabled) SetError(104,member,cp);
352	return false;
353	}
354	}
355
356	if(!_member_offset(
357	isErrorEnabled,
358	isWriteAccess,
359	pMember->GetType(),
360	NestMember,
361	pRelativeVar,
362	resultType,
363	0)) return false;
364	}
365
366	if(lpPtrOffset[0]){
367	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
368	pRelativeVar->dwKind=VAR_DIRECTMEM;
369	}
370
371	return true;
372	}
373
374	int LocalVar_ThisPtrOffset;
375	void SetThisPtrToReg(int reg){
376	//自身のオブジェクトのThisポインタをregにコピー
377
378	RELATIVE_VAR RelativeVar;
379	RelativeVar.dwKind=VAR_LOCAL;
380	RelativeVar.bOffsetOffset=0;
381	RelativeVar.offset=-LocalVar_ThisPtrOffset;
382
383	SetReg_WholeVariable(Type(DEF_PTR_VOID),&RelativeVar,reg);
384	}
385	bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char NameBuffer,RELATIVE_VAR pRelativeVar,Type &resultType, Subscripts *pResultSubscripts ){
386	char variable[VN_SIZE];
387
388	if(NameBuffer[0]=='.'){
389	GetWithName(variable);
390	lstrcat(variable,NameBuffer);
391	}
392	else lstrcpy(variable,NameBuffer);
393
394	// 名前空間を分離
395	char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
396	compiler.GetObjectModule().meta.GetNamespaces().SplitNamespace( variable, namespaceStr, simpleName );
397
398	// 先頭オブジェクトまたはクラス名と入れ子メンバに分割
399	ReferenceKind refType;
400	char member[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
401	GetVarFormatString(simpleName,array,lpPtrOffset,member,refType);
402
403	// 名前空間を分離していた場合は結合
404	char VarName[VN_SIZE];
405	if( namespaceStr[0] ){
406	sprintf( VarName, "%s.%s", namespaceStr, simpleName );
407	}
408	else{
409	lstrcpy( VarName, simpleName );
410	}
411
412	const Subscripts *pSubscripts;
413	bool bConst = false;
414
415
416	if( UserProc::IsLocalAreaCompiling() ){
417	//////////////////
418	// ローカル変数
419	//////////////////
420
421	const Variable *pVar = UserProc::CompilingUserProc().GetLocalVars().BackSearch( Symbol( VarName ) );
422	if( pVar ){
423	//ポインタ変数の場合
424	if( pVar->GetType().IsPointer() ){
425	if( !pVar->IsArray() ){
426	lstrcpy(lpPtrOffset,array);
427	array[0]=0;
428	}
429	}
430	else{
431	if(lpPtrOffset[0]){
432	SetError(16,variable,cp);
433	pRelativeVar->dwKind=NON_VAR;
434	return false;
435	}
436	}
437
438	pRelativeVar->offset=-pVar->GetOffsetAddress();
439	pRelativeVar->bOffsetOffset=0;
440	if( pVar->IsRef() ){
441	// 参照型
442	pRelativeVar->dwKind = VAR_REFLOCAL;
443	}
444	else pRelativeVar->dwKind=VAR_LOCAL;
445	resultType = pVar->GetType();
446	pSubscripts = &pVar->GetSubscripts();
447	bConst = pVar->IsConst();
448
449	/////////////////////////////////////////////////////////
450	// ☆★☆ ジェネリクスサポート ☆★☆
451
452	if( resultType.IsTypeParameter() )
453	{
454	// 型パラメータだったとき
455
456	int ptrLevel = PTR_LEVEL( resultType.GetBasicType() );
457
458	// TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
459	resultType.SetBasicType( DEF_OBJECT );
460
461	for( int i=0; i<ptrLevel; i++ )
462	{
463	resultType.PtrLevelUp();
464	}
465	}
466
467	//
468	/////////////////////////////////////////////////////////
469
470	goto ok;
471	}
472	}
473
474
475	if(compiler.pCompilingClass){
476	//////////////////////
477	// クラスメンバの参照
478	//////////////////////
479
480	if(lstrcmpi(variable,"This")==0){
481	//自身のオブジェクトのThisポインタをr11にコピー
482	SetThisPtrToReg(REG_R11);
483
484	pRelativeVar->dwKind=VAR_DIRECTMEM;
485
486	resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
487	return true;
488	}
489
490	if(memicmp(variable,"This.",5)==0){
491	//Thisオブジェクトのメンバを参照するとき
492	SlideString(variable+5,-5);
493	lstrcpy(VarName,variable);
494	}
495	else{
496	//クラス内メンバを参照するとき（通常）
497
498	bool isFound = false;
499	BOOST_FOREACH( CMember *pMember, compiler.pCompilingClass->GetDynamicMembers() ){
500	if( pMember->GetName() == VarName ){
501	isFound = true;
502	break;
503	}
504	}
505	if( !isFound ) goto NonClassMember;
506	}
507
508	//Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
509	//（コンストラクタ、デストラクタ内を除く）
510	const CMethod *pMethod = compiler.GetObjectModule().meta.GetClasses().GetNowCompilingMethodInfo();
511	if( isWriteAccess &&
512	pMethod->IsConst() &&
513	compiler.pCompilingClass->IsCompilingConstructor() == false &&
514	compiler.pCompilingClass->IsCompilingDestructor() == false
515	){
516	SetError(131, NULL, cp );
517	}
518
519	//自身のオブジェクトのThisポインタをr11にコピー
520	SetThisPtrToReg(REG_R11);
521
522	pRelativeVar->dwKind=VAR_DIRECTMEM;
523	if(!_member_offset(
524	isErrorEnabled,
525	isWriteAccess,
526	Type( DEF_OBJECT, *compiler.pCompilingClass ),
527	variable,
528	pRelativeVar,
529	resultType,1)) return false;
530	return true;
531	}
532
533	NonClassMember:
534
535	{
536	const Variable *pVar;
537
538	//////////////////////////
539	// 静的ローカル変数
540	// ※"Static.Object.Method.Variable"
541	//////////////////////////
542
543	char temporary[VN_SIZE];
544	if( UserProc::IsLocalAreaCompiling() ){
545	GetNowStaticVarFullName(VarName,temporary);
546
547	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( Symbol( temporary ) );
548	if( pVar ){
549	goto GlobalOk;
550	}
551	}
552
553
554	//////////////////////////
555	// クラスの静的メンバ
556	//////////////////////////
557
558	if(member[0]){
559	lstrcpy(temporary,member);
560
561	// TODO: 名前空間を考慮したコードになっていない
562
563	char tempMember[VN_SIZE];
564	char tempArray[VN_SIZE];
565	{
566	ReferenceKind refType;
567	GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
568	}
569
570	int typeDefIndex = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( VarName );
571	if( typeDefIndex != -1 ){
572	// TypeDef後の型名だったとき
573	lstrcpy( VarName, compiler.GetObjectModule().meta.GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
574	}
575
576	char temp2[VN_SIZE];
577	sprintf(temp2,"%s.%s",VarName,temporary);
578	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( Symbol( temp2 ) );
579	if( pVar ){
580	lstrcpy(member,tempMember);
581	lstrcpy(array,tempArray);
582	goto GlobalOk;
583	}
584	}
585
586	if(compiler.pCompilingClass){
587	//自身のクラスから静的メンバを参照する場合
588	char temp2[VN_SIZE];
589	sprintf(temp2,"%s.%s",compiler.pCompilingClass->GetName().c_str(),VarName);
590	pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( Symbol( temp2 ) );
591	if( pVar ){
592	goto GlobalOk;
593	}
594	}
595
596	/////////////////////
597	// グローバル変数
598	/////////////////////
599
600	pVar = compiler.GetObjectModule().meta.GetGlobalVars().BackSearch( Symbol( VarName ) );
601	if( pVar ){
602	goto GlobalOk;
603	}
604
605	if(isErrorEnabled) SetError(3,variable,cp);
606	pRelativeVar->dwKind=NON_VAR;
607	return false;
608
609
610
611	GlobalOk:
612	//ポインタ変数の場合
613	if( pVar->GetType().IsPointer() ){
614	if( !pVar->IsArray() ){
615	lstrcpy(lpPtrOffset,array);
616	array[0]=0;
617	}
618	}
619	else{
620	if(lpPtrOffset[0]){
621	SetError(16,variable,cp);
622	pRelativeVar->dwKind=NON_VAR;
623	return false;
624	}
625	}
626
627	pRelativeVar->offset=pVar->GetOffsetAddress();
628	pRelativeVar->bOffsetOffset=0;
629	if( pVar->IsRef() ){
630	// 参照型
631	pRelativeVar->dwKind = VAR_REFGLOBAL;
632	}
633	else pRelativeVar->dwKind=VAR_GLOBAL;
634	resultType = pVar->GetType();
635	pSubscripts=&pVar->GetSubscripts();
636	bConst = pVar->IsConst();
637	}
638
639
640
641	ok:
642
643	if( bConst && isWriteAccess ){
644	//Const定義の変数に書き込みアクセスをしようとした場合
645	if( resultType.IsObject() ){
646	//オブジェクト定数
647	SetError(130, VarName, cp );
648	}
649	else{
650	//一般のConst変数
651	SetError(61,VarName,cp);
652	}
653	}
654
655	if( array[0] == 0 && pSubscripts->size() > 0 ){
656	//配列の先頭ポインタを示す場合
657	resultType.SetBasicType( resultType.GetBasicType() \| FLAG_PTR );
658
659	if( pResultSubscripts )
660	{
661	(pResultSubscripts) = pSubscripts;
662	}
663	return true;
664	}
665
666	if( array[0] \|\| member[0] ){
667	//xor r11,r11（r11を0に初期化する）
668	//※r11は変数ベースアドレスからの相対オフセットを示す
669	compiler.codeGenerator.op_zero_reg(REG_R11);
670
671	pRelativeVar->bOffsetOffset=1;
672	}
673	if(array[0]){
674	if(!GetArrayOffset(*pSubscripts,array,resultType)){
675	SetError(14,variable,cp);
676	pRelativeVar->dwKind=NON_VAR;
677	return false;
678	}
679	}
680	if(member[0]){
681	if( resultType.IsObject() \|\| resultType.IsStruct() ){
682	//実態オブジェクトのメンバを参照（obj.member）
683	if( refType != RefDot ){
684	SetError(104,VarName,cp);
685	pRelativeVar->dwKind=NON_VAR;
686	return false;
687	}
688
689	if( resultType.IsObject() ){
690	// 参照内容へのポインタを抽出
691	SetRelativeOffset( *pRelativeVar );
692	}
693	}
694	else if( resultType.IsObjectPtr() \|\| resultType.IsStructPtr() ){
695	//ポインタオブジェクトが示すメンバを参照
696	if(lpPtrOffset[0]){
697	//pObj[n].member
698	if( refType != RefDot ){
699	SetError(104,VarName,cp);
700	pRelativeVar->dwKind=NON_VAR;
701	return false;
702	}
703	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
704	pRelativeVar->dwKind=VAR_DIRECTMEM;
705	}
706	else{
707	//pObj->member
708	if( refType != RefPointer ){
709	SetError(104,VarName,cp);
710	pRelativeVar->dwKind=NON_VAR;
711	return false;
712	}
713
714	SetVarPtrToReg(REG_R12,pRelativeVar);
715	pRelativeVar->dwKind=VAR_DIRECTMEM;
716
717	//mov r11,qword ptr[r12]
718	compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
719	}
720	}
721	else if( resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_OBJECT,2) \|\| resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_STRUCT,2)){
722	//ポインタオブジェクトが示すメンバを参照
723	if(lpPtrOffset[0]){
724	//ppObj[n]->member
725	if( refType != RefPointer ){
726	SetError(104,VarName,cp);
727	pRelativeVar->dwKind=NON_VAR;
728	return false;
729	}
730
731	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
732	pRelativeVar->dwKind=VAR_DIRECTMEM;
733
734
735	SetVarPtrToReg(REG_R12,pRelativeVar);
736
737	//mov r11,qword ptr[r12]
738	compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
739	}
740	else{
741	SetError(104,VarName,cp);
742	pRelativeVar->dwKind=NON_VAR;
743	return false;
744	}
745	}
746	else{
747	SetError(102,VarName,cp);
748	pRelativeVar->dwKind=NON_VAR;
749	return false;
750	}
751
752	if(!_member_offset(
753	isErrorEnabled,
754	isWriteAccess,
755	resultType,
756	member,pRelativeVar,resultType,0)) return false;
757
758	return true;
759	}
760
761	if(lpPtrOffset[0]){
762	SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
763	pRelativeVar->dwKind=VAR_DIRECTMEM;
764	}
765
766	return true;
767	}
768
769	bool SetInitGlobalData(int offset,const Type &type,const Subscripts &subscripts,const char *lpszInitBuf){
770	int i2,i3;
771	char temporary[VN_SIZE];
772	char InitBuf[VN_SIZE];
773	lstrcpy( InitBuf, lpszInitBuf );
774
775	if(InitBuf[0]=='['){
776	SlideString(InitBuf+1,-1);
777	InitBuf[lstrlen(InitBuf)-1]=0;
778
779	int typeSize = type.GetSize();
780
781	if( subscripts.size() > 0 ){
782	Subscripts nestSubscripts;
783	for( int i=1; i<(int)subscripts.size(); i++ )
784	{
785	nestSubscripts.push_back( subscripts[i] );
786	}
787
788	typeSize*=JumpSubScripts( nestSubscripts );
789	{
790	int i=0;
791	i2=0;
792	while(1){
793	if( subscripts[0] < i2 ){
794	SetError(41,0,cp);
795	return 0;
796	}
797	i=GetOneParameter(InitBuf,i,temporary);
798	if(!SetInitGlobalData(
799	offset+i2*typeSize,
800	type,
801	nestSubscripts,
802	temporary)) return false;
803	i2++;
804	if(InitBuf[i]=='\0') break;
805	}
806	}
807	return true;
808	}
809
810	if(type.IsStruct()){
811	const CClass &objClass = type.GetClass();
812
813	int i = 0;
814	BOOST_FOREACH( CMember *pMember, objClass.GetDynamicMembers() ){
815	if(InitBuf[i]=='\0'){
816	SetError(41,0,cp);
817	return false;
818	}
819
820	i=GetOneParameter(InitBuf,i,temporary);
821
822	i3=objClass.GetMemberOffset( pMember->GetName().c_str(), NULL );
823
824	if(!SetInitGlobalData(offset+i3,
825	pMember->GetType(),
826	pMember->GetSubscripts(),
827	temporary)) return false;
828	}
829	return true;
830	}
831
832	SetError(41,0,cp);
833	return false;
834	}
835
836
837	///////////////////////////////////////
838	// 単発式（[]で囲まれていない）
839	///////////////////////////////////////
840
841	if( type.IsObject() \|\| type.IsStruct() ){
842	//オブジェクトまたは構造体の場合はありえない
843	SetError(300,NULL,cp);
844	return false;
845	}
846
847	if( subscripts.size() > 0 ){
848	SetError(41,0,cp);
849	return false;
850	}
851
852	double dbl;
853	_int64 i64data;
854	Type calcType;
855
856	if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
857	//動的データだった場合
858	return false;
859	}
860	if( calcType.IsReal() ){
861	memcpy(&dbl,&i64data,sizeof(double));
862	i64data=(_int64)dbl;
863	}
864	else dbl=(double)i64data;
865
866	//型チェック
867	CheckDifferentType(
868	type,
869	calcType,
870	0,0);
871
872	if( type.IsDouble() ){
873	compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
874	offset,
875	(const char *)&dbl,
876	sizeof(double)
877	);
878	}
879	else if( type.IsSingle() ){
880	float flt = (float)dbl;
881	compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
882	offset,
883	(const char *)&flt,
884	sizeof(float)
885	);
886	}
887	else if( type.Is64() \|\| type.IsPointer() ){
888	if(type.GetBasicType()==typeOfPtrChar){
889	//文字列定数のとき
890
891	char *temp;
892	temp=(char *)i64data;
893	i2=compiler.GetObjectModule().dataTable.AddString( temp );
894	HeapDefaultFree(temp);
895
896	//mov rax,DataPos
897	compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,i2, Schedule::DataTable );
898
899	//mov qword ptr[offset],rax
900	compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,0,offset,MOD_DISP32, Schedule::GlobalVar );
901	}
902	else{
903	compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
904	offset,
905	(const char *)&i64data,
906	sizeof(_int64)
907	);
908	}
909	}
910	else if( type.IsDWord() \|\| type.IsLong() ){
911	long l = (long)i64data;
912	compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
913	offset,
914	(const char *)&l,
915	sizeof(long)
916	);
917	}
918	else if( type.IsWord() \|\| type.IsInteger() ){
919	short s = (short)i64data;
920	compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
921	offset,
922	(const char *)&s,
923	sizeof(short)
924	);
925	}
926	else if( type.IsSByte() \|\| type.IsByte() \|\| type.IsBoolean() ){
927	char c = (char)i64data;
928	compiler.GetObjectModule().meta.GetGlobalVars().initAreaBuffer.Overwrite(
929	offset,
930	(const char *)&c,
931	sizeof(char)
932	);
933	}
934
935	return true;
936	}
937	bool InitLocalVar(int offset,const Type &type,const Subscripts &subscripts,const char *lpszInitBuf){
938	int i2,i3;
939	char temporary[VN_SIZE];
940	char InitBuf[VN_SIZE];
941	lstrcpy( InitBuf, lpszInitBuf );
942
943	if(InitBuf[0]=='['){
944	SlideString(InitBuf+1,-1);
945	InitBuf[lstrlen(InitBuf)-1]=0;
946
947	int typeSize = type.GetSize();
948
949	if( subscripts.size() > 0 ){
950	Subscripts nestSubscripts;
951	for( int i=1; i<(int)subscripts.size(); i++ )
952	{
953	nestSubscripts.push_back( subscripts[i] );
954	}
955
956	typeSize*=JumpSubScripts( nestSubscripts );
957	{
958	int i=0;
959	i2=0;
960	while(1){
961	if( subscripts[0] < i2 ){
962	SetError(41,0,cp);
963	return 0;
964	}
965	i=GetOneParameter(InitBuf,i,temporary);
966	if(!InitLocalVar(
967	offset+i2*typeSize,
968	type,
969	nestSubscripts,
970	temporary)) return false;
971	i2++;
972	if(InitBuf[i]=='\0') break;
973	}
974	}
975	return true;
976	}
977
978	if(type.IsStruct()){
979	const CClass &objClass = type.GetClass();
980
981	int i = 0;
982	BOOST_FOREACH( CMember *pMember, objClass.GetDynamicMembers() ){
983	if(InitBuf[i]=='\0'){
984	SetError(41,0,cp);
985	return false;
986	}
987
988	i=GetOneParameter(InitBuf,i,temporary);
989
990	i3=objClass.GetMemberOffset( pMember->GetName().c_str(), NULL );
991
992	if(!InitLocalVar(offset+i3,
993	pMember->GetType(),
994	pMember->GetSubscripts(),
995	temporary)) return false;
996
997	if(InitBuf[i]=='\0') break;
998	}
999	return true;
1000	}
1001
1002	SetError(41,0,cp);
1003	return false;
1004	}
1005
1006
1007	///////////////////////////////////////
1008	// 単発式（[]で囲まれていない）
1009	///////////////////////////////////////
1010
1011	if( subscripts.size() > 0 ){
1012	SetError(41,0,cp);
1013	return false;
1014	}
1015
1016	double dbl;
1017	_int64 i64data;
1018	Type calcType;
1019
1020	if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
1021	//動的データだった場合
1022	return false;
1023	}
1024	if( calcType.IsReal() ){
1025	memcpy(&dbl,&i64data,sizeof(double));
1026	i64data=(_int64)dbl;
1027	}
1028	else dbl=(double)i64data;
1029
1030	//型チェック
1031	CheckDifferentType(
1032	type,
1033	calcType,
1034	0,0);
1035
1036	if( type.IsDouble() ){
1037	memcpy(&i64data,&dbl,sizeof(double));
1038
1039	//mov rax,i64data
1040	compiler.codeGenerator.op_mov_RV64(REG_RAX,i64data);
1041
1042	//mov qword ptr[rsp+offset],rax
1043	compiler.codeGenerator.localVarPertialSchedules.push_back(
1044	compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32, Schedule::None, true )
1045	);
1046	}
1047	else if( type.IsSingle() ){
1048	float flt;
1049	flt=(float)dbl;
1050
1051	//mov dword ptr[rsp+offset],value
1052	compiler.codeGenerator.localVarPertialSchedules.push_back(
1053	compiler.codeGenerator.op_mov_MV(sizeof(long),REG_RSP,offset, Schedule::None, true, USE_OFFSET,(int )&flt)
1054	);
1055	}
1056	else if( type.Is64() \|\| type.IsPointer() ){
1057	if(type.GetBasicType()==typeOfPtrChar ){
1058	//文字列定数のとき
1059
1060	char *temp;
1061	temp=(char *)i64data;
1062	i2=compiler.GetObjectModule().dataTable.AddString( temp );
1063	HeapDefaultFree(temp);
1064
1065	//mov rax,i2
1066	compiler.codeGenerator.op_mov_RV(sizeof(_int64),REG_RAX,i2, Schedule::DataTable );
1067
1068	//mov qword ptr[rsp+offset],rax
1069	compiler.codeGenerator.localVarPertialSchedules.push_back(
1070	compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32, Schedule::None, true )
1071	);
1072	}
1073	else{
1074	if(i64data&0xFFFFFFFF00000000){
1075	//mov rax,i64data
1076	compiler.codeGenerator.op_mov_RV64(REG_RAX,i64data);
1077
1078	//mov qword ptr[rsp+offset],rax
1079	compiler.codeGenerator.localVarPertialSchedules.push_back(
1080	compiler.codeGenerator.op_mov_MR(sizeof(_int64),REG_RAX,REG_RSP,offset,MOD_BASE_DISP32, Schedule::None, true )
1081	);
1082	}
1083	else{
1084	//mov qword ptr[rsp+offset],value
1085	compiler.codeGenerator.localVarPertialSchedules.push_back(
1086	compiler.codeGenerator.op_mov_MV(sizeof(_int64),REG_RSP,offset, Schedule::None, true, USE_OFFSET,(int)i64data)
1087	);
1088	}
1089	}
1090	}
1091	else if( type.IsDWord() \|\| type.IsLong() ){
1092	//mov dword ptr[rsp+offset],value
1093	compiler.codeGenerator.localVarPertialSchedules.push_back(
1094	compiler.codeGenerator.op_mov_MV(sizeof(long),REG_RSP,offset, Schedule::None, true, USE_OFFSET,(int)i64data)
1095	);
1096	}
1097	else if( type.IsWord() \|\| type.IsInteger() ){
1098	//mov word ptr[rsp+offset],value
1099	compiler.codeGenerator.localVarPertialSchedules.push_back(
1100	compiler.codeGenerator.op_mov_MV(sizeof(short),REG_RSP,offset, Schedule::None, true, USE_OFFSET,(int)i64data)
1101	);
1102	}
1103	else if( type.IsSByte() \|\| type.IsByte() \|\| type.IsBoolean() ){
1104	//mov byte ptr[rsp+offset],value
1105	compiler.codeGenerator.localVarPertialSchedules.push_back(
1106	compiler.codeGenerator.op_mov_MV(sizeof(char),REG_RSP,offset, Schedule::None, true, USE_OFFSET,(int)i64data)
1107	);
1108	}
1109	return true;
1110	}
1111
1112	void dim( char VarName, const Subscripts &subscripts, const Type &type,const char InitBuf,const char *ConstractParameter,DWORD dwFlags)
1113	{
1114	if( UserProc::IsGlobalAreaCompiling() ){
1115	/////////////////////////
1116	// グローバル変数
1117	/////////////////////////
1118
1119	AddGlobalVariable(VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags);
1120	}
1121	else{
1122	/////////////////
1123	// ローカル変数
1124	/////////////////
1125
1126	if( UserProc::CompilingUserProc().GetLocalVars().DuplicateCheck( VarName ) ){
1127	//２重定義のエラー
1128	SetError(15,VarName,cp);
1129	return;
1130	}
1131
1132	bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
1133
1134	Variable *pVar = new Variable( VarName, type, isConst, false, ConstractParameter, false );
1135
1136	if( subscripts.size() > 0 ){
1137	//配列あり
1138	pVar->SetArray( subscripts );
1139	}
1140
1141	//レキシカルスコープ
1142	pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
1143	pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
1144	pVar->bLiving=TRUE;
1145
1146	//エラー用
1147	pVar->source_code_address=cp;
1148
1149	// 変数を追加
1150	UserProc::CompilingUserProc().GetLocalVars().push_back( pVar );
1151
1152	//アラインメントを考慮
1153	if( pVar->GetType().IsStruct() ){
1154	int alignment = pVar->GetType().GetClass().GetFixedAlignment();
1155
1156	if( alignment ){
1157	if( AllLocalVarSize % alignment ){
1158	AllLocalVarSize += alignment - (AllLocalVarSize % alignment);
1159	}
1160	}
1161
1162	if( alignment == PTR_SIZE*2 ){
1163	// ポインタに要するサイズよりも一回り大きなアラインメントが指定されているとき
1164	// （例:CONTEXT構造体など）
1165	// 呼び出し側のオフセットズレを考慮する
1166
1167	if( 0 == ( UserProc::CompilingUserProc().RealParams().GetMemorySize() + PTR_SIZE/ret分/ ) % alignment ){
1168	AllLocalVarSize += PTR_SIZE;
1169	}
1170	}
1171	}
1172
1173	AllLocalVarSize += pVar->GetMemorySize();
1174	pVar->SetOffsetAddress( AllLocalVarSize );
1175
1176	//レキシカルスコープ
1177	pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
1178	pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
1179	pVar->bLiving=TRUE;
1180
1181	if(InitBuf[0]){
1182	//初期代入時のみ、書き込みアクセスを許可する
1183	if( isConst ){
1184	pVar->ConstOff();
1185	}
1186
1187	int result = 0;
1188	if( !pVar->GetType().IsObject() ){
1189	result = InitLocalVar(-pVar->GetOffsetAddress(),
1190	pVar->GetType(),
1191	pVar->GetSubscripts(),
1192	InitBuf);
1193	}
1194
1195	if(!result){
1196	//動的な式だった場合は代入演算を行う
1197	char temporary[8192];
1198	sprintf(temporary,"%s=%s",VarName,InitBuf);
1199	OpcodeCalc(temporary);
1200	}
1201
1202	if( isConst ){
1203	pVar->ConstOn();
1204	}
1205	}
1206	else{
1207	//0初期化
1208
1209	//mov r8, 0
1210	compiler.codeGenerator.op_zero_reg( REG_R8 );
1211
1212	//mov rdx, VarSize
1213	compiler.codeGenerator.op_mov_RV( sizeof(_int64), REG_RDX, pVar->GetMemorySize() );
1214
1215	//mov rcx, rsp
1216	compiler.codeGenerator.op_mov_RR( REG_RCX, REG_RSP );
1217
1218	//add rcx, offset
1219	compiler.codeGenerator.localVarPertialSchedules.push_back(
1220	compiler.codeGenerator.op_add_RV( REG_RCX, -pVar->GetOffsetAddress(), Schedule::None, true )
1221	);
1222
1223	//call FillMemory
1224	DllProc *pDllProc;
1225	pDllProc=GetDeclareHash("FillMemory");
1226	compiler.codeGenerator.op_call( pDllProc );
1227	}
1228	}
1229
1230	//コンストラクタ呼び出し
1231	if( type.IsObject() &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
1232	char objectSize[255];
1233	if( subscripts.size() == 0 ){
1234	objectSize[0] = 0;
1235	}
1236	else{
1237	if( subscripts.size() > 1 ){
1238	SetError(300,NULL,cp);
1239	}
1240	sprintf( objectSize, "%d", subscripts[0] );
1241	}
1242	Operator_New( type.GetClass(), objectSize, ConstractParameter, type );
1243
1244	Type tempType;
1245	RELATIVE_VAR RelativeVar;
1246	GetVarOffset( true, false, VarName, &RelativeVar, tempType );
1247	if( RelativeVar.dwKind == VAR_DIRECTMEM ){
1248	SetError();
1249	}
1250	SetVariableFromRax( Type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr() ), DEF_OBJECT, &RelativeVar );
1251	}
1252	}
1253	void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
1254	if(!IsGeneralReg(reg)) SetError(300,NULL,cp);
1255
1256	if(pRelativeVar->dwKind==VAR_GLOBAL){
1257	if(pRelativeVar->bOffsetOffset){
1258	//add r11,offset
1259	compiler.codeGenerator.op_add_RV( REG_R11, (long)pRelativeVar->offset, Schedule::GlobalVar );
1260
1261	//mov reg,r11
1262	compiler.codeGenerator.op_mov_RR(reg,REG_R11);
1263	}
1264	else{
1265	//mov reg,offset
1266	compiler.codeGenerator.op_mov_RV( sizeof(_int64), reg, (long)pRelativeVar->offset, Schedule::GlobalVar );
1267	}
1268	}
1269	else if( pRelativeVar->dwKind == VAR_REFGLOBAL ){
1270	if(pRelativeVar->bOffsetOffset){
1271	//add r11,qword ptr[offset]
1272	compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelativeVar->offset, MOD_DISP32, Schedule::GlobalVar );
1273	}
1274	else{
1275	//mov r11,qword ptr[offset]
1276	compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32, Schedule::GlobalVar );
1277	}
1278
1279	goto directmem;
1280	}
1281	else if(pRelativeVar->dwKind==VAR_LOCAL){
1282	if(pRelativeVar->bOffsetOffset){
1283	//add r11,offset
1284	compiler.codeGenerator.localVarPertialSchedules.push_back(
1285	compiler.codeGenerator.op_add_RV( REG_R11, (long)pRelativeVar->offset, Schedule::None, true )
1286	);
1287
1288	//add r11,rsp
1289	compiler.codeGenerator.op_add_RR(REG_R11,REG_RSP);
1290
1291	//mov reg,r11
1292	compiler.codeGenerator.op_mov_RR(reg,REG_R11);
1293	}
1294	else{
1295	//mov reg,rsp
1296	compiler.codeGenerator.op_mov_RR(reg,REG_RSP);
1297
1298	//add reg,offset
1299	compiler.codeGenerator.localVarPertialSchedules.push_back(
1300	compiler.codeGenerator.op_add_RV(reg,(long)pRelativeVar->offset, Schedule::None, true )
1301	);
1302	}
1303	}
1304	else if( pRelativeVar->dwKind == VAR_REFLOCAL ){
1305	if(pRelativeVar->bOffsetOffset){
1306	//add r11,qword ptr[rsp+offset]
1307	compiler.codeGenerator.localVarPertialSchedules.push_back(
1308	compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::None, true )
1309	);
1310	}
1311	else{
1312	//mov r11,qword ptr[rsp+offset]
1313	compiler.codeGenerator.localVarPertialSchedules.push_back(
1314	compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
1315	);
1316	}
1317
1318	goto directmem;
1319	}
1320	else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
1321	directmem:
1322	//mov reg,r11
1323	compiler.codeGenerator.op_mov_RR(reg,REG_R11);
1324	}
1325	}
1326
1327	bool Compile_AddGlobalRootsForGc(){
1328	const UserProc *pUserProc_AddGlobalRootPtr = GetClassMethod( "_System_CGarbageCollection", "AddGlobalRootPtr" );
1329	if( !pUserProc_AddGlobalRootPtr ){
1330	SetError(3, "_System_CGarbageCollection.AddGlobalRootPtr", -1 );
1331	return false;
1332	}
1333
1334	BOOST_FOREACH( const Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
1335	if( pVar->GetType().IsObject() \|\| pVar->GetType().IsPointer() \|\| pVar->GetType().IsStruct() ){
1336	// オブジェクトまたはポインタだったとき
1337	// ※構造体も含む（暫定対応）
1338
1339	// 変数領域に要するLONG_PTR単位の個数を引き渡す
1340	//mov r8,count
1341	compiler.codeGenerator.op_mov_RV(sizeof(_int64), REG_R8,pVar->GetMemorySize()/PTR_SIZE);
1342
1343	// ルートポインタを引き渡す
1344	//mov rdx,offset
1345	compiler.codeGenerator.op_mov_RV(sizeof(_int64), REG_RDX,(int)pVar->GetOffsetAddress(), Schedule::GlobalVar );
1346
1347	// Thisポインタを引き渡す
1348	SetThisPtrToReg(REG_RCX);
1349
1350	// call AddGlobalRootPtr
1351	compiler.codeGenerator.op_call( pUserProc_AddGlobalRootPtr );
1352	}
1353	}
1354
1355	return true;
1356	}

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

Download in other formats: