source: dev/trunk/ab5.0/abdev/BasicCompiler_Common/VariableOpe.cpp @ 536

Last change on this file since 536 was 536, checked in by dai_9181, 15 years ago

Compiler::pCompilingClassメンバをprivateにし、setter/getterにあたるメソッドを用意した。

File size: 26.5 KB
Line 
1#include "stdafx.h"
2
3#include <Compiler.h>
4#include <LexicalScope.h>
5#include <Variable.h>
6
7#include "../BasicCompiler_Common/common.h"
8
9#ifdef _AMD64_
10#include "../compiler_x64/opcode.h"
11#else
12#include "../compiler_x86/opcode.h"
13#endif
14
15using namespace ActiveBasic::Compiler;
16
17BOOL IsPtrType(int type){
18    if(type==-1) return 0;
19
20    if(PTR_LEVEL(type)||type==DEF_PTR_VOID||type==DEF_PTR_PROC||
21        (type&FLAG_PTR) ) return 1;
22
23    return 0;
24}
25BOOL IsSignedType(int type){
26    switch(type){
27        case DEF_SBYTE:
28        case DEF_INTEGER:
29        case DEF_LONG:
30        case DEF_INT64:
31        case DEF_SINGLE:
32        case DEF_DOUBLE:
33        case DEF_CHAR:
34            return 1;
35        default:
36            break;
37    }
38    return 0;
39}
40BOOL IsNaturalWholeNumberType(int type){
41    switch(type){
42        case DEF_SBYTE:
43        case DEF_BYTE:
44        case DEF_INTEGER:
45        case DEF_WORD:
46        case DEF_LONG:
47        case DEF_DWORD:
48        case DEF_INT64:
49        case DEF_QWORD:
50        case DEF_CHAR:
51            return 1;
52        default:
53            break;
54    }
55    return 0;
56}
57BOOL IsWholeNumberType(int type){
58    return (
59        IsNaturalWholeNumberType(type)
60        || IsPtrType(type)
61        || type == DEF_BOOLEAN
62        );
63}
64BOOL IsRealNumberType(int type){
65    switch(type){
66        case DEF_DOUBLE:
67        case DEF_SINGLE:
68            return 1;
69        default:
70            break;
71    }
72    return 0;
73}
74BOOL Is64Type(int type){
75    switch(type){
76        case DEF_INT64:
77        case DEF_QWORD:
78            return 1;
79        default:
80            break;
81    }
82#ifdef _AMD64_
83    return IsPtrType(type);
84#else
85    return 0;
86#endif
87}
88int GetSignedType(int type){
89    switch(type){
90        case DEF_BYTE:
91            return DEF_SBYTE;
92        case DEF_WORD:
93            return DEF_INTEGER;
94        case DEF_DWORD:
95            return DEF_LONG;
96        case DEF_QWORD:
97            return DEF_INT64;
98        default:
99            break;
100    }
101#ifdef _AMD64_
102    if(IsPtrType(type)) return DEF_INT64;
103#else
104    if(IsPtrType(type)) return DEF_LONG;
105#endif
106    return type;
107}
108int GetUnsignedType(int type){
109    switch(type){
110        case DEF_SBYTE:
111            return DEF_BYTE;
112        case DEF_INTEGER:
113            return DEF_WORD;
114        case DEF_LONG:
115            return DEF_DWORD;
116        case DEF_INT64:
117            return DEF_QWORD;
118        case DEF_CHAR:
119            if( compiler.IsUnicode() ) return DEF_WORD;
120            return DEF_BYTE;
121    }
122    return type;
123}
124int GetPtrType(int type){
125    return MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)+1);
126}
127BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name){
128    if(PTR_LEVEL(type)){
129        //ポインタ型
130        name[0]='*';
131        return GetTypeName(MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)-1),lpIndex,name+1);
132    }
133
134    //整数型
135    if(type==DEF_SBYTE)             lstrcpy(name,"SByte");
136    else if(type==DEF_BYTE)         lstrcpy(name,"Byte");
137    else if(type==DEF_INTEGER)      lstrcpy(name,"Integer");
138    else if(type==DEF_WORD)         lstrcpy(name,"Word");
139    else if(type==DEF_LONG)         lstrcpy(name,"Long");
140    else if(type==DEF_DWORD)        lstrcpy(name,"DWord");
141    else if(type==DEF_INT64)        lstrcpy(name,"Int64");
142    else if(type==DEF_QWORD)        lstrcpy(name,"QWord");
143
144    //実数型
145    else if(type==DEF_SINGLE)       lstrcpy(name,"Single");
146    else if(type==DEF_DOUBLE)       lstrcpy(name,"Double");
147
148    //文字型
149    //else if(type==DEF_CHAR)               lstrcpy(name,"Char");
150
151    //bool型
152    else if(type==DEF_BOOLEAN)      lstrcpy(name,"Boolean");
153
154    //オブジェクト
155    else if(type==DEF_OBJECT || type==DEF_STRUCT){
156        if(lpIndex==0) lstrcpy(name,"non");
157        else{
158            lstrcpy(name,((CClass *)lpIndex)->GetName().c_str());
159        }
160    }
161
162    //ポインタ型
163    else if(type==DEF_PTR_VOID)     lstrcpy(name,"VoidPtr");
164
165    else if(type==DEF_PTR_PROC){
166        if(lpIndex==-1) lstrcpy(name,"VoidPtr");
167        else{
168            if( compiler.GetObjectModule().meta.GetProcPointers()[lpIndex]->ReturnType().IsNull() )
169                lstrcpy(name,"*Sub");
170            else lstrcpy(name,"*Function");
171        }
172    }
173
174    else{
175        extern int cp;
176        compiler.errorMessenger.Output(1,NULL,cp);
177        return 0;
178    }
179    return 1;
180}
181
182Type GetStringTypeInfo(){
183    Type type( DEF_OBJECT, *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
184    return type;
185}
186
187void GetWithName(char *buffer){
188    extern WITHINFO WithInfo;
189    int i;
190
191    buffer[0]=0;
192    for(i=0;i<WithInfo.num;i++)
193        lstrcat(buffer,WithInfo.ppName[i]);
194}
195
196
197void GetArrange(char *variable,char *variAnswer, Subscripts &subscripts ){
198    extern int cp;
199    int i,i2,i4;
200    double dbl;
201    _int64 i64data;
202    BOOL bBracket;
203    char temporary[VN_SIZE];
204
205    for(i=0;;i++){
206        if(variable[i]=='('||variable[i]=='['){
207            if(variable[i]=='[') bBracket=1;
208            else bBracket=0;
209
210            variAnswer[i]=0;
211            for(i++,i2=0;;i++,i2++){
212                if(variable[i]==','){
213                    temporary[i2]=0;
214
215                    Type resultType;
216                    if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
217                        return;
218                    }
219                    if(resultType.IsReal()){
220                        memcpy(&dbl,&i64data,sizeof(double));
221                        i64data=(_int64)dbl;
222                    }
223
224                    if(i64data<0)
225                    {
226                        //error
227                        subscripts.push_back( 0 );
228                    }
229                    else
230                    {
231                        subscripts.push_back( (int)i64data );
232                    }
233                    i2=-1;
234                    continue;
235                }
236                if(variable[i]=='('){
237                    i4=GetStringInPare(temporary+i2,variable+i);
238                    i2+=i4-1;
239                    i+=i4-1;
240                    continue;
241                }
242                if(variable[i]=='['){
243                    i4=GetStringInBracket(temporary+i2,variable+i);
244                    i2+=i4-1;
245                    i+=i4-1;
246                    continue;
247                }
248                if(variable[i]==')'&&bBracket==0||
249                    variable[i]==']'&&bBracket){
250                    temporary[i2]=0;
251                    if(i2==0){
252                        subscripts.push_back( -2 );
253                        break;
254                    }
255
256                    Type resultType;
257                    if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
258                        return;
259                    }
260                    if(resultType.IsReal()){
261                        memcpy(&dbl,&i64data,sizeof(double));
262                        i64data=(_int64)dbl;
263                    }
264
265                    if(i64data<0){
266                        //error
267                        subscripts.push_back( 0 );
268                    }
269                    else
270                    {
271                        subscripts.push_back( (int)i64data );
272                    }
273                    break;
274                }
275                if(variable[i]=='\"'){
276                    compiler.errorMessenger.Output(1,NULL,cp);
277                    return;
278                }
279                temporary[i2]=variable[i];
280            }
281            break;
282        }
283        variAnswer[i]=variable[i];
284        if(variable[i]=='\0'){
285            break;
286        }
287    }
288}
289
290
291BOOL GetVarFormatString( char *buffer,char *array,char *array2,char *NestMember,ReferenceKind &refType, PareOrBracket *pPareOrBracket ){
292    extern int cp;
293    int i,i2,i3;
294    char cPare_Open,cPare_Close;
295
296    array[0]=0;
297    array2[0]=0;
298    NestMember[0]=0;
299    for(i=0;;i++){
300        if(buffer[i]=='\"'){
301            for(i++;;i++){
302                if(IsDBCSLeadByte(buffer[i])){
303                    i++;
304                    continue;
305                }
306                if(buffer[i]=='\"') break;
307            }
308        }
309        if(buffer[i]=='['||buffer[i]=='('){
310            if(buffer[i]=='['){
311                cPare_Open='[';
312                cPare_Close=']';
313            }
314            else{
315                cPare_Open='(';
316                cPare_Close=')';
317            }
318
319            if( pPareOrBracket )
320            {
321                // []なのか、()なのかを伝える
322                if( cPare_Open == '[' )
323                {
324                    *pPareOrBracket = Bracket;
325                }
326                else
327                {
328                    *pPareOrBracket = Pare;
329                }
330            }
331
332            buffer[i]=0;
333            for(i++,i2=0;;i++,i2++){
334                if(buffer[i]==cPare_Open){
335                    if(cPare_Open=='[') i3=GetStringInBracket(array+i2,buffer+i);
336                    else i3=GetStringInPare(array+i2,buffer+i);
337                    i+=i3-1;
338                    i2+=i3-1;
339                    continue;
340                }
341                if(buffer[i]==cPare_Close){
342                    array[i2]=0;
343                    break;
344                }
345                array[i2]=buffer[i];
346            }
347            if(buffer[i+1]==cPare_Open){
348                for(i+=2,i2=0;;i++,i2++){
349                    if(buffer[i]==cPare_Open){
350                        if(cPare_Open=='[') i3=GetStringInBracket(array2+i2,buffer+i);
351                        else i3=GetStringInPare(array2+i2,buffer+i);
352                        i+=i3-1;
353                        i2+=i3-1;
354                        continue;
355                    }
356                    if(buffer[i]==cPare_Close){
357                        array2[i2]=0;
358                        break;
359                    }
360                    array2[i2]=buffer[i];
361                }
362                if(buffer[i+1]==cPare_Open){
363                    compiler.errorMessenger.Output(14,buffer,cp);
364                    return 0;
365                }
366            }
367            continue;
368        }
369        if(buffer[i]=='.'){
370            lstrcpy(NestMember,buffer+i+1);
371            refType = RefDot;
372            buffer[i]=0;
373            break;
374        }
375        if(buffer[i]==1&&buffer[i+1]==ESC_PSMEM){
376            lstrcpy(NestMember,buffer+i+2);
377            refType = RefPointer;
378            buffer[i]=0;
379            break;
380        }
381        if(buffer[i]=='\0') break;
382    }
383    return 1;
384}
385
386void GetArrayElement( const char *buffer,char *variable,char *array_element){
387    array_element[0]=0;
388
389    if(buffer[lstrlen(buffer)-1]!=']'){
390        lstrcpy(variable,buffer);
391        return;
392    }
393
394    int i,i2;
395    for(i=0;;i++){
396        if(buffer[i]=='\0') break;
397        if(buffer[i]=='['){
398            i2=GetStringInBracket(array_element,buffer+i);
399            i+=i2-1;
400            continue;
401        }
402    }
403
404    lstrcpy(variable,buffer);
405    variable[lstrlen(variable)-lstrlen(array_element)]=0;
406
407    RemoveStringBracket(array_element);
408}
409
410BOOL CheckVarNameError(char *name,int nowLine){
411    int i2;
412
413    if(!IsVariableTopChar(name[0])){
414        compiler.errorMessenger.Output(1,NULL,nowLine);
415        return 0;
416    }
417    for(i2=1;;i2++){
418        if(name[i2]=='\0') break;
419        if(!IsVariableChar(name[i2])){
420            compiler.errorMessenger.Output(1,NULL,nowLine);
421            return 0;
422        }
423    }
424    return 1;
425}
426
427int JumpSubScripts( const Subscripts &subscripts ){
428    //DIMで定義された並んだ配列の数だけアドレスを進める
429    int i, i2;
430    for( i=0,i2=1; i<(int)subscripts.size(); i++ ){
431        i2 *= subscripts[i] + 1;
432    }
433    return i2;
434}
435
436
437bool GetMemberType( const Type &classType, const char *lpszMember, Type &resultType, BOOL bPrivateAccess, bool isErrorEnabled)
438{
439    const CClass &objClass = classType.GetClass();
440
441    extern int cp;
442
443    //クラス、配列の構成要素を解析する
444    char VarName[VN_SIZE];      //変数名
445    char array[VN_SIZE];        //第1次配列
446    char lpPtrOffset[VN_SIZE];      //第2次配列
447    char NestMember[VN_SIZE];   //入れ子メンバ
448    ReferenceKind refType = RefNon;
449    lstrcpy(VarName,lpszMember);
450    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
451
452    const CMember *pMember = objClass.FindDynamicMember( VarName );
453    if( !pMember ){
454        if(isErrorEnabled) compiler.errorMessenger.Output(103,VarName,cp);
455        return false;
456    }
457
458    //アクセシビリティをチェック
459    if( compiler.IsCompilingClass() && &objClass == &compiler.GetCompilingClass() ){
460        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
461        if( pMember->IsNoneAccess() ){
462            if(isErrorEnabled) compiler.errorMessenger.Output(107,VarName,cp);
463            return false;
464        }
465    }
466    else{
467        if(( bPrivateAccess==0 && pMember->IsPrivate() )||
468            pMember->IsNoneAccess() ){
469            if(isErrorEnabled) compiler.errorMessenger.Output(107,VarName,cp);
470            return false;
471        }
472        else if( bPrivateAccess==0 && pMember->IsProtected() ){
473            if(isErrorEnabled) compiler.errorMessenger.Output(108,VarName,cp);
474            return false;
475        }
476    }
477
478    resultType = pMember->GetType();
479
480    // 型パラメータを解決
481    ResolveFormalGenericTypeParameter( resultType, classType );
482
483
484    //ポインタ変数の場合
485    if( resultType.IsPointer() ){
486        if( pMember->GetSubscripts().size() == 0 ){
487            lstrcpy(lpPtrOffset,array);
488            array[0]=0;
489        }
490    }
491    else{
492        if(lpPtrOffset[0]){
493            if(isErrorEnabled) compiler.errorMessenger.Output(16,lpszMember,cp);
494            return false;
495        }
496    }
497
498    if(array[0]){
499        //配列オフセット
500        if( pMember->GetSubscripts().size() <= 0 )
501        {
502            // 配列ではないメンバに配列指定をした
503            return false;
504        }
505    }
506    else if( pMember->GetSubscripts().size() > 0 ){
507        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
508    }
509
510    if( refType != RefNon ){
511        //入れ子構造の場合
512
513        return GetMemberType( pMember->GetType(),
514            NestMember,
515            resultType,
516            0,
517            isErrorEnabled);
518    }
519
520    if(lpPtrOffset[0]){
521        if( resultType.PtrLevel() ){
522            resultType.PtrLevelDown();
523        }
524        else{
525            //エラー
526            if(isErrorEnabled) compiler.errorMessenger.Output(1,NULL,cp);
527            return false;
528        }
529    }
530
531    return true;
532}
533bool GetVarType( const char *nameBuffer, Type &resultType, bool isErrorEnabled){
534    char variable[VN_SIZE];
535
536    if(nameBuffer[0]=='.'){
537        GetWithName(variable);
538        lstrcat(variable,nameBuffer);
539    }
540    else lstrcpy(variable,nameBuffer);
541
542    // 名前空間を分離
543    char namespaceStr[VN_SIZE]="", simpleName[VN_SIZE];
544    compiler.GetObjectModule().meta.GetNamespaces().SplitNamespace( variable, namespaceStr, simpleName );
545
546    // 先頭オブジェクトまたはクラス名と入れ子メンバに分割
547    ReferenceKind refType;
548    char member[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
549    GetVarFormatString(simpleName,array,lpPtrOffset,member,refType);
550
551    // 名前空間を分離していた場合は結合
552    char VarName[VN_SIZE];
553    if( namespaceStr[0] ){
554        sprintf( VarName, "%s.%s", namespaceStr, simpleName );
555    }
556    else{
557        lstrcpy( VarName, simpleName );
558    }
559
560    const Variable *pVar = NULL;
561
562    if( UserProc::IsLocalAreaCompiling() ){
563        /////////////////
564        // ローカル変数
565        /////////////////
566
567        pVar = UserProc::CompilingUserProc().GetLocalVars().BackSearch( LexicalAnalyzer::FullNameToSymbol( VarName ) );
568        if( pVar ){
569            goto ok;
570        }
571    }
572
573    if( compiler.IsCompilingClass() ){
574        ///////////////////////
575        // クラスメンバの参照
576        ///////////////////////
577
578        if(lstrcmpi(variable,"This")==0){
579            //Thisオブジェクト
580            resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
581            return true;
582        }
583
584        if(memicmp(variable,"This.",5)==0){
585            //Thisオブジェクトのメンバを参照するとき
586            SlideString(variable+5,-5);
587            lstrcpy(VarName,variable);
588        }
589        else{
590            //クラス内の動的メンバを参照するとき(通常)
591
592            if( !compiler.GetCompilingClass().HasDynamicMember( VarName ) )
593            {
594                goto NonClassMember;
595            }
596        }
597
598        return GetMemberType(
599            Type( DEF_OBJECT, compiler.GetCompilingClass() ),
600            variable,
601            resultType,
602            1,
603            isErrorEnabled
604        );
605    }
606
607NonClassMember:
608
609    //////////////////////////
610    // 静的ローカル変数
611    // ※"Static.Object.Method.Variable"
612    //////////////////////////
613
614    char temporary[VN_SIZE];
615    if( UserProc::IsLocalAreaCompiling() ){
616        GetNowStaticVarFullName(VarName,temporary);
617
618        pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temporary ) );
619        if( pVar ){
620            goto ok;
621        }
622    }
623
624
625    //////////////////////////
626    // クラスの静的メンバ
627    //////////////////////////
628
629    if(member[0]){
630        lstrcpy(temporary,member);
631        char tempMember[VN_SIZE];
632        char tempArray[VN_SIZE];
633        {
634            ReferenceKind refType;
635            GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,refType);
636        }
637
638        int typeDefIndex = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( VarName );
639        if( typeDefIndex != -1 ){
640            // TypeDef後の型名だったとき
641            lstrcpy( VarName, compiler.GetObjectModule().meta.GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
642        }
643
644        char temp2[VN_SIZE];
645        sprintf(temp2,"%s.%s",VarName,temporary);
646
647        pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
648        if( pVar ){
649            lstrcpy(member,tempMember);
650            lstrcpy(array,tempArray);
651            goto ok;
652        }
653    }
654
655    if( compiler.IsCompilingClass() ){
656        //自身のクラスから静的メンバを参照する場合
657        char temp2[VN_SIZE];
658        sprintf(temp2,"%s.%s",compiler.GetCompilingClass().GetName().c_str(),VarName);
659
660        pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
661        if( pVar ){
662            goto ok;
663        }
664    }
665
666
667    ////////////////////
668    // グローバル変数
669    ////////////////////
670
671    pVar = compiler.GetObjectModule().meta.GetGlobalVars().BackSearch( LexicalAnalyzer::FullNameToSymbol( VarName ) );
672    if( pVar ){
673        goto ok;
674    }
675
676    //変数として見つからなかったとき
677    if(isErrorEnabled) compiler.errorMessenger.Output(3,variable,cp);
678    return false;
679
680ok:
681
682    //ポインタ変数の場合
683    if( pVar->GetType().IsPointer() ){
684        if( !pVar->IsArray() ){
685            lstrcpy(lpPtrOffset,array);
686            array[0]=0;
687        }
688    }
689    else{
690        if(lpPtrOffset[0]){
691            if(isErrorEnabled) compiler.errorMessenger.Output(16,variable,cp);
692            return false;
693        }
694    }
695
696    resultType = pVar->GetType();
697
698    if(member[0]){
699        if( NATURAL_TYPE( resultType.GetBasicType() )==DEF_OBJECT
700            || NATURAL_TYPE( resultType.GetBasicType() )==DEF_STRUCT)
701        {
702            return GetMemberType(resultType,member,resultType,0,isErrorEnabled);
703        }
704    }
705
706    if( array[0] == 0 && pVar->GetSubscripts().size() > 0 ){
707        //配列の先頭ポインタを示す場合
708        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
709    }
710
711    if(lpPtrOffset[0]){
712        if( resultType.PtrLevel() ){
713            resultType.PtrLevelDown();
714        }
715        else{
716            //エラー
717            if(isErrorEnabled) compiler.errorMessenger.Output(1,NULL,cp);
718            return false;
719        }
720    }
721
722    return true;
723}
724
725bool GetVarOffsetReadOnly(const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
726{
727    //読み取り専用で変数へアクセス
728    return GetVarOffset(
729        true,       //エラー表示有効
730        false,      //書き込みアクセスは無し
731        NameBuffer,
732        pRelativeVar,
733        resultType,
734        pResultSubscripts
735    );
736}
737bool GetVarOffsetReadWrite(const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType, Subscripts *pResultSubscripts )
738{
739    //読み書き両用で変数へアクセス
740    return GetVarOffset(
741        true,       //エラー表示有効
742        true,       //書き込みアクセス
743        NameBuffer,
744        pRelativeVar,
745        resultType,
746        pResultSubscripts
747    );
748}
749
750
751
752bool GetDimentionFormat( const char *buffer,
753                        char *VarName,
754                        Subscripts &subscripts,
755                        Type &type,
756                        char *InitBuf,
757                        char *ConstractParameter ){
758    int i,i2,i3,IsStr;
759    char variable[VN_SIZE],temporary[8192];
760
761    for(i=0;;i++){
762        if((buffer[i]==1&&buffer[i+1]==ESC_AS)||
763            buffer[i]=='='||
764            buffer[i]=='\0'){
765            variable[i]=0;
766            break;
767        }
768        variable[i]=buffer[i];
769    }
770
771    if(buffer[i]=='='){
772        ////////////////////////////////////
773        // 初期化データが指定されいるとき
774        ////////////////////////////////////
775        i++;
776
777        if( buffer[i]=='[' ){
778            // 構造初期データの場合
779
780            i3=GetStringInBracket(InitBuf,buffer+i);
781            i+=i3;
782        }
783        else{
784            // 代入初期データの場合
785
786            for(i2=0,IsStr=0;;i++,i2++){
787                if(buffer[i]=='\"') IsStr^=1;
788                if(buffer[i]=='('&&IsStr==0){
789                    i3=GetStringInPare(InitBuf+i2,buffer+i);
790                    i+=i3-1;
791                    i2+=i3-1;
792                    continue;
793                }
794                if(buffer[i]=='['&&IsStr==0){
795                    i3=GetStringInBracket(InitBuf+i2,buffer+i);
796                    i+=i3-1;
797                    i2+=i3-1;
798                    continue;
799                }
800                if((buffer[i]==','&&IsStr==0)||
801                    buffer[i]=='\0'){
802                    InitBuf[i2]=0;
803                    break;
804                }
805                InitBuf[i2]=buffer[i];
806            }
807        }
808    }
809    else{
810        //初期化データなし
811        InitBuf[0]=0;
812    }
813
814    ConstractParameter[0]=0;
815    if(buffer[i]==1&&buffer[i+1]==ESC_AS){
816        /////////////////////////////
817        // "As ~" による型指定あり
818        /////////////////////////////
819
820        for(i+=2,i2=0;;i++,i2++){
821            if(buffer[i]=='('||buffer[i]=='\0'){
822                temporary[i2]=0;
823                break;
824            }
825            temporary[i2]=buffer[i];
826        }
827        if(temporary[0]=='*'&&
828            temporary[1]==1&&
829            (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
830            if(buffer[i]!='('){
831                compiler.errorMessenger.Output(10,temporary,cp);
832                return false;
833            }
834            i3=GetStringInPare(temporary+3,buffer+i);
835            i+=i3;
836            i2+=i3;
837
838            if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
839                temporary[i2++]=buffer[i++];
840                temporary[i2++]=buffer[i++];
841                for(;;i++,i2++){
842                    if(!IsVariableChar(buffer[i])){
843                        temporary[i2]=0;
844                        break;
845                    }
846                    temporary[i2]=buffer[i];
847                }
848            }
849        }
850
851        if( !compiler.StringToType( temporary, type ) ){
852            compiler.errorMessenger.Output(3,temporary,cp);
853            return false;
854        }
855
856        if(buffer[i]=='('){
857            //コンストラクタに渡すパラメータを取得
858            i2=GetStringInPare(ConstractParameter,buffer+i);
859            i+=i2;
860            RemoveStringPare(ConstractParameter);
861
862            if( !type.IsObject() ){
863                compiler.errorMessenger.Output(112,variable,cp);
864                return false;
865            }
866        }
867    }
868    else{
869        /////////////////
870        // As指定なし
871        /////////////////
872
873        if( InitBuf[0] == '\0' ){
874            //As指定も、初期値指定もない場合
875            type.SetBasicType( Type::GetBasicTypeFromSimpleName(variable) );
876
877            i2=lstrlen(variable)-1;
878            if(i2>=0){
879                if(!(variable[i2]=='#'||variable[i2]=='!'||variable[i2]=='%'||variable[i2]=='$'))
880                    compiler.errorMessenger.Output(-103,variable,cp);
881            }
882        }
883        else{
884            //初期値の型を判別して自動的に型情報を付加する
885            if( !NumOpe_GetType( InitBuf, GetStringTypeInfo(), type ) ){
886                // エラーの場合
887                return false;
888            }
889
890            if( IS_LITERAL( type.GetIndex() ) ){
891                type.SetIndex( -1 );
892            }
893        }
894
895    }
896
897    if( InitBuf[0] != '\0' && ConstractParameter[0] != '\0' ){
898        //初期値とコンストラクタパラメータが同時に呼び出されているとき
899        compiler.errorMessenger.Output(132, NULL, cp);
900    }
901
902    GetArrange(variable,VarName,subscripts);
903    return true;
904}
905
906BOOL GetNowStaticVarFullName(char *VarName,char *FullName){
907    if( UserProc::IsGlobalAreaCompiling() ){
908        // グローバル領域をコンパイル中のとき
909        return 0;
910    }
911
912    const UserProc &proc = UserProc::CompilingUserProc();
913
914    //Static識別
915    lstrcpy(FullName,"Static%");
916
917    //クラス名
918    if( compiler.IsCompilingClass() ){
919        lstrcat(FullName,compiler.GetCompilingClass().GetName().c_str());
920        lstrcat(FullName,"%");
921    }
922
923    //関数(またはメソッド)名
924    lstrcat(FullName,proc.GetName().c_str());
925    lstrcat(FullName,"%");
926
927    //ID
928    char temp[255];
929    sprintf(temp,"%x",proc.GetId());
930    lstrcat(FullName,temp);
931    lstrcat(FullName,"%");
932
933    //変数名
934    lstrcat(FullName,VarName);
935
936    return 1;
937}
938
939
940void AddGlobalVariable( const char *name, const Subscripts &subscripts, const Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlag){
941    /////////////////////////
942    // グローバル変数を追加
943    /////////////////////////
944
945    if( compiler.GetObjectModule().meta.GetGlobalVars().DuplicateCheck( LexicalAnalyzer::FullNameToSymbol( name ) ) ){
946        //2重定義のエラー
947        compiler.errorMessenger.Output(15,name,cp);
948        return;
949    }
950
951    bool isConst = ( dwFlag & DIMFLAG_CONST ) ? true:false;
952
953    Variable *pVar = new Variable(
954        compiler.GetNamespaceSupporter().GetLivingNamespaceScopes(),
955        name,
956        type,
957        isConst,
958        false,
959        ConstractParameter,
960        ( InitBuf[0] != 0 || dwFlag == DIMFLAG_INITDEBUGVAR )
961    );
962
963    if( subscripts.size() > 0 ){
964        //配列あり
965        pVar->SetArray( subscripts );
966    }
967
968    //レキシカルスコープ
969    pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
970    pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
971    pVar->isLiving = true;
972
973    //エラー用
974    pVar->source_code_address=cp;
975
976    // 変数を追加
977    compiler.GetObjectModule().meta.GetGlobalVars().Add( pVar );
978
979    if(InitBuf[0]){
980        int result = 0;
981        if( !pVar->GetType().IsObject() ){
982            result = SetInitGlobalData(pVar->GetOffsetAddress(),
983                pVar->GetType(),
984                pVar->GetSubscripts(),
985                InitBuf);
986        }
987
988        if(!result){
989            //動的な式だった場合は代入演算を行う
990
991            //初期代入時のみ、書き込みアクセスを許可する
992            if( isConst ){
993                pVar->ConstOff();
994            }
995
996            //代入
997            char temporary[8192];
998            sprintf(temporary,"%s=%s",name,InitBuf);
999            OpcodeCalc(temporary);
1000
1001            //アクセス制限を元に戻す
1002            if( isConst ){
1003                pVar->ConstOn();
1004            }
1005        }
1006    }
1007
1008
1009    if( type.IsObject() ){
1010        //デストラクタの利用フラグをオンにする
1011        const CMethod *method = type.GetClass().GetDestructorMethod();
1012        if( method ){
1013            method->GetUserProc().Using();
1014        }
1015    }
1016}
1017
1018void dim(char *Parameter,DWORD dwFlags){
1019    extern HANDLE hHeap;
1020    int i2;
1021    char VarName[VN_SIZE];
1022
1023    i2 = 0;
1024
1025    if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
1026        //参照型
1027        compiler.errorMessenger.OutputFatalError();
1028        Parameter += 2;
1029    }
1030
1031    if(dwFlags & DIMFLAG_CONST){
1032
1033        //////////////////////////////////
1034        // 定数変数の場合を考慮
1035        //////////////////////////////////
1036        for(;;i2++){
1037            if(Parameter[i2] == '=' ||
1038                Parameter[i2] == 1 && Parameter[i2] == ESC_AS ||
1039                Parameter[i2] =='('){
1040                    VarName[i2] = 0;
1041                    break;
1042            }
1043            VarName[i2] = Parameter[i2];
1044        }
1045
1046        //定数と2重定義されていないる場合は抜け出す
1047        if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(VarName)){
1048            return;
1049        }
1050
1051        //定数マクロとして定義されている場合は抜け出す
1052        if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExist( VarName ) )
1053        {
1054            return;
1055        }
1056    }
1057
1058
1059    //構文を解析
1060    Type type;
1061    char InitBuf[8192];
1062    char ConstractParameter[VN_SIZE];
1063    Subscripts subscripts;
1064    if(!GetDimentionFormat(Parameter, VarName,subscripts,type,InitBuf,ConstractParameter))
1065        return;
1066
1067
1068    //定数と2重定義されていないかを調べる
1069    if(compiler.GetObjectModule().meta.GetGlobalConsts().GetBasicType(VarName)){
1070        compiler.errorMessenger.Output(15,VarName,cp);
1071        return;
1072    }
1073
1074    //定数マクロとして定義されている場合
1075    if( compiler.GetObjectModule().meta.GetGlobalConstMacros().IsExist( VarName ) ){
1076        compiler.errorMessenger.Output(15,VarName,cp);
1077        return;
1078    }
1079
1080    if( type.IsObject() ){
1081        if( type.GetClass().IsBlittableType() ){
1082            // Blittable型のときは基本型として扱う
1083            // ※ただし、コンパイル中のメソッドがBlittable型クラスに属していないこと
1084            if( UserProc::IsLocalAreaCompiling()
1085                && UserProc::CompilingUserProc().HasParentClass()
1086                && UserProc::CompilingUserProc().GetParentClass().IsBlittableType() )
1087            {
1088                // コンパイル中のメソッドがBlittable型クラスに属している
1089            }
1090            else{
1091                type = type.GetClass().GetBlittableType();
1092            }
1093        }
1094    }
1095
1096    if(dwFlags&DIMFLAG_STATIC){
1097        if( UserProc::IsGlobalAreaCompiling() ){
1098            compiler.errorMessenger.Output(60,NULL,cp);
1099            return;
1100        }
1101
1102        /////////////////////
1103        // Static変数
1104        // ※"Static.Object.Method.Variable"
1105        /////////////////////
1106
1107        char temporary[VN_SIZE];
1108        GetNowStaticVarFullName(VarName,temporary);
1109
1110        dim( temporary,subscripts,type,InitBuf,ConstractParameter,dwFlags );
1111
1112        /*
1113        Note: 静的変数のコンストラクタ呼び出しは
1114            _System_InitStaticLocalVariables関数内で一括して行う
1115        */
1116    }
1117    else{
1118        dim( VarName,subscripts,type,InitBuf,ConstractParameter,dwFlags );
1119    }
1120}
1121void OpcodeDim(char *Parameter,DWORD dwFlags){
1122    int i,i2,i3,IsStr=0;
1123    char temporary[8192];
1124
1125    for(i=0,i2=0;;i++,i2++){
1126        if(Parameter[i]=='\"') IsStr^=1;
1127        if(Parameter[i]=='('&&IsStr==0){
1128            i3=GetStringInPare(temporary+i2,Parameter+i);
1129            i+=i3-1;
1130            i2+=i3-1;
1131            continue;
1132        }
1133        if(Parameter[i]=='['&&IsStr==0){
1134            i3=GetStringInBracket(temporary+i2,Parameter+i);
1135            i+=i3-1;
1136            i2+=i3-1;
1137            continue;
1138        }
1139        if( Parameter[i] == '<' && IsStr == 0 )
1140        {
1141            if( IsGenericTypeSourcePart( Parameter + i ) )
1142            {
1143                // ジェネリクス構文
1144                i3=GetStringInGenericBracket(temporary+i2,Parameter+i);
1145                i+=i3-1;
1146                i2+=i3-1;
1147                continue;
1148            }
1149            else
1150            {
1151                // 一般構文
1152            }
1153        }
1154        if((Parameter[i]==','&&IsStr==0)||
1155            Parameter[i]=='\0'){
1156            temporary[i2]=0;
1157
1158            dim(temporary,dwFlags);
1159
1160            if(Parameter[i]=='\0') break;
1161            i2=-1;
1162            continue;
1163        }
1164        temporary[i2]=Parameter[i];
1165    }
1166}
1167
1168void DebugVariable(void)
1169{
1170    char temporary[255];
1171    if( compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( "_DebugSys_dwThreadID" ) ) == NULL )
1172    {
1173        // 未定義の場合は定義する
1174        sprintf(temporary,"_DebugSys_dwThreadID[255]%c%cDWord",1,ESC_AS);
1175        OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1176        sprintf(temporary,"_DebugSys_ProcNum[255]%c%cDWord",1,ESC_AS);
1177        OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1178        sprintf(temporary,"_DebugSys_lplpObp[255]%c%c*ULONG_PTR",1,ESC_AS);
1179        OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1180        sprintf(temporary,"_DebugSys_lplpSpBase[255]%c%c*ULONG_PTR",1,ESC_AS);
1181        OpcodeDim(temporary,DIMFLAG_INITDEBUGVAR);
1182    }
1183}
Note: See TracBrowser for help on using the repository browser.