Changeset 409 in dev for trunk/abdev/BasicCompiler_Common


Ignore:
Timestamp:
Mar 3, 2008, 6:33:29 PM (17 years ago)
Author:
dai_9181
Message:

クラス継承を行う際、dynamicMembersの中身をコピーする方式をやめ、基底クラスのものを参照するように修正した。

Location:
trunk/abdev/BasicCompiler_Common
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler_Common/VarList.cpp

    r393 r409  
    160160    TreeView_InsertItem(hVarTree,lptv);
    161161}
    162 void VarList_Member(HWND hVarTree,HTREEITEM hParent,LONG_PTR pTopOffset,const CClass &objClass,BOOL bPtr){
     162void VarList_Member(HWND hVarTree,HTREEITEM hParent,LONG_PTR pTopOffset,const CClass &objClass,BOOL bPtr)
     163{
    163164    char VarData[VN_SIZE],VarName[VN_SIZE];
     165    if( objClass.HasSuperClass() )
     166    {
     167        TV_INSERTSTRUCT tv;
     168
     169        memset(&tv,0,sizeof(TV_INSERTSTRUCT));
     170        tv.hInsertAfter=TVI_LAST;
     171        tv.item.mask=TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
     172        tv.hParent=hParent;
     173        tv.item.pszText=VarData;
     174
     175        // 基底クラス
     176        sprintf(tv.item.pszText,"Inherits %s",objClass.GetSuperClass().GetName().c_str());
     177        tv.item.iImage=1;
     178        tv.item.iSelectedImage=1;
     179        HTREEITEM hTempParent=TreeView_InsertItem(hVarTree,&tv);
     180
     181        VarList_Member(hVarTree,hTempParent,pTopOffset,objClass.GetSuperClass(),0);
     182    }
     183
    164184    TV_INSERTSTRUCT tv;
    165185
    … …  
    181201
    182202        LONG_PTR offset;
    183         int i2;
    184         offset=objClass.GetMemberOffset( pMember->GetName().c_str(), &i2 );
     203        offset=objClass.GetMemberOffset( pMember->GetName().c_str() );
    185204
    186205        if( pMember->GetSubscripts().size() > 0 ){
    … …  
    435454    ReadProcessMemory(hDebugProcess,(void *)lpData,&pThis,sizeof(LONG_PTR),&accessBytes);
    436455
     456    if( pUserProc->GetParentClassPtr()->HasSuperClass() )
     457    {
     458        TV_INSERTSTRUCT tv;
     459
     460        memset(&tv,0,sizeof(TV_INSERTSTRUCT));
     461        tv.hInsertAfter=TVI_LAST;
     462        tv.item.mask=TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE;
     463        tv.hParent=NULL;
     464        tv.item.pszText=temporary;
     465
     466        // 基底クラス
     467        sprintf(tv.item.pszText,"Inherits %s",pUserProc->GetParentClassPtr()->GetSuperClass().GetName().c_str());
     468        tv.item.iImage=1;
     469        tv.item.iSelectedImage=1;
     470        HTREEITEM hTempParent=TreeView_InsertItem(hVarTree_This,&tv);
     471
     472        VarList_Member(hVarTree_This,hTempParent,pThis,pUserProc->GetParentClassPtr()->GetSuperClass(),0);
     473    }
     474
    437475    BOOST_FOREACH( CMember *pMember, pUserProc->GetParentClassPtr()->GetDynamicMembers() ){
    438         offset=pUserProc->GetParentClassPtr()->GetMemberOffset( pMember->GetName().c_str(),&i2);
     476        offset=pUserProc->GetParentClassPtr()->GetMemberOffset( pMember->GetName().c_str());
    439477
    440478        if( pMember->GetSubscripts().size() > 0 ){

  • trunk/abdev/BasicCompiler_Common/VariableOpe.cpp

    r403 r409  
    451451    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
    452452
    453     bool isFound = false;
    454     CMember *pMember = NULL;
    455     BOOST_FOREACH( pMember, objClass.GetDynamicMembers() ){
    456         if( pMember->GetName() == VarName ){
    457             isFound = true;
    458             break;
    459         }
    460     }
    461     if( !isFound ){
     453    const CMember *pMember = objClass.FindDynamicMember( VarName );
     454    if( !pMember ){
    462455        if(isErrorEnabled) SetError(103,VarName,cp);
    463456        return false;
    … …  
    596589        }
    597590        else{
    598             //クラス内メンバを参照するとき（通常）
    599 
    600             bool isFound = false;
    601             BOOST_FOREACH( CMember *pMember, compiler.pCompilingClass->GetDynamicMembers() ){
    602                 if( pMember->GetName() == VarName ){
    603                     isFound = true;
    604                     break;
    605                 }
    606             }
    607             if( !isFound ) goto NonClassMember;
     591            //クラス内の動的メンバを参照するとき（通常）
     592
     593            if( !compiler.pCompilingClass->HasDynamicMember( VarName ) )
     594            {
     595                goto NonClassMember;
     596            }
    608597        }
    609598

  • trunk/abdev/BasicCompiler_Common/WatchList.cpp

    r265 r409  
    130130    ////////////////////////////
    131131
    132     int memberIndex;
    133     int offset = objClass.GetMemberOffset( VarName, &memberIndex );
    134     if(memberIndex==objClass.GetDynamicMembers().size()) return 0;
    135 
    136     CMember *pMember = objClass.GetDynamicMembers()[memberIndex];
     132    const CMember *pMember = objClass.FindDynamicMember( VarName );
     133    if( !pMember )
     134    {
     135        return 0;
     136    }
     137
     138    int offset = objClass.GetMemberOffset( VarName );
    137139
    138140
    … …  
    388390        }
    389391        else{
    390             //クラス内メンバを参照するとき（通常）
    391 
    392             bool isFound = false;
    393             BOOST_FOREACH( CMember *pMember, compiler.pCompilingClass->GetDynamicMembers() ){
    394                 if( pMember->GetName() == VarName ){
    395                     isFound = true;
    396                     break;
    397                 }
    398             }
    399             if( !isFound ) goto NonClassMember;
     392            //クラス内の動的メンバを参照するとき（通常）
     393
     394            if( !compiler.pCompilingClass->HasDynamicMember( VarName ) )
     395            {
     396                goto NonClassMember;
     397            }
    400398        }
    401399

  • trunk/abdev/BasicCompiler_Common/error.cpp

    r402 r409  
    211211    if(num==138) sprintf(msg,"%s はインターフェイスではありません。Implementsできるのはインターフェイスに限ります。",tempKeyWord);
    212212    if(num==139) sprintf(msg,"%s はインターフェイスではありません。",tempKeyWord);
     213    if(num==140) lstrcpy(msg,"Align修飾子を構造体以外の型に指定することはできません。");
     214    if(num==141) lstrcpy(msg,"Blittable修飾子をクラス以外の型に指定することはできません。");
    213215
    214216    //Enum関連

  • trunk/abdev/BasicCompiler_Common/include/Class.h

    r387 r409  
    221221        , isCompilingDestructor( false )
    222222        , pobj_NextClass( NULL )
     223        , cacheSize( 0 )
    223224    {
    224225    }
    … …  
    239240        , isCompilingDestructor( false )
    240241        , pobj_NextClass( NULL )
     242        , cacheSize( 0 )
    241243    {
    242244    }
    … …  
    423425
    424426    //重複チェック
    425     bool DupliCheckAll(const char *name);
    426     bool DupliCheckMember(const char *name);
     427    bool DupliCheckAll(const char *name) const;
     428    bool DupliCheckMember(const char *name) const;
    427429
    428430    const Members &GetDynamicMembers() const
    … …  
    443445    }
    444446   
    445     const CMember *FindDynamicMember( const char *memberName ) const
    446     {
    447         BOOST_FOREACH( CMember *pMember, GetDynamicMembers() )
    448         {
    449             if( pMember->GetName() == memberName )
    450             {
    451                 return pMember;
    452             }
    453         }
    454         return NULL;
     447    const CMember *FindDynamicMember( const char *memberName ) const;
     448    bool HasDynamicMember( const char *memberName ) const
     449    {
     450        return ( FindDynamicMember( memberName ) != NULL );
    455451    }
    456452
    … …  
    503499
    504500    // メンバの総合サイズを取得
     501private:
     502    int cacheSize;
     503public:
    505504    int GetSize() const;
    506505
    507506    // メンバのオフセットを取得
    508     int GetMemberOffset( const char *memberName, int *pMemberNum = NULL ) const;
     507    int GetMemberOffset( const char *memberName ) const;
    509508private:
    510509    // アラインメント値を取得
    … …  
    531530    bool IsExistVirtualFunctions() const
    532531    {
    533         return ( vtblNum > 0 );
     532        // 構造体以外は仮想関数を持つ
     533        return !IsStructure();
    534534    }
    535535   

  • trunk/abdev/BasicCompiler_Common/include/Member.h

    r382 r409  
    6161    }
    6262
    63     bool IsConst()
     63    bool IsConst() const
    6464    {
    6565        return isConst;

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

    r407 r409  
    246246        //継承先が読み取られていないとき
    247247        compiler.GetObjectModule().meta.GetClasses().LookaheadClass(inheritsClass.GetName().c_str());
    248     }
    249 
    250     //メンバをコピー
    251     BOOST_FOREACH( CMember *inheritsClassDynamicMember, inheritsClass.GetDynamicMembers() ){
    252         CMember *pMember = new CMember( *inheritsClassDynamicMember );
    253 
    254         // アクセシビリティ
    255         if( inheritsClassDynamicMember->IsPrivate() ){
    256             pMember->SetAccessibility( Prototype::None );
    257         }
    258         else{
    259             pMember->SetAccessibility( inheritsClassDynamicMember->GetAccessibility() );
    260         }
    261 
    262         // メンバのみ、型パラメータを解決する（メソッドのほうは呼び出し時に解決する）
    263         if( pMember->GetType().IsTypeParameter() )
    264         {
    265             pMember->ResetType( actualTypeParameters[pMember->GetType().GetFormalTypeIndex()] );
    266         }
    267 
    268         dynamicMembers.push_back( pMember );
    269248    }
    270249
    … …  
    592571}
    593572
    594 bool CClass::DupliCheckAll(const char *name){
     573bool CClass::DupliCheckAll(const char *name) const
     574{
    595575    //重複チェック
    596576
    … …  
    607587    return 0;
    608588}
    609 bool CClass::DupliCheckMember(const char *name){
     589bool CClass::DupliCheckMember(const char *name) const
     590{
    610591    //重複チェック
    611592
     593    if( this->HasSuperClass() )
     594    {
     595        if( this->GetSuperClass().DupliCheckMember( name ) )
     596        {
     597            // 基底クラスで重複が発見された
     598            return true;
     599        }
     600    }
     601
    612602    // 動的メンバ
    613     BOOST_FOREACH( CMember *pMember, dynamicMembers ){
    614         if( GetName() == pMember->GetName() ){
    615             return 1;
     603    BOOST_FOREACH( CMember *pMember, dynamicMembers )
     604    {
     605        if( GetName() == pMember->GetName() )
     606        {
     607            return true;
    616608        }
    617609    }
    … …  
    620612    BOOST_FOREACH( CMember *pMember, staticMembers ){
    621613        if( GetName() == pMember->GetName() ){
    622             return 1;
    623         }
    624     }
    625 
    626     return 0;
     614            return true;
     615        }
     616    }
     617
     618    return false;
     619}
     620
     621const CMember *CClass::FindDynamicMember( const char *memberName ) const
     622{
     623    if( this->HasSuperClass() )
     624    {
     625        // 基底クラスで検索
     626        const CMember *result = this->GetSuperClass().FindDynamicMember( memberName );
     627        if( result )
     628        {
     629            return result;
     630        }
     631    }
     632
     633    BOOST_FOREACH( CMember *pMember, GetDynamicMembers() )
     634    {
     635        if( pMember->GetName() == memberName )
     636        {
     637            return pMember;
     638        }
     639    }
     640    return NULL;
    627641}
    628642
    … …  
    679693int CClass::GetSize() const
    680694{
    681     return GetMemberOffset( NULL, NULL );
     695    int resultSize = 0;
     696
     697    int alignment = 1;
     698    if( this->IsStructure() )
     699    {
     700        // 構造体のとき
     701
     702        if( this->GetFixedAlignment() )
     703        {
     704            // アラインメントの固定値が指定されていた場合はそれを取得
     705            alignment = this->GetFixedAlignment();
     706        }
     707    }
     708    else
     709    {
     710        // それ以外
     711
     712        if( this->HasSuperClass() )
     713        {
     714            // 基底クラスのサイズを追加
     715            resultSize += this->GetSuperClass().GetSize();
     716
     717            // 基底クラスのアラインメントを取得
     718            alignment = this->GetSuperClass().GetAlignment();
     719        }
     720        else
     721        {
     722            // 基底クラスが存在しないとき
     723
     724            // 仮想関数が存在する場合はvtbl及びvtblMasterListへのポインタのサイズを追加
     725            resultSize += IsExistVirtualFunctions() ? PTR_SIZE*2 : 0;
     726        }
     727    }
     728
     729    BOOST_FOREACH( CMember *pMember, dynamicMembers )
     730    {
     731        // メンバサイズ
     732        int tempMemberSize = pMember->GetType().GetSize();
     733
     734        // 一時アラインメントを算出
     735        int tempAlignment = tempMemberSize;
     736        if( pMember->GetType().IsStruct() )
     737        {
     738            // メンバが構造体の場合は、メンバのアラインメントを取得
     739            tempAlignment = pMember->GetType().GetClass().GetAlignment();
     740        }
     741
     742        // アラインメントを考慮してパディングを追加
     743        if( GetFixedAlignment() && alignment < tempAlignment )
     744        {
     745            if( resultSize % alignment )
     746            {
     747                resultSize += alignment - ( resultSize % alignment );
     748            }
     749        }
     750        else
     751        {
     752            if( alignment < tempAlignment )
     753            {
     754                // 最大アラインメントを更新
     755                alignment = tempAlignment;
     756            }
     757
     758            if( tempMemberSize == 0 )
     759            {
     760                if( !pMember->GetType().IsStruct() )
     761                {
     762                    SetError();
     763                }
     764
     765                //メンバを持たない構造体
     766                //※何もしない（オフセットの計算をしない）
     767            }
     768            else{
     769                if( resultSize % tempAlignment )
     770                {
     771                    resultSize += tempAlignment - ( resultSize % tempAlignment );
     772                }
     773            }
     774        }
     775
     776        // メンバサイズを加算（配列を考慮）
     777        resultSize += tempMemberSize * Variable::GetSubScriptCounts( pMember->GetSubscripts() );
     778    }
     779
     780    if( alignment )
     781    {
     782        // 末尾アラインメントを考慮してパディングを追加
     783        if( resultSize % alignment )
     784        {
     785            resultSize += alignment - ( resultSize % alignment );
     786        }
     787    }
     788
     789    return resultSize;
    682790}
    683791
    684792//メンバのオフセットを取得
    685 int CClass::GetMemberOffset( const char *memberName, int *pMemberNum ) const
    686 {
    687     int i2;
    688 
    689     //仮想関数が存在する場合はvtbl及びvtblMasterListへのポインタのサイズを追加
    690     int offset = IsExistVirtualFunctions() ? PTR_SIZE*2 : 0;
     793int CClass::GetMemberOffset( const char *memberName ) const
     794{
     795    int resultSize = 0;
    691796
    692797    int alignment = 1;
    693     if( GetFixedAlignment() )
    694     {
    695         alignment = GetFixedAlignment();
    696     }
    697 
    698     int iMaxAlign=0;
    699     int i = -1;
    700     BOOST_FOREACH( CMember *pMember, dynamicMembers ){
    701         i++;
    702 
    703         i2 = pMember->GetType().GetSize();
    704 
    705         //アラインメントを算出
    706         int member_size;
    707         if( pMember->GetType().IsStruct() ){
    708             //メンバクラスのアラインメントを取得
    709             member_size=pMember->GetType().GetClass().GetAlignment();
    710         }
    711         else{
    712             //メンバサイズを取得
    713             member_size=i2;
    714         }
    715         if(iMaxAlign<member_size) iMaxAlign=member_size;
    716 
    717         //アラインメントを考慮
    718         if(GetFixedAlignment()&&GetFixedAlignment()<member_size){
    719             if(offset%alignment) offset+=alignment-(offset%alignment);
    720         }
    721         else{
    722             if(alignment<member_size) alignment=member_size;
    723 
    724             if(member_size==0){
    725                 //メンバを持たないクラス
     798    if( this->IsStructure() )
     799    {
     800        // 構造体のとき
     801
     802        if( this->GetFixedAlignment() )
     803        {
     804            // アラインメントの固定値が指定されていた場合はそれを取得
     805            alignment = this->GetFixedAlignment();
     806        }
     807    }
     808    else
     809    {
     810        // それ以外
     811
     812        if( this->HasSuperClass() )
     813        {
     814            if( this->GetSuperClass().HasDynamicMember( memberName ) )
     815            {
     816                // 基底クラスのメンバを取得
     817                return this->GetSuperClass().GetMemberOffset( memberName );
     818            }
     819
     820            // 基底クラスのサイズを追加
     821            resultSize += this->GetSuperClass().GetSize();
     822
     823            // 基底クラスのアラインメントを取得
     824            alignment = this->GetSuperClass().GetAlignment();
     825        }
     826        else
     827        {
     828            // 基底クラスが存在しないとき
     829
     830            // 仮想関数が存在する場合はvtbl及びvtblMasterListへのポインタのサイズを追加
     831            resultSize += IsExistVirtualFunctions() ? PTR_SIZE*2 : 0;
     832        }
     833    }
     834
     835    BOOST_FOREACH( CMember *pMember, dynamicMembers )
     836    {
     837        // メンバサイズ
     838        int tempMemberSize = pMember->GetType().GetSize();
     839
     840        // 一時アラインメントを算出
     841        int tempAlignment = tempMemberSize;
     842        if( pMember->GetType().IsStruct() )
     843        {
     844            // メンバが構造体の場合は、メンバのアラインメントを取得
     845            tempAlignment = pMember->GetType().GetClass().GetAlignment();
     846        }
     847
     848        // アラインメントを考慮してパディングを追加
     849        if( GetFixedAlignment() && alignment < tempAlignment )
     850        {
     851            if( resultSize % alignment )
     852            {
     853                resultSize += alignment - ( resultSize % alignment );
     854            }
     855        }
     856        else
     857        {
     858            if( alignment < tempAlignment )
     859            {
     860                // 最大アラインメントを更新
     861                alignment = tempAlignment;
     862            }
     863
     864            if( tempMemberSize == 0 )
     865            {
     866                if( !pMember->GetType().IsStruct() )
     867                {
     868                    SetError();
     869                }
     870
     871                //メンバを持たない構造体
    726872                //※何もしない（オフセットの計算をしない）
    727873            }
    728874            else{
    729                 if(offset%member_size) offset+=member_size-(offset%member_size);
     875                if( resultSize % tempAlignment )
     876                {
     877                    resultSize += tempAlignment - ( resultSize % tempAlignment );
     878                }
    730879            }
    731880        }
    … …  
    733882        if(memberName){
    734883            //メンバ指定がある場合は、オフセットを返す
    735             if( pMember->GetName() == memberName ){
    736                 if(pMemberNum) *pMemberNum=i;
    737                 return offset;
    738             }
    739         }
    740 
    741         //配列を考慮したメンバサイズを取得
    742         member_size = i2 * Variable::GetSubScriptCounts( pMember->GetSubscripts() );
    743 
    744         //メンバサイズを加算
    745         offset+= member_size;
    746     }
    747 
    748     if(iMaxAlign<alignment) alignment=iMaxAlign;
    749 
    750     //アラインメントを考慮
    751     if(alignment){
    752         if(offset%alignment) offset+=alignment-(offset%alignment);
    753     }
    754 
    755     if(pMemberNum) *pMemberNum=i;
    756     return offset;
     884            if( pMember->GetName() == memberName )
     885            {
     886                return resultSize;
     887            }
     888        }
     889
     890        // メンバサイズを加算（配列を考慮）
     891        resultSize += tempMemberSize * Variable::GetSubScriptCounts( pMember->GetSubscripts() );
     892    }
     893
     894    if( alignment )
     895    {
     896        // 末尾アラインメントを考慮してパディングを追加
     897        if( resultSize % alignment )
     898        {
     899            resultSize += alignment - ( resultSize % alignment );
     900        }
     901    }
     902
     903    return resultSize;
    757904}
    758905int CClass::GetAlignment() const
    759906{
    760     //仮想関数が存在する場合は関数リストへのポインタのサイズを追加
    761     int alignment = IsExistVirtualFunctions() ? PTR_SIZE : 0;
    762 
    763     BOOST_FOREACH( CMember *pMember, dynamicMembers ){
    764         int member_size;
    765         if(pMember->GetType().IsStruct()){
    766             //メンバクラスのアラインメントを取得
    767             member_size=pMember->GetType().GetClass().GetAlignment();
    768         }
    769         else{
    770             //メンバサイズを取得
    771             member_size = pMember->GetType().GetSize();
    772         }
    773 
    774         //アラインメントをセット
    775         if(alignment<member_size) alignment=member_size;
    776     }
    777 
    778     if(alignment==0) return 0;
    779 
    780     if(GetFixedAlignment()) alignment=GetFixedAlignment();
     907    int alignment = 1;
     908    if( this->IsStructure() )
     909    {
     910        // 構造体のとき
     911
     912        if( this->GetFixedAlignment() )
     913        {
     914            // アラインメントの固定値が指定されていた場合はそれを取得
     915            return this->GetFixedAlignment();
     916        }
     917    }
     918    else
     919    {
     920        // それ以外
     921
     922        if( this->HasSuperClass() )
     923        {
     924            // 基底クラスのアラインメントを取得
     925            alignment = this->GetSuperClass().GetAlignment();
     926        }
     927        else
     928        {
     929            // 基底クラスが存在しないとき
     930
     931            // 仮想関数が存在する場合はvtbl及びvtblMasterListへのポインタのサイズを追加
     932            alignment = PTR_SIZE;
     933        }
     934    }
     935
     936    BOOST_FOREACH( CMember *pMember, dynamicMembers )
     937    {
     938        int tempAlignment = pMember->GetType().GetSize();
     939        if( pMember->GetType().IsStruct() )
     940        {
     941            // メンバが構造体の場合は、メンバのアラインメントを取得
     942            tempAlignment = pMember->GetType().GetClass().GetAlignment();
     943        }
     944
     945        if( alignment < tempAlignment )
     946        {
     947            // 最大アラインメントを更新
     948            alignment = tempAlignment;
     949        }
     950    }
    781951
    782952    return alignment;
    … …  
    11871357        }
    11881358
    1189         if( objClass.HasSuperClass() ){
     1359        if( objClass.HasSuperClass() || objClass.GetDynamicMembers().size() ){
    11901360            sprintf( temporary
    11911361                , "tempType=Search(\"%s\")"
    … …  
    11961366            ChangeOpcode( temporary );
    11971367
    1198             sprintf( temporary
    1199                 , "tempType.SetBaseType(Search(\"%s\"))"
    1200                 , objClass.GetSuperClass().GetFullName().c_str()
    1201             );
    1202 
    1203             // コンパイル
    1204             ChangeOpcode( temporary );
    1205 
    1206 
    1207             // メンバの型を示すTypeInfoオブジェクトへのDataOffset配列の静的データ定義文字列を取得
    1208             sprintf(
    1209                 temporary,
    1210                 "tempType.SetMembers([%s],[%s],%d)",
    1211                 objClass.GetStaticDefiningStringAsMemberNames().c_str(),
    1212                 objClass.GetStaticDefiningStringAsMemberTypeInfoNames().c_str(),
    1213                 objClass.GetDynamicMembers().size()
    1214             );
    1215             ChangeOpcode( temporary );
     1368            if( objClass.HasSuperClass() )
     1369            {
     1370                sprintf( temporary
     1371                    , "tempType.SetBaseType(Search(\"%s\"))"
     1372                    , objClass.GetSuperClass().GetFullName().c_str()
     1373                );
     1374
     1375                // コンパイル
     1376                ChangeOpcode( temporary );
     1377            }
     1378
     1379            if( objClass.GetDynamicMembers().size() )
     1380            {
     1381                // メンバの型を示すTypeInfoオブジェクトへのDataOffset配列の静的データ定義文字列を取得
     1382                sprintf(
     1383                    temporary,
     1384                    "tempType.SetMembers([%s],[%s],%d)",
     1385                    objClass.GetStaticDefiningStringAsMemberNames().c_str(),
     1386                    objClass.GetStaticDefiningStringAsMemberTypeInfoNames().c_str(),
     1387                    objClass.GetDynamicMembers().size()
     1388                );
     1389                ChangeOpcode( temporary );
     1390            }
    12161391        }
    12171392    }

  • trunk/abdev/BasicCompiler_Common/src/Class_Collect.cpp

    r402 r409  
    216216
    217217bool Classes::MemberVar_LoopRefCheck(const CClass &objClass){
     218    if( objClass.HasSuperClass() )
     219    {
     220        // 基底クラスをチェック
     221        if( MemberVar_LoopRefCheck( objClass.GetSuperClass() ) == false )
     222        {
     223            return false;
     224        }
     225    }
     226
    218227    bool result = true;
    219228    BOOST_FOREACH( CMember *pMember, objClass.GetDynamicMembers() ){
    … …  
    483492                iAlign=atoi(temporary);
    484493
     494                if( dwClassType != ESC_TYPE )
     495                {
     496                    SetError(140,NULL,i);
     497                }
     498
    485499                if(!(iAlign==1||iAlign==2||iAlign==4||iAlign==8||iAlign==16))
    486500                    SetError(51,NULL,i);
    … …  
    490504                i+=10;
    491505                i=JumpStringInPare(basbuf,i)+1;
     506
     507                if( dwClassType != ESC_CLASS )
     508                {
     509                    SetError(141,NULL,i);
     510                }
    492511            }
    493512
    … …  
    715734
    716735
    717                         if(pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().IsStruct()){
    718                             if( !pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().GetClass().IsReady() ){
     736                        if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
     737                            if( !pobj_c->GetDynamicMembers().back()->GetType().GetClass().IsReady() ){
    719738                                //参照先が読み取られていないとき
    720                                 GetClass_recur(pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().GetClass().GetName().c_str());
     739                                GetClass_recur(pobj_c->GetDynamicMembers().back()->GetType().GetClass().GetName().c_str());
    721740                            }
    722741                        }
    723742
    724743
    725                         if(pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().IsStruct()){
     744                        if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
    726745                            //循環参照のチェック
    727746                            pobj_LoopRefCheck->add(pobj_c->GetName().c_str());
    728                             if(!MemberVar_LoopRefCheck(pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().GetClass())){
     747                            if(!MemberVar_LoopRefCheck(pobj_c->GetDynamicMembers().back()->GetType().GetClass())){
    729748                                //エラー回避
    730749                                Type &type = const_cast<Type &>(pobj_c->GetDynamicMembers().back()->GetType());

  • trunk/abdev/BasicCompiler_Common/src/DataTable.cpp

    r389 r409  
    109109
    110110    // TypeInfoスケジュール
    111     int offsetForTypeInfo = objClass.GetMemberOffset( "typeInfo" );
     111    int offsetForTypeInfo = objClass.GetMemberOffset( "_system_object_member_typeInfo" );
    112112    //this->schedules.push_back( Schedule( Schedule::TypeInfo, &objClass, dataTableOffset + offsetForTypeInfo ) );
    113113
    … …  
    240240
    241241    // メンバ位置を取得
    242     int offsetForTypeInfo = strClass.GetMemberOffset( "typeInfo" );
     242    int offsetForTypeInfo = strClass.GetMemberOffset( "_system_object_member_typeInfo" );
    243243    int offsetForLength = strClass.GetMemberOffset( "m_Length" );
    244244    int offsetForChars = strClass.GetMemberOffset( "Chars" );
Note: See TracChangeset for help on using the changeset viewer.