source: dev/trunk/abdev/BasicCompiler32/Compile_Var.cpp@ 299

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