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

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