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

Last change on this file since 402 was 402, checked in by dai_9181, 16 years ago

UserProc::SetParamsAndReturnTypeメソッドをリファクタリング
LexicalAnalysis.hのインクルードを除去した
File size: 34.7 KB
Line 
1#include "stdafx.h"
2
3#include <jenga/include/smoothie/Smoothie.h>
4
5#include <CodeGenerator.h>
6#include <Compiler.h>
7#include <Variable.h>
8
9#include "../BasicCompiler_Common/common.h"
10#include "Opcode.h"
11
12//変数
13// TODO: xml未完成
14int AllLocalVarSize;
15
16
17void SetRelativeOffset( Type &resultType, RELATIVE_VAR *pRelativeVar,const char *lpPtrOffset){
18 /////////////////////////////////////////////
19 // 先頭ポインタをr12に取得してメモリへ退避
20 /////////////////////////////////////////////
21
22 SetReg_WholeVariable(Type(DEF_INT64),pRelativeVar,REG_R11);
23
24 //mov qword ptr[rsp+offset],r11 ※スタックフレームを利用
25 pobj_sf->push(REG_R11);
26
27
28 ////////////////////////////////
29 // 添え字を計算する
30 ////////////////////////////////
31
32 int reg=REG_NON;
33 Type type;
34 NumOpe( &reg, lpPtrOffset, Type(), type );
35 if( !type.IsWhole() ){
36 SetError(46,NULL,cp);
37 }
38 ExtendTypeTo64(type.GetBasicType(),reg);
39
40 if(reg==REG_R14){
41 //mov r14,qword ptr[rsp+offset] ※スタックフレームを利用
42 pobj_sf->pop(REG_R14);
43 }
44
45 if( resultType.PtrLevel() ){
46 resultType.PtrLevelDown();
47
48 int typeSize = resultType.GetSize();
49 if(typeSize>=2){
50 //imul reg,i2
51 compiler.codeGenerator.op_imul_RV(sizeof(_int64),reg,typeSize);
52 }
53 }
54 else{
55 //エラー
56 SetError(1,NULL,cp);
57 return;
58 }
59
60
61 //////////////////////////////
62 // 先頭ポインタに添え字を加算
63 //////////////////////////////
64
65 //mov r11,qword ptr[rsp+offset] ※スタックフレームを利用
66 pobj_sf->pop(REG_R11);
67
68 //add r11,reg
69 compiler.codeGenerator.op_add_RR(REG_R11,reg);
70}
71void SetRelativeOffset( RELATIVE_VAR &relativeVar ){
72 if(relativeVar.dwKind==VAR_DIRECTMEM){
73 //mov r11,qword ptr[r11]
74 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
75 }
76 else{
77 //直接参照に切り替え
78 SetVarPtrToReg(REG_R12,&relativeVar);
79 relativeVar.dwKind=VAR_DIRECTMEM;
80
81 //mov r11,qword ptr[r12]
82 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
83 }
84}
85bool GetArrayOffset(const Subscripts &subscripts,char *array, const Type &type){
86 extern HANDLE hHeap;
87 int i,i2,i3,i4;
88 char temporary[VN_SIZE],*pParm[MAX_PARMS];
89
90 for(i=0,i2=0,i3=0;;i++,i2++){
91 if(array[i]=='('){
92 i4=GetStringInPare(temporary+i2,array+i);
93 i+=i4-1;
94 i2+=i4-1;
95 continue;
96 }
97 if(array[i]=='['){
98 i4=GetStringInBracket(temporary+i2,array+i);
99 i+=i4-1;
100 i2+=i4-1;
101 continue;
102 }
103 if(array[i]==','||array[i]=='\0'){
104 if( i3 >= (int)subscripts.size() )
105 {
106 for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
107 return false;
108 }
109
110 temporary[i2]=0;
111
112 pParm[i3]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
113 lstrcpy(pParm[i3],temporary);
114
115 i3++;
116
117 if(array[i]=='\0'){
118 if( i3 < (int)subscripts.size() )
119 {
120 for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
121 return false;
122 }
123 break;
124 }
125
126 i2=-1;
127 continue;
128 }
129 temporary[i2]=array[i];
130 }
131
132 //mov qword ptr[rsp+offset],r11 ※スタックフレームを利用
133 pobj_sf->push(REG_R11);
134
135 //xor r12,r12
136 compiler.codeGenerator.op_zero_reg(REG_R12);
137
138 for(i=i3-1;i>=0;i--){
139 //mov qword ptr[rsp+offset],r12 ※スタックフレームを利用
140 pobj_sf->push(REG_R12);
141
142 int reg=REG_NON;
143 Type type;
144 BOOL bUseHeap;
145 NumOpe( &reg, pParm[i], Type( DEF_LONG ), type, &bUseHeap );
146 if( type.IsObject() ){
147 //キャスト演算子のオーバーロードに対応する
148 CallCastOperatorProc(reg,
149 type,
150 bUseHeap, Type(DEF_LONG) );
151 type.SetBasicType( DEF_LONG );
152 }
153
154 if( !type.IsWhole() ){
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 int memberIndex;
211 int offset = objClass.GetMemberOffset( VarName, &memberIndex );
212 if( memberIndex == objClass.GetDynamicMembers().size() ){
213 if(isErrorEnabled) SetError(103,VarName,cp);
214 return false;
215 }
216
217 CMember *pMember = objClass.GetDynamicMembers()[memberIndex];
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 // 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->isLiving = 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->isLiving = 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 //New呼び出し
1228 if( type.IsObject()
1229 && !type.IsInterface() && !type.IsComInterface()
1230 &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0
1231 &&InitBuf[0]=='\0')
1232 {
1233 char objectSize[255];
1234 if( subscripts.size() == 0 ){
1235 objectSize[0] = 0;
1236 }
1237 else{
1238 if( subscripts.size() > 1 ){
1239 SetError(300,NULL,cp);
1240 }
1241 sprintf( objectSize, "%d", subscripts[0] );
1242 }
1243 Operator_New( type.GetClass(), objectSize, ConstractParameter, type );
1244
1245 Type tempType;
1246 RELATIVE_VAR RelativeVar;
1247 GetVarOffset( true, false, VarName, &RelativeVar, tempType );
1248 if( RelativeVar.dwKind == VAR_DIRECTMEM ){
1249 SetError();
1250 }
1251 SetVariableFromRax( Type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr() ), DEF_OBJECT, &RelativeVar );
1252 }
1253}
1254void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
1255 if(!IsGeneralReg(reg)) SetError(300,NULL,cp);
1256
1257 if(pRelativeVar->dwKind==VAR_GLOBAL){
1258 if(pRelativeVar->bOffsetOffset){
1259 //add r11,offset
1260 compiler.codeGenerator.op_add_RV( REG_R11, (long)pRelativeVar->offset, Schedule::GlobalVar );
1261
1262 //mov reg,r11
1263 compiler.codeGenerator.op_mov_RR(reg,REG_R11);
1264 }
1265 else{
1266 //mov reg,offset
1267 compiler.codeGenerator.op_mov_RV( sizeof(_int64), reg, (long)pRelativeVar->offset, Schedule::GlobalVar );
1268 }
1269 }
1270 else if( pRelativeVar->dwKind == VAR_REFGLOBAL ){
1271 if(pRelativeVar->bOffsetOffset){
1272 //add r11,qword ptr[offset]
1273 compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_NON, (int)pRelativeVar->offset, MOD_DISP32, Schedule::GlobalVar );
1274 }
1275 else{
1276 //mov r11,qword ptr[offset]
1277 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_NON,(int)pRelativeVar->offset,MOD_DISP32, Schedule::GlobalVar );
1278 }
1279
1280 goto directmem;
1281 }
1282 else if(pRelativeVar->dwKind==VAR_LOCAL){
1283 if(pRelativeVar->bOffsetOffset){
1284 //add r11,offset
1285 compiler.codeGenerator.localVarPertialSchedules.push_back(
1286 compiler.codeGenerator.op_add_RV( REG_R11, (long)pRelativeVar->offset, Schedule::None, true )
1287 );
1288
1289 //add r11,rsp
1290 compiler.codeGenerator.op_add_RR(REG_R11,REG_RSP);
1291
1292 //mov reg,r11
1293 compiler.codeGenerator.op_mov_RR(reg,REG_R11);
1294 }
1295 else{
1296 //mov reg,rsp
1297 compiler.codeGenerator.op_mov_RR(reg,REG_RSP);
1298
1299 //add reg,offset
1300 compiler.codeGenerator.localVarPertialSchedules.push_back(
1301 compiler.codeGenerator.op_add_RV(reg,(long)pRelativeVar->offset, Schedule::None, true )
1302 );
1303 }
1304 }
1305 else if( pRelativeVar->dwKind == VAR_REFLOCAL ){
1306 if(pRelativeVar->bOffsetOffset){
1307 //add r11,qword ptr[rsp+offset]
1308 compiler.codeGenerator.localVarPertialSchedules.push_back(
1309 compiler.codeGenerator.op_add_RM( sizeof(_int64), REG_R11, REG_RSP, (long)pRelativeVar->offset, MOD_BASE_DISP32, Schedule::None, true )
1310 );
1311 }
1312 else{
1313 //mov r11,qword ptr[rsp+offset]
1314 compiler.codeGenerator.localVarPertialSchedules.push_back(
1315 compiler.codeGenerator.op_mov_RM(sizeof(_int64),REG_R11,REG_RSP,(int)pRelativeVar->offset,MOD_BASE_DISP32, Schedule::None, true )
1316 );
1317 }
1318
1319 goto directmem;
1320 }
1321 else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
1322directmem:
1323 //mov reg,r11
1324 compiler.codeGenerator.op_mov_RR(reg,REG_R11);
1325 }
1326}
1327
1328bool Compile_AddGlobalRootsForGc(){
1329 const UserProc *pUserProc_AddGlobalRootPtr = GetClassMethod( "_System_CGarbageCollection", "AddGlobalRootPtr" );
1330 if( !pUserProc_AddGlobalRootPtr ){
1331 SetError(3, "_System_CGarbageCollection.AddGlobalRootPtr", -1 );
1332 return false;
1333 }
1334
1335 BOOST_FOREACH( const Variable *pVar, compiler.GetObjectModule().meta.GetGlobalVars() ){
1336 if( pVar->GetType().IsObject() || pVar->GetType().IsPointer() || pVar->GetType().IsStruct() ){
1337 // オブジェクトまたはポインタだったとき
1338 // ※構造体も含む（暫定対応）
1339
1340 // 変数領域に要するLONG_PTR単位の個数を引き渡す
1341 //mov r8,count
1342 compiler.codeGenerator.op_mov_RV(sizeof(_int64), REG_R8,pVar->GetMemorySize()/PTR_SIZE);
1343
1344 // ルートポインタを引き渡す
1345 //mov rdx,offset
1346 compiler.codeGenerator.op_mov_RV(sizeof(_int64), REG_RDX,(int)pVar->GetOffsetAddress(), Schedule::GlobalVar );
1347
1348 // Thisポインタを引き渡す
1349 SetThisPtrToReg(REG_RCX);
1350
1351 // call AddGlobalRootPtr
1352 compiler.codeGenerator.op_call( pUserProc_AddGlobalRootPtr );
1353 }
1354 }
1355
1356 return true;
1357}
Note: See TracBrowser for help on using the repository browser.