Ignore:
Timestamp:
Jun 14, 2008, 12:16:27 PM (16 years ago)
Author:
dai_9181
Message:

静的リンクリンカの依存関係解決モジュールを製作中

Location:
trunk/ab5.0/abdev/ab_common/src/Lexical
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Class.cpp

    r639 r640  
    869869}
    870870
    871 bool CClass::Resolve( const ObjectModule &resolver )
     871bool CClass::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    872872{
    873873    // 型パラメータ
    874874    BOOST_FOREACH( GenericType &genericType, formalGenericTypes )
    875875    {
    876         genericType.GetType().Resolve( resolver );
     876        genericType.GetType().Resolve( resolver, resolveErrors );
    877877    }
    878878
    … …  
    882882        if( this->pSuperClass->IsNeedResolve() )
    883883        {
    884             this->pSuperClass = resolver.meta.GetClasses().FindEx( *pSuperClass );
     884            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pSuperClass );
     885            if( pTempClass )
     886            {
     887                this->pSuperClass = pTempClass;
     888            }
     889            else
     890            {
     891                resolveErrors.Add( ResolveError( this->pSuperClass->GetRelationalObjectModuleIndex(), this->pSuperClass->GetFullName() ) );
     892            }
    885893        }
    886894    }
    … …  
    889897    BOOST_FOREACH( Type &superClassActualTypeParameter, superClassActualTypeParameters )
    890898    {
    891         superClassActualTypeParameter.Resolve( resolver );
     899        superClassActualTypeParameter.Resolve( resolver, resolveErrors );
    892900    }
    893901
    894902    // Blittable型情報
    895     blittableType.Resolve( resolver );
     903    blittableType.Resolve( resolver, resolveErrors );
    896904
    897905    // 実装するインターフェイス
    898906    BOOST_FOREACH( ::Interface *pInterface, interfaces )
    899907    {
    900         pInterface->Resolve( resolver );
     908        pInterface->Resolve( resolver, resolveErrors );
    901909    }
    902910
    … …  
    904912    BOOST_FOREACH( Member *pMember, dynamicMembers )
    905913    {
    906         pMember->Resolve( resolver );
     914        pMember->Resolve( resolver, resolveErrors );
    907915    }
    908916
    … …  
    910918    BOOST_FOREACH( Member *pMember, staticMembers )
    911919    {
    912         pMember->Resolve( resolver );
     920        pMember->Resolve( resolver, resolveErrors );
    913921    }
    914922
    … …  
    916924    BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
    917925    {
    918         pMethod->Resolve( resolver );
     926        pMethod->Resolve( resolver, resolveErrors );
    919927    }
    920928
    … …  
    922930    BOOST_FOREACH( CMethod *pMethod, staticMethods )
    923931    {
    924         pMethod->Resolve( resolver );
     932        pMethod->Resolve( resolver, resolveErrors );
    925933    }
    926934
    … …  
    928936    BOOST_FOREACH( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, expandedTemplateClasses )
    929937    {
    930         pExpandedTemplateClass->Resolve( resolver );
     938        pExpandedTemplateClass->Resolve( resolver, resolveErrors );
    931939    }
    932940

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Const.cpp

    r639 r640  
    77}
    88
    9 bool CConst::Resolve( const ObjectModule &resolver )
     9bool CConst::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    1010{
    11     type.Resolve( resolver );
     11    type.Resolve( resolver, resolveErrors );
    1212    return true;
    1313}
    … …  
    7878}
    7979
    80 bool ConstMacro::Resolve( const ObjectModule &resolver )
     80bool ConstMacro::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    8181{
    8282    // 依存関係を解決すべきメンバは無い

  • trunk/ab5.0/abdev/ab_common/src/Lexical/DataTable.cpp

    r639 r640  
    7878}
    7979
    80 void DataTable::Resolve( const ObjectModule &resolver )
     80void DataTable::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    8181{
    8282    BOOST_FOREACH( Schedule &schedule, schedules )
    8383    {
    84         schedule.Resolve( resolver );
     84        schedule.Resolve( resolver, resolveErrors );
    8585    }
    8686}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Delegate.cpp

    r639 r640  
    1919}
    2020
    21 bool Delegate::Resolve( const ObjectModule &resolver )
     21bool Delegate::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    2222{
    23     Procedure::Resolve( resolver );
     23    Procedure::Resolve( resolver, resolveErrors );
    2424
    2525    BOOST_FOREACH( Parameter *pParameter, dynamicParams )
    2626    {
    27         pParameter->Resolve( resolver );
     27        pParameter->Resolve( resolver, resolveErrors );
    2828    }
    2929

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Interface.cpp

    r639 r640  
    3333}
    3434
     35bool Interface::Equals( const Interface *pInterface ) const
     36{
     37    // ポインタが等しいかどうかを見てみる
     38    if( this == pInterface )
     39    {
     40        return true;
     41    }
     42    else if( this->pInterfaceClass->IsNeedResolve() || pInterface->pInterfaceClass->IsNeedResolve() )
     43    {
     44        // 依存関係解決前の状態であれば、パスが等しいかどうかを見てみる
     45        if( this-pInterfaceClass->IsDuplication( pInterface->pInterfaceClass ) )
     46        {
     47            return true;
     48        }
     49    }
     50    return false;
     51}
     52
    3553std::string Interface::GetFullNameWithActualGenericTypeParameters() const
    3654{
    … …  
    5371}
    5472
    55 bool Interface::Resolve( const ObjectModule &resolver )
     73bool Interface::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    5674{
    5775    // 動的メソッド
    5876    BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
    5977    {
    60         pMethod->Resolve( resolver );
     78        pMethod->Resolve( resolver, resolveErrors );
    6179    }
    6280
    … …  
    6684        if( this->pInterfaceClass->IsNeedResolve() )
    6785        {
    68             this->pInterfaceClass = resolver.meta.GetClasses().FindLike( pInterfaceClass );
     86            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pInterfaceClass );
     87            if( pTempClass )
     88            {
     89                this->pInterfaceClass = pTempClass;
     90            }
     91            else
     92            {
     93                resolveErrors.Add( ResolveError( this->pInterfaceClass->GetRelationalObjectModuleIndex(), this->pInterfaceClass->GetFullName() ) );
     94            }
    6995        }
    7096    }
    … …  
    7298    BOOST_FOREACH( Type &actualTypeParameter, actualTypeParameters )
    7399    {
    74         actualTypeParameter.Resolve( resolver );
     100        actualTypeParameter.Resolve( resolver, resolveErrors );
    75101    }
    76102

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Member.cpp

    r639 r640  
    4141}
    4242
    43 bool Member::Resolve( const ObjectModule &resolver )
     43bool Member::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    4444{
    45     type.Resolve( resolver );
     45    type.Resolve( resolver, resolveErrors );
    4646    return true;
    4747}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Meta.cpp

    r639 r640  
    253253}
    254254
    255 void Meta::Resolve( const ObjectModule &resolver )
     255void Meta::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    256256{
    257257    // 関数・メソッド
    … …  
    261261    {
    262262        UserProc *pUserProc = this->GetUserProcs().Iterator_GetNext();
    263         pUserProc->Resolve( resolver );
     263        pUserProc->Resolve( resolver, resolveErrors );
    264264    }
    265265
    … …  
    270270    {
    271271        DllProc *pDllProc = this->GetDllProcs().Iterator_GetNext();
    272         pDllProc->Resolve( resolver );
     272        pDllProc->Resolve( resolver, resolveErrors );
    273273    }
    274274
    … …  
    279279    {
    280280        CClass *pClass = this->GetClasses().Iterator_GetNext();
    281         pClass->Resolve( resolver );
     281        pClass->Resolve( resolver, resolveErrors );
    282282    }
    283283
    … …  
    285285    BOOST_FOREACH( Variable *pVar, globalVars )
    286286    {
    287         pVar->Resolve( resolver );
     287        pVar->Resolve( resolver, resolveErrors );
    288288    }
    289289
    … …  
    294294    {
    295295        CConst *pConst = this->GetGlobalConsts().Iterator_GetNext();
    296         pConst->Resolve( resolver );
     296        pConst->Resolve( resolver, resolveErrors );
    297297    }
    298298
    … …  
    303303    {
    304304        ConstMacro *pConstMacro = this->GetGlobalConstMacros().Iterator_GetNext();
    305         pConstMacro->Resolve( resolver );
     305        pConstMacro->Resolve( resolver, resolveErrors );
     306    }
     307
     308    // blittable型
     309    BOOST_FOREACH( BlittableType &blittableType, blittableTypes )
     310    {
     311        blittableType.Resolve( resolver, resolveErrors );
    306312    }
    307313
    … …  
    309315    BOOST_FOREACH( TypeDef &typeDef, typeDefs )
    310316    {
    311         typeDef.Resolve( resolver );
     317        typeDef.Resolve( resolver, resolveErrors );
    312318    }
    313319
    … …  
    315321    BOOST_FOREACH( ProcPointer *pProcPointer, procPointers )
    316322    {
    317         pProcPointer->Resolve( resolver );
     323        pProcPointer->Resolve( resolver, resolveErrors );
    318324    }
    319325
    … …  
    324330    {
    325331        Delegate *pDelegate = this->GetDelegates().Iterator_GetNext();
    326         pDelegate->Resolve( resolver );
    327     }
    328 }
     332        pDelegate->Resolve( resolver, resolveErrors );
     333    }
     334}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Method.cpp

    r639 r640  
    11#include "stdafx.h"
    22
    3 bool CMethod::Resolve( const ObjectModule &resolver )
     3bool CMethod::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    44{
    5     if( pUserProc )
     5    if( this->pUserProc )
    66    {
    7         if( pUserProc->IsNeedResolve() )
     7        if( this->pUserProc->IsNeedResolve() )
    88        {
    9             pUserProc = resolver.meta.GetUserProcs().FindLike( pUserProc );
     9            const UserProc *pTempUserProc = resolver.meta.GetUserProcs().FindLike( this->pUserProc );
     10            if( pTempUserProc )
     11            {
     12                this->pUserProc = pTempUserProc;
     13            }
     14            else
     15            {
     16                resolveErrors.Add( ResolveError( this->pUserProc->GetRelationalObjectModuleIndex(), this->pUserProc->GetFullName() ) );
     17            }
    1018        }
    1119    }
    … …  
    4149}
    4250
    43 bool DynamicMethod::Resolve( const ObjectModule &resolver )
     51bool DynamicMethod::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    4452{
    45     CMethod::Resolve( resolver );
     53    CMethod::Resolve( resolver, resolveErrors );
    4654
    4755    if( this->pInheritsClass )
    … …  
    4957        if( this->pInheritsClass->IsNeedResolve() )
    5058        {
    51             this->pInheritsClass = resolver.meta.GetClasses().FindLike( pInheritsClass );
     59            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( pInheritsClass );
     60            if( pTempClass )
     61            {
     62                this->pInheritsClass = pTempClass;
     63            }
     64            else
     65            {
     66                resolveErrors.Add( ResolveError( this->pInheritsClass->GetRelationalObjectModuleIndex(), this->pInheritsClass->GetFullName() ) );
     67            }
    5268        }
    5369    }
    … …  
    6278}
    6379
    64 bool StaticMethod::Resolve( const ObjectModule &resolver )
     80bool StaticMethod::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    6581{
    66     CMethod::Resolve( resolver );
     82    CMethod::Resolve( resolver, resolveErrors );
    6783    return true;
    6884}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/NativeCode.cpp

    r639 r640  
    1919}
    2020
    21 bool Schedule::Resolve( const ObjectModule &resolver )
     21bool Schedule::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    2222{
    2323    switch( type )
    … …  
    2626    case AddressOf:
    2727    case CatchAddress:
    28         if( pUserProc->IsNeedResolve() )
    29         {
    30             pUserProc = resolver.meta.GetUserProcs().FindLike( pUserProc );
     28        if( this->pUserProc->IsNeedResolve() )
     29        {
     30            const ::UserProc *pTempUserProc = resolver.meta.GetUserProcs().FindLike( this->pUserProc );
     31            if( pTempUserProc )
     32            {
     33                this->pUserProc = pTempUserProc;
     34            }
     35            else
     36            {
     37                resolveErrors.Add( ResolveError( this->pUserProc->GetRelationalObjectModuleIndex(), this->pUserProc->GetFullName() ) );
     38            }
    3139        }
    3240        break;
    3341    case DllProc:
    34         if( pDllProc->IsNeedResolve() )
    35         {
    36             pDllProc = resolver.meta.GetDllProcs().FindLike( pDllProc );
     42        if( this->pDllProc->IsNeedResolve() )
     43        {
     44            const ::DllProc *pTempDllProc = resolver.meta.GetDllProcs().FindLike( this->pDllProc );
     45            if( pTempDllProc )
     46            {
     47                this->pDllProc = pTempDllProc;
     48            }
     49            else
     50            {
     51                resolveErrors.Add( ResolveError( this->pDllProc->GetRelationalObjectModuleIndex(), this->pDllProc->GetFullName() ) );
     52            }
    3753        }
    3854        break;
    … …  
    4056    case Vtbl:
    4157    case TypeInfo:
    42         if( pClass->IsNeedResolve() )
    43         {
    44             pClass = resolver.meta.GetClasses().FindLike( pClass );
     58        if( this->pClass->IsNeedResolve() )
     59        {
     60            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pClass );
     61            if( pTempClass )
     62            {
     63                this->pClass = pTempClass;
     64            }
     65            else
     66            {
     67                resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
     68            }
    4569        }
    4670        break;
    … …  
    191215}
    192216
    193 void NativeCode::Resolve( const ObjectModule &resolver )
     217void NativeCode::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    194218{
    195219    BOOST_FOREACH( Schedule &schedule, schedules )
    196220    {
    197         schedule.Resolve( resolver );
    198     }
    199 }
     221        schedule.Resolve( resolver, resolveErrors );
     222    }
     223}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/ObjectModule.cpp

    r639 r640  
    7777    }
    7878
    79     // 依存関係を解決
    80     this->Resolve();
    81 
    8279    // TODO: basbufがいらなくなったら消す
    8380    extern char *basbuf;
    … …  
    8582}
    8683
    87 void ObjectModule::Resolve()
    88 {
    89     this->meta.Resolve( *this );
     84void ObjectModule::Resolve( ResolveErrors &resolveErrors )
     85{
     86    this->meta.Resolve( *this, resolveErrors );
    9087
    9188    // グローバルネイティブコードを解決（スケジュールを解決する）
    92     this->globalNativeCode.Resolve( *this );
     89    this->globalNativeCode.Resolve( *this, resolveErrors );
    9390
    9491    // データテーブルを解決（スケジュールを解決する）
    95     this->dataTable.Resolve( *this );
     92    this->dataTable.Resolve( *this, resolveErrors );
    9693}
    9794

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Procedure.cpp

    r639 r640  
    1212}
    1313
    14 bool Procedure::Resolve( const ObjectModule &resolver )
     14bool Procedure::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    1515{
    1616    BOOST_FOREACH( Parameter *pParameter, params )
    1717    {
    18         pParameter->Resolve( resolver );
    19     }
    20 
    21     returnType.Resolve( resolver );
     18        pParameter->Resolve( resolver, resolveErrors );
     19    }
     20
     21    returnType.Resolve( resolver, resolveErrors );
    2222
    2323    return true;
    … …  
    170170}
    171171
    172 bool UserProc::Resolve( const ObjectModule &resolver )
    173 {
    174     Procedure::Resolve( resolver );
    175 
    176     if( pParentClass )
    177     {
    178         if( pParentClass->IsNeedResolve() )
    179         {
    180             pParentClass = resolver.meta.GetClasses().FindLike( pParentClass );
     172bool UserProc::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
     173{
     174    Procedure::Resolve( resolver, resolveErrors );
     175
     176    if( this->pParentClass )
     177    {
     178        if( this->pParentClass->IsNeedResolve() )
     179        {
     180            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pParentClass );
     181            if( pTempClass )
     182            {
     183                this->pParentClass = pTempClass;
     184            }
     185            else
     186            {
     187                resolveErrors.Add( ResolveError( this->pParentClass->GetRelationalObjectModuleIndex(), this->pParentClass->GetFullName() ) );
     188            }
    181189        }
    182190    }
    … …  
    184192    if( pInterface )
    185193    {
    186         const_cast<Interface *>(pInterface)->Resolve( resolver );
     194        const_cast<Interface *>(pInterface)->Resolve( resolver, resolveErrors );
    187195    }
    188196
    189197    if( pMethod )
    190198    {
    191         pMethod->Resolve( resolver );
     199        pMethod->Resolve( resolver, resolveErrors );
    192200    }
    193201
    194202    BOOST_FOREACH( Parameter *pParameter, realParams )
    195203    {
    196         pParameter->Resolve( resolver );
     204        pParameter->Resolve( resolver, resolveErrors );
    197205    }
    198206
    199207    BOOST_FOREACH( Variable *pLocalVar, localVars )
    200208    {
    201         pLocalVar->Resolve( resolver );
    202     }
    203 
    204     nativeCode.Resolve( resolver );
     209        pLocalVar->Resolve( resolver, resolveErrors );
     210    }
     211
     212    nativeCode.Resolve( resolver, resolveErrors );
    205213    return true;
    206214}
    … …  
    228236}
    229237
    230 bool DllProc::Resolve( const ObjectModule &resolver )
    231 {
    232     Procedure::Resolve( resolver );
    233     return true;
    234 }
    235 
    236 bool ProcPointer::Resolve( const ObjectModule &resolver )
    237 {
    238     Procedure::Resolve( resolver );
     238bool DllProc::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
     239{
     240    Procedure::Resolve( resolver, resolveErrors );
     241    return true;
     242}
     243
     244bool ProcPointer::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
     245{
     246    Procedure::Resolve( resolver, resolveErrors );
    239247    return true;
    240248}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Template.cpp

    r639 r640  
    99}
    1010
    11 bool ExpandedTemplateClass::Resolve( const ObjectModule &resolver )
     11bool ExpandedTemplateClass::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    1212{
    1313    if( pClass->IsNeedResolve() )
    1414    {
    15         pClass = const_cast<CClass *>(resolver.meta.GetClasses().FindLike( pClass ));
     15        CClass *pTempClass = const_cast<CClass *>(resolver.meta.GetClasses().FindLike( pClass ));
     16        if( pTempClass )
     17        {
     18            this->pClass = pTempClass;
     19        }
     20        else
     21        {
     22            resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
     23        }
    1624    }
    1725
    1826    BOOST_FOREACH( Type &actualType, actualTypes )
    1927    {
    20         actualType.Resolve( resolver );
     28        actualType.Resolve( resolver, resolveErrors );
    2129    }
    2230

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Type.cpp

    r639 r640  
    129129bool Type::Equals( const Type &type ) const
    130130{
    131     if( basicType == type.basicType ){
    132         if( NATURAL_TYPE( basicType ) == DEF_OBJECT
    133             || NATURAL_TYPE( basicType ) == DEF_STRUCT ){
    134 
    135                 if( index == type.index ){
     131    if( basicType == type.basicType )
     132    {
     133        if( NATURAL_TYPE( basicType ) == DEF_OBJECT || NATURAL_TYPE( basicType ) == DEF_STRUCT )
     134        {
     135            // ポインタが等しいかどうかを見てみる
     136            if( this->pClass == type.pClass )
     137            {
     138                return true;
     139            }
     140            else if( this->pClass->IsNeedResolve() || type.pClass->IsNeedResolve() )
     141            {
     142                // 依存関係解決前の状態であれば、パスが等しいかどうかを見てみる
     143                if( this->pClass->IsDuplication( type.pClass ) )
     144                {
    136145                    return true;
    137146                }
    138 
    139         }
    140         else{
     147            }
     148        }
     149        else
     150        {
    141151            return true;
    142152        }
    … …  
    556566}
    557567
    558 bool Type::Resolve( const ObjectModule &resolver )
     568bool Type::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    559569{
    560570    if( this->HasMember() )
    … …  
    562572        if( this->pClass->IsNeedResolve() )
    563573        {
    564             this->pClass = resolver.meta.GetClasses().FindLike( this->pClass );
     574            const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pClass );
     575            if( pTempClass )
     576            {
     577                this->pClass = pTempClass;
     578            }
     579            else
     580            {
     581                resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
     582            }
    565583        }
    566584
    567585        BOOST_FOREACH( GenericType &actualGenericType, actualGenericTypes )
    568586        {
    569             actualGenericType.GetType().Resolve( resolver );
     587            actualGenericType.GetType().Resolve( resolver, resolveErrors );
    570588        }
    571589    }
    … …  
    655673    return pClass->GetNamespaceScopes().ToString() + "." + pClass->GetName() + "._Create";
    656674}
     675
     676bool BlittableType::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
     677{
     678    basicType.Resolve( resolver, resolveErrors );
     679
     680    if( this->pClass->IsNeedResolve() )
     681    {
     682        const CClass *pTempClass = resolver.meta.GetClasses().FindLike( this->pClass );
     683        if( pTempClass )
     684        {
     685            this->pClass = pTempClass;
     686        }
     687        else
     688        {
     689            resolveErrors.Add( ResolveError( this->pClass->GetRelationalObjectModuleIndex(), this->pClass->GetFullName() ) );
     690        }
     691    }
     692
     693    return true;
     694}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/TypeDef.cpp

    r639 r640  
    88}
    99
    10 bool TypeDef::Resolve( const ObjectModule &resolver )
     10bool TypeDef::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    1111{
    12     this->baseType.Resolve( resolver );
     12    this->baseType.Resolve( resolver, resolveErrors );
    1313    return true;
    1414}

  • trunk/ab5.0/abdev/ab_common/src/Lexical/Variable.cpp

    r639 r640  
    2828}
    2929
    30 bool Variable::Resolve( const ObjectModule &resolver )
     30bool Variable::Resolve( const ObjectModule &resolver, ResolveErrors &resolveErrors )
    3131{
    32     this->type.Resolve( resolver );
     32    this->type.Resolve( resolver, resolveErrors );
    3333    return true;
    3434}
Note: See TracChangeset for help on using the changeset viewer.