source: dev/trunk/ab5.0/abdev/BasicCompiler64/Compile_Var.cpp@ 463

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

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