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

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

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