Changeset 536 in dev


Ignore:
Timestamp:
May 3, 2008, 6:32:50 PM (17 years ago)
Author:
dai_9181
Message:

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

Location:
trunk/ab5.0/abdev
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/ab5.0/abdev/BasicCompiler_Common/DebugMiddleFile.cpp

    r485 r536  
    162162    int i2,i3;
    163163
    164     compiler.pCompilingClass = NULL;
     164    compiler.ClearCompilingUserProcAndClass();
    165165
    166166    i2=0;

  • trunk/ab5.0/abdev/BasicCompiler_Common/NumOpe_GetType.cpp

    r523 r536  
    480480
    481481
    482     if(lstrcmpi(termFull,"This")==0){
    483         if( compiler.pCompilingClass == NULL )
     482    if(lstrcmpi(termFull,"This")==0)
     483    {
     484        if( !compiler.IsCompilingClass() )
    484485        {
    485486            return false;
    … …  
    487488
    488489        //Thisオブジェクト
    489         resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
     490        resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
    490491        isLiteral = false;
    491492        return true;

  • trunk/ab5.0/abdev/BasicCompiler_Common/VarList.cpp

    r508 r536  
    778778
    779779        if(pUserProc){
    780             compiler.pCompilingClass = pUserProc->GetParentClassPtr();
     780            compiler.StartProcedureCompile( pUserProc );
    781781            UserProc::CompileStartForUserProc( pUserProc );
    782782        }

  • trunk/ab5.0/abdev/BasicCompiler_Common/VariableOpe.cpp

    r508 r536  
    457457
    458458    //アクセシビリティをチェック
    459     if( &objClass == compiler.pCompilingClass ){
     459    if( compiler.IsCompilingClass() && &objClass == &compiler.GetCompilingClass() ){
    460460        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    461461        if( pMember->IsNoneAccess() ){
    … …  
    571571    }
    572572
    573     if(compiler.pCompilingClass){
     573    if( compiler.IsCompilingClass() ){
    574574        ///////////////////////
    575575        // クラスメンバの参照
    … …  
    578578        if(lstrcmpi(variable,"This")==0){
    579579            //Thisオブジェクト
    580             resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
     580            resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
    581581            return true;
    582582        }
    … …  
    590590            //クラス内の動的メンバを参照するとき（通常）
    591591
    592             if( !compiler.pCompilingClass->HasDynamicMember( VarName ) )
     592            if( !compiler.GetCompilingClass().HasDynamicMember( VarName ) )
    593593            {
    594594                goto NonClassMember;
    … …  
    597597
    598598        return GetMemberType(
    599             Type( DEF_OBJECT, *compiler.pCompilingClass ),
     599            Type( DEF_OBJECT, compiler.GetCompilingClass() ),
    600600            variable,
    601601            resultType,
    … …  
    653653    }
    654654
    655     if(compiler.pCompilingClass){
     655    if( compiler.IsCompilingClass() ){
    656656        //自身のクラスから静的メンバを参照する場合
    657657        char temp2[VN_SIZE];
    658         sprintf(temp2,"%s.%s",compiler.pCompilingClass->GetName().c_str(),VarName);
     658        sprintf(temp2,"%s.%s",compiler.GetCompilingClass().GetName().c_str(),VarName);
    659659
    660660        pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
    … …  
    916916
    917917    //クラス名
    918     if(compiler.pCompilingClass){
    919         lstrcat(FullName,compiler.pCompilingClass->GetName().c_str());
     918    if( compiler.IsCompilingClass() ){
     919        lstrcat(FullName,compiler.GetCompilingClass().GetName().c_str());
    920920        lstrcat(FullName,"%");
    921921    }

  • trunk/ab5.0/abdev/BasicCompiler_Common/WatchList.cpp

    r508 r536  
    379379    }
    380380
    381     if(compiler.pCompilingClass){
     381    if( compiler.IsCompilingClass() )
     382    {
    382383        ///////////////////////
    383384        // クラスメンバの参照
    … …  
    392393            //クラス内の動的メンバを参照するとき（通常）
    393394
    394             if( !compiler.pCompilingClass->HasDynamicMember( VarName ) )
     395            if( !compiler.GetCompilingClass().HasDynamicMember( VarName ) )
    395396            {
    396397                goto NonClassMember;
    … …  
    418419        pRelativeVar->dwKind=VAR_DIRECTMEM;
    419420
    420         i3=Debugging_GetMember(*compiler.pCompilingClass,variable,pRelativeVar,resultType,1);
     421        i3=Debugging_GetMember( compiler.GetCompilingClass(),variable,pRelativeVar,resultType,1);
    421422        if(i3==0){
    422423            //式エラー

  • trunk/ab5.0/abdev/BasicCompiler_Common/hash.cpp

    r523 r536  
    6666        {
    6767            //クラスメンバ関数内から基底クラスの呼び出し
    68             pobj_c=&compiler.pCompilingClass->GetSuperClass();
     68            pobj_c=&compiler.GetCompilingClass().GetSuperClass();
    6969        }
    7070        else
    … …  
    104104
    105105
    106     if(compiler.pCompilingClass){
     106    if( compiler.IsCompilingClass() ){
    107107        //自身のオブジェクトのメンバ関数を検索
    108108
    109109        // 静的メソッド
    110         compiler.pCompilingClass->GetStaticMethods().Enum( name, subs );
     110        compiler.GetCompilingClass().GetStaticMethods().Enum( name, subs );
    111111
    112112        // 動的メソッド
    113         compiler.pCompilingClass->EnumDynamicMethodsOrInterfaceMethods( name, subs );
     113        compiler.GetCompilingClass().EnumDynamicMethodsOrInterfaceMethods( name, subs );
    114114    }
    115115

  • trunk/ab5.0/abdev/BasicCompiler_Common/include/Compiler.h

    r533 r536  
    3030    // 名前空間サポート
    3131    NamespaceSupporter namespaceSupporter;
     32
     33    // コンパイル中のUserProc/CClass
     34    const UserProc *pCompilingUserProc;
     35    const CClass *pCompilingClass;
    3236
    3337    // オブジェクトモジュール
    … …  
    187191    const std::string TypeToString( const Type &type );
    188192
    189     // コンパイル中のクラス
    190     const CClass *pCompilingClass;
    191 
     193    void ClearCompilingUserProcAndClass();
     194    void SetCompilingClass( const CClass *pClass );
    192195    void StartProcedureCompile( const UserProc *pUserProc );
    193196    void FinishProcedureCompile();
     197
     198    bool IsGlobalAreaCompiling();
     199    const UserProc &GetCompilingUserProc();
     200    bool IsCompilingClass();
     201    const CClass &GetCompilingClass();
    194202};
    195203

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/Class.cpp

    r523 r536  
    942942
    943943        // コンパイル中クラスとしてセット
    944         compiler.pCompilingClass = &objClass;
     944        compiler.SetCompilingClass( &objClass );
    945945
    946946        const EnumInfo *pEnumInfo = NULL;
    … …  
    971971        }
    972972
    973         compiler.pCompilingClass = NULL;
     973        compiler.SetCompilingClass( NULL );
    974974    }
    975975

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/Compiler.cpp

    r533 r536  
    145145
    146146    // 型パラメータ
    147     if( this->pCompilingClass )
     147    if( this->IsCompilingClass() )
    148148    {
    149149        // クラスに属するメソッドをコンパイルしているとき
    150         int formalTypeIndex = this->pCompilingClass->GetFormalGenericTypeParameterIndex( typeName );
     150        int formalTypeIndex = this->GetCompilingClass().GetFormalGenericTypeParameterIndex( typeName );
    151151        if( formalTypeIndex != -1 )
    152152        {
    153153            // コンパイル中クラスにおけるジェネリクス用の型パラメータのとき
    154154            type.SetBasicType( DEF_TYPE_PARAMETER );
    155             type.SetClassPtr( &this->pCompilingClass->GetFormalGenericTypes()[formalTypeIndex].GetType().GetClass() );
     155            type.SetClassPtr( &this->GetCompilingClass().GetFormalGenericTypes()[formalTypeIndex].GetType().GetClass() );
    156156            type.SetFormalTypeName( typeName );
    157157            type.SetFormalTypeIndex( formalTypeIndex );
    … …  
    211211}
    212212
     213void Compiler::ClearCompilingUserProcAndClass()
     214{
     215    this->pCompilingUserProc = NULL;
     216    this->pCompilingClass = NULL;
     217}
     218
     219void Compiler::SetCompilingClass( const CClass *pClass )
     220{
     221    this->pCompilingClass = pClass;
     222}
     223
    213224void Compiler::StartProcedureCompile( const UserProc *pUserProc )
    214225{
     226    //コンパイル中の関数
     227    this->pCompilingUserProc = pUserProc;
     228
    215229    //コンパイル中の関数が属するクラス
    216     this->pCompilingClass = pUserProc->GetParentClassPtr();
     230    this->SetCompilingClass( pUserProc->GetParentClassPtr() );
    217231
    218232    //コンパイルスタートをクラス管理クラスに追加
    … …  
    233247void Compiler::FinishProcedureCompile()
    234248{
    235 }
     249    this->pCompilingUserProc = NULL;
     250    this->pCompilingClass = NULL;
     251}
     252
     253bool Compiler::IsGlobalAreaCompiling()
     254{
     255    return ( pCompilingUserProc == NULL );
     256}
     257const UserProc &Compiler::GetCompilingUserProc()
     258{
     259    if( !this->IsGlobalAreaCompiling() )
     260    {
     261        return *pCompilingUserProc;
     262    }
     263
     264    throw;
     265}
     266
     267bool Compiler::IsCompilingClass()
     268{
     269    return ( pCompilingClass != NULL );
     270}
     271const CClass &Compiler::GetCompilingClass()
     272{
     273    if( this->IsCompilingClass() )
     274    {
     275        return *pCompilingClass;
     276    }
     277
     278    throw;
     279}

  • trunk/ab5.0/abdev/BasicCompiler_Common/src/LexicalAnalyzer_Class.cpp

    r512 r536  
    391391
    392392    // 呼び出し元でコンパイル中のクラスポインタをバックアップ
    393     const CClass *pBackCompilingClass = compiler.pCompilingClass;
     393    const CClass *pBackCompilingClass = compiler.IsCompilingClass()
     394        ? &compiler.GetCompilingClass()
     395        : NULL;
    394396
    395397    for(i=0;;i++){
    … …  
    464466            if(!pobj_c) continue;
    465467
    466             compiler.pCompilingClass = pobj_c;
     468            compiler.SetCompilingClass( pobj_c );
    467469
    468470            if(lpszInheritsClass){
    … …  
    688690            if(!pobj_c) continue;
    689691
    690             compiler.pCompilingClass = pobj_c;
     692            compiler.SetCompilingClass( pobj_c );
    691693
    692694            if(lpszInheritsClass){
    … …  
    981983
    982984    // 呼び出し元でコンパイル中のクラスポインタを元に戻す
    983     compiler.pCompilingClass = pBackCompilingClass;
     985    compiler.SetCompilingClass( pBackCompilingClass );
    984986
    985987    // 名前空間を元に戻す

  • trunk/ab5.0/abdev/compiler_x86/Compile_CallProc.cpp

    r509 r536  
    113113            {
    114114                //クラスメンバ関数内から基底クラスの呼び出し
    115                 pobj_c=&compiler.pCompilingClass->GetSuperClass();
     115                pobj_c=&compiler.GetCompilingClass().GetSuperClass();
    116116
    117117                isFixedClass = true;
    … …  
    147147
    148148                //New演算子によるコンストラクタ呼び出し
    149                 pobj_c=pUserProc->GetParentClassPtr();
     149                pobj_c = pUserProc->GetParentClassPtr();
    150150            }
    151151            else{
    152152                //クラスメンバ関数内から同一クラスのメンバ関数の呼び出し
    153                 pobj_c=compiler.pCompilingClass;
     153                pobj_c = &compiler.GetCompilingClass();
    154154            }
    155155        }
    … …  
    180180        if(ObjectName[0]){
    181181            //外部からの呼び出し
    182             if(pobj_c==compiler.pCompilingClass){
     182            if( compiler.IsCompilingClass() && pobj_c == &compiler.GetCompilingClass() )
     183            {
    183184                //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    184                 if( pMethod->IsNoneAccess() ){
     185                if( pMethod->IsNoneAccess() )
     186                {
    185187                    compiler.errorMessenger.Output(109,pUserProc->GetName(),cp);
    186188                    return false;
    187189                }
    188190            }
    189             else{
     191            else
     192            {
    190193                if( pMethod->IsPrivate()
    191                     || pMethod->IsNoneAccess() ){
     194                    || pMethod->IsNoneAccess() )
     195                {
    192196                    compiler.errorMessenger.Output(109,pUserProc->GetName(),cp);
    193197                    return false;
    194198                }
    195                 if( !pMethod->GetUserProc().GetParentClass().IsEqualsOrSubClass( pobj_c ) && pMethod->IsProtected() ){
     199                if( !pMethod->GetUserProc().GetParentClass().IsEqualsOrSubClass( pobj_c ) && pMethod->IsProtected() )
     200                {
    196201                    compiler.errorMessenger.Output(110,pUserProc->GetName(),cp);
    197202                    return false;

  • trunk/ab5.0/abdev/compiler_x86/Compile_Func.cpp

    r523 r536  
    273273            SetThisPtrToReg(REG_RCX);
    274274
    275             pobj_c=compiler.pCompilingClass;
     275            pobj_c = &compiler.GetCompilingClass();
    276276        }
    277277
    … …  
    611611        }
    612612
    613         Opcode_CallDelegate( compiler.pCompilingClass->GetDelegate(), methodPtrParamStr, objPtrValueStr, paramsStr + i );
     613        Opcode_CallDelegate( compiler.GetCompilingClass().GetDelegate(), methodPtrParamStr, objPtrValueStr, paramsStr + i );
    614614    }
    615615

  • trunk/ab5.0/abdev/compiler_x86/Compile_ProcOp.cpp

    r533 r536  
    471471    }
    472472
    473     if(compiler.pCompilingClass){
    474         if( pUserProc->GetName() == compiler.pCompilingClass->GetName() ){
     473    if( compiler.IsCompilingClass() ){
     474        if( pUserProc->GetName() == compiler.GetCompilingClass().GetName() ){
    475475            ////////////////////////////////////
    476476            // コンストラクタをコンパイルするとき
    … …  
    478478
    479479            //コンストラクタのコンパイル開始を通知
    480             compiler.pCompilingClass->NotifyStartConstructorCompile();
     480            compiler.GetCompilingClass().NotifyStartConstructorCompile();
    481481
    482482            //基底クラスかどうかの識別
    483483            //（継承元がインターフェイスの場合も基底クラスと見なす）
    484484            BOOL bThisIsSuperClass;
    485             if( !compiler.pCompilingClass->HasSuperClass() ) bThisIsSuperClass=1;
    486             else if( compiler.pCompilingClass->GetSuperClass().GetConstructorMethod() == NULL ){
     485            if( !compiler.GetCompilingClass().HasSuperClass() ) bThisIsSuperClass=1;
     486            else if( compiler.GetCompilingClass().GetSuperClass().GetConstructorMethod() == NULL ){
    487487                //インターフェイスを継承したときはコンストラクタを持たない
    488488                bThisIsSuperClass=1;
    … …  
    503503                    temporary[i4]=basbuf[i3];
    504504                }
    505                 if( compiler.pCompilingClass->GetSuperClass().GetName() == temporary ){
     505                if( compiler.GetCompilingClass().GetSuperClass().GetName() == temporary ){
    506506                    //基底クラスのコンストラクタを呼び出す
    507507                    cp=i3;
    … …  
    520520                    Type dummyType;
    521521                    CallProc( PROC_DEFAULT
    522                         , &compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc()
    523                         , compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc().GetName().c_str()
     522                        , &compiler.GetCompilingClass().GetSuperClass().GetConstructorMethod()->GetUserProc()
     523                        , compiler.GetCompilingClass().GetSuperClass().GetConstructorMethod()->GetUserProc().GetName().c_str()
    524524                        , temporary
    525525                        , Type()        // baseTypeはなし
    … …  
    530530                    //基底クラスのコンストラクタを暗黙的に呼び出す
    531531                    Opcode_CallProc("",
    532                         &compiler.pCompilingClass->GetSuperClass().GetConstructorMethod()->GetUserProc(),
     532                        &compiler.GetCompilingClass().GetSuperClass().GetConstructorMethod()->GetUserProc(),
    533533                        0,
    534534                        ""
    … …  
    541541
    542542            //デストラクタのコンパイル開始を通知
    543             compiler.pCompilingClass->NotifyStartDestructorCompile();
     543            compiler.GetCompilingClass().NotifyStartDestructorCompile();
    544544        }
    545545    }
    … …  
    567567    //////////////////////////////////////////
    568568
    569     if( compiler.pCompilingClass ){
    570 
    571         if( compiler.pCompilingClass->IsCompilingConstructor() ){
     569    if( compiler.IsCompilingClass() ){
     570
     571        if( compiler.GetCompilingClass().IsCompilingConstructor() ){
    572572            // コンストラクタをコンパイルしていたとき
    573573
    574574            // コンストラクタのコンパイルが完了したことを通知
    575             compiler.pCompilingClass->NotifyFinishConstructorCompile();
     575            compiler.GetCompilingClass().NotifyFinishConstructorCompile();
    576576        }
    577577        else if( pUserProc->IsDestructor() ){
    … …  
    581581
    582582            // デストラクタのコンパイルが完了したことを通知
    583             compiler.pCompilingClass->NotifyFinishDestructorCompile();
    584 
    585             if( compiler.pCompilingClass->HasSuperClass() ){
     583            compiler.GetCompilingClass().NotifyFinishDestructorCompile();
     584
     585            if( compiler.GetCompilingClass().HasSuperClass() ){
    586586                /* サブクラスのデストラクタをコンパイルしているときは、
    587587                    基底クラスのデストラクタを呼び出す */
    588588
    589                 const CMethod *method = compiler.pCompilingClass->GetSuperClass().GetDestructorMethod();
     589                const CMethod *method = compiler.GetCompilingClass().GetSuperClass().GetDestructorMethod();
    590590                if( method ){
    591591                    Opcode_CallProc("",

  • trunk/ab5.0/abdev/compiler_x86/Compile_Var.cpp

    r508 r536  
    194194
    195195    //アクセシビリティをチェック
    196     if(&objClass==compiler.pCompilingClass){
     196    if( compiler.IsCompilingClass() && &objClass == &compiler.GetCompilingClass() ){
    197197        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
    198198        if(pMember->IsNoneAccess()){
    … …  
    447447    }
    448448
    449     if(compiler.pCompilingClass){
     449    if( compiler.IsCompilingClass() ){
    450450        //////////////////////
    451451        // クラスメンバの参照
    … …  
    460460            pRelativeVar->dwKind=VAR_DIRECTMEM;
    461461
    462             resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
     462            resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
    463463            return true;
    464464        }
    … …  
    472472            //クラス内の動的メンバを参照するとき（通常）
    473473
    474             if( !compiler.pCompilingClass->HasDynamicMember( VarName ) )
     474            if( !compiler.GetCompilingClass().HasDynamicMember( VarName ) )
    475475            {
    476476                goto NonClassMember;
    … …  
    483483        if( isWriteAccess &&
    484484            pMethod->IsConst() &&
    485             compiler.pCompilingClass->IsCompilingConstructor() == false &&
    486             compiler.pCompilingClass->IsCompilingDestructor() == false
     485            compiler.GetCompilingClass().IsCompilingConstructor() == false &&
     486            compiler.GetCompilingClass().IsCompilingDestructor() == false
    487487            ){
    488488                compiler.errorMessenger.Output(131, NULL, cp );
    … …  
    499499            isErrorEnabled,
    500500            isWriteAccess,
    501             Type( DEF_OBJECT, *compiler.pCompilingClass ),
     501            Type( DEF_OBJECT, compiler.GetCompilingClass() ),
    502502            variable,
    503503            pRelativeVar,
    … …  
    559559        }
    560560
    561         if(compiler.pCompilingClass){
     561        if( compiler.IsCompilingClass() ){
    562562            //自身のクラスから静的メンバを参照する場合
    563563            char temp2[VN_SIZE];
    564             sprintf(temp2,"%s.%s",compiler.pCompilingClass->GetName().c_str(),VarName);
     564            sprintf(temp2,"%s.%s",compiler.GetCompilingClass().GetName().c_str(),VarName);
    565565            pVar = compiler.GetObjectModule().meta.GetGlobalVars().Find( LexicalAnalyzer::FullNameToSymbol( temp2 ) );
    566566            if( pVar ){

  • trunk/ab5.0/abdev/compiler_x86/MakePeHdr.cpp

    r525 r536  
    193193
    194194    // サブルーチン（ユーザー定義、DLL関数）の識別子、アドレスを取得
    195     compiler.pCompilingClass = NULL;
     195    compiler.SetCompilingClass( NULL );
    196196    ActiveBasic::Compiler::LexicalAnalyzer::CollectProcedures(
    197197        compiler.GetObjectModule().GetCurrentSource(),

  • trunk/ab5.0/abdev/compiler_x86/NumOpe.cpp

    r523 r536  
    430430
    431431    if(lstrcmpi(termFull,"This")==0 && isProcedureCallOnly == false ){
    432         if( compiler.pCompilingClass == NULL )
     432        if( !compiler.IsCompilingClass() )
    433433        {
    434434            compiler.errorMessenger.Output(142,NULL,cp);
    … …  
    437437
    438438        //Thisオブジェクト
    439         resultType.SetType( DEF_OBJECT, compiler.pCompilingClass );
     439        resultType.SetType( DEF_OBJECT, &compiler.GetCompilingClass() );
    440440
    441441        SetThisPtrToReg( useReg );
Note: See TracChangeset for help on using the changeset viewer.