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

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