Changeset 632 in dev


Ignore:
Timestamp:
Jun 5, 2008, 10:04:39 PM (16 years ago)
Author:
dai_9181
Message:

ジェネリッククラスの型パラメータに値型が指定されたときに限り、テンプレート展開を行うようにした。

TODO: libファイルを跨ってテンプレート展開ができていないため、ソースコード管理部分に手を加える必要あり。

Location:
trunk/ab5.0/abdev
Files:
5 added
1 deleted
31 edited

Legend:

Unmodified
Added
Removed

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

    r587 r632  
    758758            }
    759759
    760             ChangeOpcode(Command);
     760            if( Command[0] )
     761            {
     762                ChangeOpcode(Command);
     763            }
    761764
    762765

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

    r600 r632  
    829829                        isNothing_stack[sp] = true;
    830830
    831                         type_stack[sp] = DEF_OBJECT;
    832831                        if( baseType.IsObject() ){
     832                            type_stack[sp] = DEF_OBJECT;
    833833                            index_stack[sp] = baseType.GetIndex();
    834834                        }
    835835                        else{
    836                             index_stack[sp] = (LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr();
     836                            type_stack[sp] = baseType.GetBasicType();
     837                            index_stack[sp] = baseType.GetIndex();
    837838                        }
     839
    838840                        *pIsLiteralCalculation = false;
    839841                        sp++;

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

    r603 r632  
    365365            lstrcpy(name,"End Enum");
    366366            break;
     367        case ESC_OPERATOR:
     368            lstrcpy( name, "Operator" );
     369            break;
    367370    }
    368371}
    … …  
    378381        if( temporary[i] == 1 )
    379382        {
     383            int esc = temporary[i+1];
    380384            char temp2[255];
    381             GetDefaultNameFromES( temporary[i+1], temp2 );
     385            GetDefaultNameFromES( esc, temp2 );
    382386            if( i>0 )
    383387            {
    … …  
    391395            }
    392396
     397            int slide = 2;
     398
     399            if( esc == ESC_OPERATOR )
     400            {
     401                extern char *calcNames[256];
     402                char calcId = temporary[i+2];
     403                if( calcNames[calcId] )
     404                {
     405                    lstrcat( temp2, calcNames[calcId] );
     406                }
     407                slide = 3;
     408            }
     409
    393410            int length = lstrlen( temp2 );
    394             SlideString( temporary + i+2, length-2 );
     411            SlideString( temporary + i+slide, length-slide );
    395412            memcpy( temporary + i, temp2, length );
    396413            maxLength = lstrlen( temporary );

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

    r628 r632  
    633633        }
    634634
    635         int typeDefIndex = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( LexicalAnalyzer::FullNameToSymbol( VarName ) );
    636         if( typeDefIndex != -1 ){
     635        const TypeDef *pTypeDef = compiler.GetObjectModule().meta.GetTypeDefs().Find( LexicalAnalyzer::FullNameToSymbol( VarName ) );
     636        if( pTypeDef )
     637        {
    637638            // TypeDef後の型名だったとき
    638             lstrcpy( VarName, compiler.GetObjectModule().meta.GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
     639            lstrcpy( VarName, pTypeDef->GetBaseName().c_str() );
    639640        }
    640641

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

    r628 r632  
    184184
    185185
     186private:
     187    ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType StringToGenericTypeEx( const std::string &typeName, Type &type );
     188public:
    186189    ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType StringToTypeEx( const std::string &typeName, Type &type, bool isResolveGenerics = false );
    187190    bool StringToType( const std::string &typeName, Type &type );

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

    r625 r632  
    4343    static void CollectClasses( const char *source, Classes &classes );
    4444
     45    // テンプレート展開
     46    static void TemplateExpand_ResolveMethod( const CMethod *pBaseMethod, const Types &actualTypes, CClass *pNewClass );
     47    static const CClass *TemplateExpand( CClass &_class, const Types &actualTypes );
     48
    4549    // グローバルプロシージャを収集する
    4650    static bool AnalyzeParameter( Parameters &params, const Jenga::Common::Strings &parameterStrings, int nowLine );

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

    r628 r632  
    1414}
    1515
    16 ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType Compiler::StringToTypeEx( const std::string &typeName, Type &type, bool isResolveGenerics )
    17 {
    18     type.SetIndex( -1 );
    19 
    20 
    21     /////////////////////////////////////////////////////////
    22     // ☆★☆ ジェネリクスサポート ☆★☆
    23 
    24     if( strstr( typeName.c_str(), "<" ) )
    25     {
    26         // ジェネリッククラスをインスタンス化した型の場合
    27         int i = 0;
    28         char className[VN_SIZE];
    29         GetIdentifierToken( className, typeName.c_str(), i );
    30 
    31         // ジェネリクスクラスを取得
    32         const CClass *pGenericClass = this->GetObjectModule().meta.FindClassSupportedTypeDef(
    33             LexicalAnalyzer::FullNameToSymbol( className )
    34         );
    35 
    36         if( !pGenericClass )
    37         {
    38             return ActiveBasic::Compiler::Error::StringToTypeErrorCode::NotfoundGenericClass;
    39         }
    40 
    41         if( typeName[i] != '<' )
    42         {
    43             Jenga::Throw( "StringToType内でジェネリクス構文の解析に失敗" );
    44         }
    45 
    46         GenericTypes genericTypes;
    47         while( true )
    48         {
    49             i++;
    50 
    51             char typeParameter[VN_SIZE];
    52             GetIdentifierToken( typeParameter, typeName.c_str(), i );
    53 
    54             // 型パラメータの型情報を取得
    55             Type baseType;
    56             StringToType( typeParameter, baseType );
    57 
    58             genericTypes.push_back( GenericType( "(non support)", baseType ) );
    59 
    60             if( typeName[i] != ',' )
    61             {
    62                 break;
    63             }
    64         }
    65 
    66         // 基本型をセット
    67         type.SetBasicType( DEF_OBJECT );
     16ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType Compiler::StringToGenericTypeEx( const std::string &typeName, Type &type )
     17{
     18    // ジェネリッククラスをインスタンス化した型の場合
     19    int i = 0;
     20    char className[VN_SIZE];
     21    GetIdentifierToken( className, typeName.c_str(), i );
     22
     23    // ジェネリクスクラスを取得
     24    const CClass *pGenericClass = this->GetObjectModule().meta.FindClassSupportedTypeDef(
     25        LexicalAnalyzer::FullNameToSymbol( className )
     26    );
     27
     28    if( !pGenericClass )
     29    {
     30        return ActiveBasic::Compiler::Error::StringToTypeErrorCode::NotfoundGenericClass;
     31    }
     32
     33    if( typeName[i] != '<' )
     34    {
     35        Jenga::Throw( "StringToType内でジェネリクス構文の解析に失敗" );
     36    }
     37
     38    GenericTypes genericTypes;
     39    bool isValueType = false;
     40    while( true )
     41    {
     42        i++;
     43
     44        char typeParameterStr[VN_SIZE];
     45        GetIdentifierToken( typeParameterStr, typeName.c_str(), i );
     46
     47        // 型パラメータの型情報を取得
     48        Type typeParameterType;
     49        StringToType( typeParameterStr, typeParameterType );
     50
     51        genericTypes.push_back( GenericType( "(non support)", typeParameterType ) );
     52
     53        if( typeParameterType.IsValueType() )
     54        {
     55            // 値型の場合
     56            isValueType = true;
     57        }
     58
     59        if( typeName[i] != ',' )
     60        {
     61            break;
     62        }
     63    }
     64
     65    // 基本型をセット
     66    type.SetBasicType( DEF_OBJECT );
     67
     68    if( isValueType )
     69    {
     70        // 型パラメータに値型が指定された場合
     71
     72        // 仮型パラメータを実型パラメータに変換
     73        Types actualTypes;
     74        BOOST_FOREACH( const GenericType &genericType, genericTypes )
     75        {
     76            actualTypes.push_back( genericType.GetType() );
     77        }
     78
     79        // テンプレートとしてクラスを展開する
     80        const CClass *pExpandedClass = LexicalAnalyzer::TemplateExpand( *const_cast<CClass *>(pGenericClass), actualTypes );
     81
     82        if( pExpandedClass )
     83        {
     84            // 拡張情報をセット
     85            type.SetClassPtr( pExpandedClass );
     86        }
     87        else
     88        {
     89            // TODO: 消す
     90            goto Generic;
     91        }
     92    }
     93    else
     94    {
     95Generic:
     96        // 型パラメータにクラス型が指定された場合
     97
     98        // ジェネリック クラスとして利用する
    6899
    69100        // 拡張情報をセット
    70101        type.SetClassPtr( pGenericClass );
    71102        type.SetActualGenericTypes( genericTypes );
    72 
    73         return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
     103    }
     104
     105    return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
     106}
     107ActiveBasic::Compiler::Error::StringToTypeErrorCode::EnumType Compiler::StringToTypeEx( const std::string &typeName, Type &type, bool isResolveGenerics )
     108{
     109    type.SetIndex( -1 );
     110
     111
     112    /////////////////////////////////////////////////////////
     113    // ☆★☆ ジェネリクスサポート ☆★☆
     114
     115    if( strstr( typeName.c_str(), "<" ) )
     116    {
     117        return StringToGenericTypeEx( typeName, type );
    74118    }
    75119
    … …  
    147191    // TypeDefされた型
    148192    ////////////////////
    149     int i=this->GetObjectModule().meta.GetTypeDefs().GetIndex( LexicalAnalyzer::FullNameToSymbol( typeName ) );
    150     if(i!=-1)
    151     {
    152         type = this->GetObjectModule().meta.GetTypeDefs()[i].GetBaseType();
     193    const TypeDef *pTypeDef = this->GetObjectModule().meta.GetTypeDefs().Find( LexicalAnalyzer::FullNameToSymbol( typeName ) );
     194    if( pTypeDef )
     195    {
     196        type = pTypeDef->GetBaseType();
     197
     198        if( type.IsObject() )
     199        {
     200            if( isResolveGenerics && !type.HasActualGenericType() )
     201            {
     202                // ジェネリッククラスの場合
     203                trace( "型解決されていない" );
     204                return ActiveBasic::Compiler::Error::StringToTypeErrorCode::FailedResolveGenericType;
     205            }
     206        }
     207
    153208        return ActiveBasic::Compiler::Error::StringToTypeErrorCode::Successful;
    154209    }
    155210
    156211    //クラス
    157     const CClass *pobj_c = this->GetObjectModule().meta.GetClasses().FindEx( LexicalAnalyzer::FullNameToSymbol( typeName ) );
     212    const CClass *pobj_c = this->GetObjectModule().meta.FindClassSupportedTypeDef( LexicalAnalyzer::FullNameToSymbol( typeName ) );
    158213    if(pobj_c)
    159214    {

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

    r603 r632  
    287287    Subscripts subscripts;
    288288    Type type;
    289     GetDimentionFormat(buffer,VarName,subscripts,type,initBuffer,lpszConstructParameter);
     289    if( !GetDimentionFormat(buffer,VarName,subscripts,type,initBuffer,lpszConstructParameter) )
     290    {
     291        return NULL;
     292    }
    290293
    291294    //重複チェック
    … …  
    12171220                extern int cp;
    12181221                if(i3==0){
    1219                     if(bStatic){
    1220                         //静的メンバを追加
    1221                         cp=i;   //エラー用
    1222                         pobj_c->AddStaticMember(
    1223                             LexicalAnalyzer::CreateMember( *pobj_c, accessibility, isConst, false, temporary, i )
    1224                         );
    1225                     }
    1226                     else{
    1227                         //メンバを追加
    1228                         cp=i;   //エラー用
    1229                         pobj_c->AddDynamicMember(
    1230                             LexicalAnalyzer::CreateMember( *pobj_c, accessibility, isConst, false, temporary, i )
    1231                         );
    1232 
    1233 
    1234                         if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
    1235                             if( !pobj_c->GetDynamicMembers().back()->GetType().GetClass().IsReady() ){
    1236                                 //参照先が読み取られていないとき
    1237                                 GetClass_recur( pobj_c->GetDynamicMembers().back()->GetType().GetClass().GetName().c_str(), classes );
     1222                    cp=i;   //エラー用
     1223                    Member *pMember = LexicalAnalyzer::CreateMember( *pobj_c, accessibility, isConst, false, temporary, i );
     1224                    if( pMember )
     1225                    {
     1226                        if(bStatic)
     1227                        {
     1228                            //静的メンバを追加
     1229                            pobj_c->AddStaticMember( pMember );
     1230                        }
     1231                        else
     1232                        {
     1233                            //メンバを追加
     1234                            pobj_c->AddDynamicMember( pMember );
     1235
     1236
     1237                            if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
     1238                                if( !pobj_c->GetDynamicMembers().back()->GetType().GetClass().IsReady() ){
     1239                                    //参照先が読み取られていないとき
     1240                                    GetClass_recur( pobj_c->GetDynamicMembers().back()->GetType().GetClass().GetName().c_str(), classes );
     1241                                }
    12381242                            }
    1239                         }
    1240 
    1241 
    1242                         if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
    1243                             //循環参照のチェック
    1244                             pobj_LoopRefCheck->add(pobj_c->GetName().c_str());
    1245                             if(!MemberVar_LoopRefCheck(pobj_c->GetDynamicMembers().back()->GetType().GetClass())){
    1246                                 //エラー回避
    1247                                 Type &type = const_cast<Type &>(pobj_c->GetDynamicMembers().back()->GetType());
    1248                                 type.SetBasicType( DEF_PTR_VOID );
     1243
     1244
     1245                            if(pobj_c->GetDynamicMembers().back()->GetType().IsStruct()){
     1246                                //循環参照のチェック
     1247                                pobj_LoopRefCheck->add(pobj_c->GetName().c_str());
     1248                                if(!MemberVar_LoopRefCheck(pobj_c->GetDynamicMembers().back()->GetType().GetClass())){
     1249                                    //エラー回避
     1250                                    Type &type = const_cast<Type &>(pobj_c->GetDynamicMembers().back()->GetType());
     1251                                    type.SetBasicType( DEF_PTR_VOID );
     1252                                }
     1253                                pobj_LoopRefCheck->del(pobj_c->GetName().c_str());
    12491254                            }
    1250                             pobj_LoopRefCheck->del(pobj_c->GetName().c_str());
    12511255                        }
    12521256                    }
    … …  
    13551359    classes.Iterator_Init();
    13561360}
     1361
     1362void LexicalAnalyzer::TemplateExpand_ResolveMethod( const CMethod *pBaseMethod, const Types &actualTypes, CClass *pNewClass )
     1363{
     1364    UserProc *pUserProc = new UserProc(
     1365        pBaseMethod->GetUserProc(),
     1366        pNewClass
     1367    );
     1368    pUserProc->Using();
     1369    pUserProc->GetParameters().clear();
     1370    pUserProc->RealParams().clear();
     1371
     1372    // パラメータのジェネリック型を解決
     1373    BOOST_FOREACH( const Parameter *pParam, pBaseMethod->GetUserProc().Params() )
     1374    {
     1375        Type type = pParam->IsTypeParameter()
     1376            ? actualTypes[pParam->GetFormalTypeIndex()]
     1377            : *pParam;
     1378        type.SetPtrLevel( pParam->PtrLevel() );
     1379
     1380        pUserProc->GetParameters().push_back( new Parameter( *pParam, type ) );
     1381    }
     1382    BOOST_FOREACH( const Parameter *pParam, pBaseMethod->GetUserProc().RealParams() )
     1383    {
     1384        Type type = pParam->IsTypeParameter()
     1385            ? actualTypes[pParam->GetFormalTypeIndex()]
     1386            : *pParam;
     1387        type.SetPtrLevel( pParam->PtrLevel() );
     1388
     1389        pUserProc->RealParams().push_back( new Parameter( *pParam, type ) );
     1390    }
     1391
     1392    // 戻り値のジェネリック型を解決
     1393    if( pUserProc->ReturnType().IsTypeParameter() )
     1394    {
     1395        Type type = actualTypes[pUserProc->ReturnType().GetFormalTypeIndex()];
     1396        type.SetPtrLevel( pUserProc->ReturnType().PtrLevel() );
     1397        pUserProc->SetReturnType( type );
     1398    }
     1399
     1400    compiler.GetObjectModule().meta.GetUserProcs().Put( pUserProc );
     1401    compiler.GetObjectModule().meta.GetUserProcs().Iterator_Init();
     1402
     1403    LexicalAnalyzer::AddMethod(
     1404        pNewClass,
     1405        pUserProc,
     1406        pBaseMethod->GetAccessibility(),
     1407        pBaseMethod->IsStatic(),
     1408        pBaseMethod->IsConst(),
     1409        pBaseMethod->IsAbstract(),
     1410        pBaseMethod->IsVirtual(),
     1411        false,
     1412        "",
     1413        false,
     1414        -1
     1415    );
     1416}
     1417
     1418const CClass *LexicalAnalyzer::TemplateExpand( CClass &_class, const Types &actualTypes )
     1419{
     1420    // 展開済みのクラスがあればそれを返す
     1421    BOOST_FOREACH( const ExpandedTemplateClass *pExpandedTemplateClass, _class.expandedTemplateClasses )
     1422    {
     1423        if( pExpandedTemplateClass->GetActualTypes().IsEquals( actualTypes ) )
     1424        {
     1425            return &pExpandedTemplateClass->GetClass();
     1426        }
     1427    }
     1428
     1429
     1430    /////////////////////////////////////////////////////////////////
     1431    // 未展開の場合は新たに展開する
     1432    /////////////////////////////////////////////////////////////////
     1433
     1434    // クラスをコピー
     1435    CClass *pNewClass = new CClass(
     1436        _class.GetNamespaceScopes(),
     1437        _class.GetImportedNamespaces(),
     1438        _class.GetName(),
     1439        _class.GetClassType(),
     1440        _class.GetFormalGenericTypes(),
     1441        actualTypes,
     1442        _class.GetConstructorMemberSubIndex(),
     1443        _class.GetDestructorMemberSubIndex(),
     1444        0,
     1445        _class.GetFixedAlignment()
     1446    );
     1447
     1448    // 基底クラス
     1449    pNewClass->SetSuperClass( &_class.GetSuperClass() );
     1450
     1451    // インターフェイスのジェネリック型を解決
     1452    BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
     1453    {
     1454        pNewClass->AddInterface( new ::Interface( &pInterface->GetClass(), actualTypes ) );
     1455    }
     1456
     1457    // メンバのジェネリック型を解決
     1458    BOOST_FOREACH( const Member *pMember, _class.GetDynamicMembers() )
     1459    {
     1460        Type type = pMember->GetType();
     1461        if( type.IsTypeParameter() )
     1462        {
     1463            // ジェネリック型だったときは値型に変換
     1464            type = actualTypes[type.GetFormalTypeIndex()];
     1465            type.SetPtrLevel( pMember->GetType().PtrLevel() );
     1466        }
     1467
     1468        pNewClass->GetDynamicMembers().push_back(
     1469            new Member( *pMember, type )
     1470        );
     1471    }
     1472
     1473    // クラス メソッドのジェネリック型を解決
     1474    BOOST_FOREACH( const CMethod *pMethod, _class.GetDynamicMethods() )
     1475    {
     1476        if( pMethod->GetUserProc().GetParentClassPtr() == &_class )
     1477        {
     1478            // ターゲットクラス内で実装されるメソッドの場合
     1479
     1480            TemplateExpand_ResolveMethod( pMethod, actualTypes, pNewClass );
     1481        }
     1482        else
     1483        {
     1484            DynamicMethod *pNewDynamicMethod = new DynamicMethod( *pMethod );
     1485            pNewClass->GetDynamicMethods().push_back( pNewDynamicMethod );
     1486        }
     1487    }
     1488
     1489    // インターフェイス メソッドのジェネリック型を解決
     1490    BOOST_FOREACH( const ::Interface *pInterface, _class.GetInterfaces() )
     1491    {
     1492        BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() )
     1493        {
     1494            TemplateExpand_ResolveMethod( pMethod, actualTypes, pNewClass );
     1495        }
     1496    }
     1497
     1498    pNewClass->SetVtblNum( _class.GetVtblNum() );
     1499
     1500    // 展開済みクラスとして登録
     1501    _class.expandedTemplateClasses.push_back( new ExpandedTemplateClass( pNewClass, actualTypes ) );
     1502
     1503    pNewClass->Readed();
     1504
     1505    return pNewClass;
     1506}

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

    r574 r632  
    156156
    157157    //ソースコードの位置
    158     userProc.SetCodePos( nowLine );
     158    userProc.SetSourceCodePosition( SourceCodePosition( compiler.GetObjectModule().GetName(), nowLine ) );
    159159
    160160    //パラメータ
    … …  
    286286
    287287    //ソースコードの位置
    288     pProc->SetCodePos( nowLine );
     288    pProc->SetSourceCodePosition( SourceCodePosition( compiler.GetObjectModule().GetName(), nowLine ) );
    289289
    290290    //パラメータ

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

    r593 r632  
    9696    while( classes.Iterator_HasNext() )
    9797    {
    98         GenerateFullVTables( *classes.Iterator_GetNext() );
     98        CClass *pClass = classes.Iterator_GetNext();
     99        GenerateFullVTables( *pClass );
     100
     101        // テンプレート展開されたクラスも
     102        BOOST_FOREACH( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, pClass->expandedTemplateClasses )
     103        {
     104            if( !pExpandedTemplateClass->GetClass().expandedTemplateClasses.empty() )
     105            {
     106                // テンプレート展開後のクラスが更にテンプレート展開されていることはありえない
     107                throw;
     108            }
     109
     110            GenerateFullVTables( pExpandedTemplateClass->GetClass() );
     111        }
    99112    }
    100113}
    … …  
    167180    while( classes.Iterator_HasNext() )
    168181    {
    169         ActionVtblSchedule( *classes.Iterator_GetNext(), ImageBase, MemPos_CodeSection, MemPos_DataSection );
     182        CClass *pClass = classes.Iterator_GetNext();
     183        ActionVtblSchedule( *pClass, ImageBase, MemPos_CodeSection, MemPos_DataSection );
     184
     185        // テンプレート展開されたクラスも
     186        BOOST_FOREACH( ActiveBasic::Common::Lexical::ExpandedTemplateClass *pExpandedTemplateClass, pClass->expandedTemplateClasses )
     187        {
     188            if( !pExpandedTemplateClass->GetClass().expandedTemplateClasses.empty() )
     189            {
     190                // テンプレート展開後のクラスが更にテンプレート展開されていることはありえない
     191                throw;
     192            }
     193
     194            ActionVtblSchedule( pExpandedTemplateClass->GetClass(), ImageBase, MemPos_CodeSection, MemPos_DataSection );
     195        }
    170196    }
    171197}

  • trunk/ab5.0/abdev/ab_common/ab_common.vcproj

    r622 r632  
    340340                <File
    341341                    RelativePath=".\src\Lexical\Interface.cpp"
     342                    >
     343                </File>
     344                <File
     345                    RelativePath=".\src\Lexical\Member.cpp"
    342346                    >
    343347                </File>
    … …  
    416420                </File>
    417421                <File
     422                    RelativePath=".\src\Lexical\Template.cpp"
     423                    >
     424                </File>
     425                <File
    418426                    RelativePath=".\src\Lexical\Type.cpp"
    419427                    >
    … …  
    530538                </File>
    531539                <File
     540                    RelativePath=".\include\Lexical\Template.h"
     541                    >
     542                </File>
     543                <File
    532544                    RelativePath=".\include\Lexical\Type.h"
    533545                    >

  • trunk/ab5.0/abdev/ab_common/include/Lexical/Class.h

    r603 r632  
    22
    33class UserProc;
     4class UserProcs;
    45class Delegate;
     6class Classes;
    57
    68class ClassPrototype : public Prototype, public DynamicMethodsPrototype
    … …  
    7880    //アラインメント値
    7981    int fixedAlignment;
     82
     83public:
     84    ActiveBasic::Common::Lexical::ExpandedTemplateClasses expandedTemplateClasses;
    8085
    8186    // XMLシリアライズ用
    … …  
    101106        ar & BOOST_SERIALIZATION_NVP( staticMethods );
    102107        ar & BOOST_SERIALIZATION_NVP( fixedAlignment );
     108        ar & BOOST_SERIALIZATION_NVP( expandedTemplateClasses );
    103109    }
    104110
    … …  
    106112public:
    107113
    108     CClass( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const std::string &name )
    109         : ClassPrototype( namespaceScopes, name )
    110         , importedNamespaces( importedNamespaces )
    111         , classType( Class )
    112         , pSuperClass( NULL )
    113         , blittableType( Type() )
    114         , isReady( false )
    115         , fixedAlignment( 0 )
    116         , ConstructorMemberSubIndex( -1 )
    117         , DestructorMemberSubIndex( -1 )
    118         , vtblNum( 0 )
    119         , vtbl_offset( -1 )
    120         , comVtblOffset( 0 )
    121         , isCompilingConstructor( false )
    122         , isCompilingDestructor( false )
    123         , cacheSize( 0 )
    124     {
    125     }
    126     CClass()
    127         : ClassPrototype()
    128         , importedNamespaces()
    129         , classType()
    130         , pSuperClass( NULL )
    131         , blittableType( Type() )
    132         , isReady( false )
    133         , fixedAlignment( 0 )
    134         , ConstructorMemberSubIndex( -1 )
    135         , DestructorMemberSubIndex( -1 )
    136         , vtblNum( 0 )
    137         , vtbl_offset( -1 )
    138         , comVtblOffset( 0 )
    139         , isCompilingConstructor( false )
    140         , isCompilingDestructor( false )
    141         , cacheSize( 0 )
    142     {
    143     }
    144     ~CClass()
    145     {
    146         // 動的メンバ
    147         BOOST_FOREACH( Member *member, dynamicMembers )
    148         {
    149             delete member;
    150         }
    151 
    152         // 静的メンバ
    153         BOOST_FOREACH( Member *member, staticMembers )
    154         {
    155             delete member;
    156         }
    157 
    158         // インターフェイス
    159         BOOST_FOREACH( ::Interface *pInterface, interfaces )
    160         {
    161             delete pInterface;
    162         }
    163     }
     114    CClass( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const std::string &name );
     115    CClass( const NamespaceScopes &namespaceScopes,
     116        const NamespaceScopesCollection &importedNamespaces,
     117        const std::string &name, ClassType classType,
     118        const GenericTypes &formalGenericTypes,
     119        const Types &superClassActualTypeParameters,
     120        int ConstructorMemberSubIndex,
     121        int DestructorMemberSubIndex,
     122        int vtblNum,
     123        int fixedAlignment );
     124    CClass();
     125    ~CClass();
    164126
    165127    virtual const std::string &GetKeyName() const
    … …  
    273235        this->classType = classType;
    274236    }
     237    ClassType GetClassType() const
     238    {
     239        return classType;
     240    }
    275241
    276242
    … …  
    314280        return interfaces;
    315281    }
     282    Interfaces &GetInterfaces()
     283    {
     284        return interfaces;
     285    }
    316286    bool IsInheritsInterface( const CClass *pInterfaceClass ) const;
    317287
    … …  
    372342        this->ConstructorMemberSubIndex = constructorMemberSubIndex;
    373343    }
     344    int GetConstructorMemberSubIndex() const
     345    {
     346        return ConstructorMemberSubIndex;
     347    }
    374348
    375349    //デストラクタ メソッドを取得
    … …  
    382356    {
    383357        this->DestructorMemberSubIndex = destructorMemberSubIndex;
     358    }
     359    int GetDestructorMemberSubIndex() const
     360    {
     361        return DestructorMemberSubIndex;
    384362    }
    385363

  • trunk/ab5.0/abdev/ab_common/include/Lexical/Member.h

    r603 r632  
    3333
    3434    int source_code_address;
     35
     36    Member( Prototype::Accessibility accessibility, const std::string &name, const Type &newType, bool isConst, const Subscripts &subscripts, const std::string &initializeExpression, const std::string &constructParameter );
     37    Member( const Member &member, const Type &actualType );
     38    Member( const Member &member );
     39    Member();
     40    ~Member();
    3541
    3642    const std::string &GetName() const
    … …  
    7076        return constructParameter;
    7177    }
    72 
    73     Member( Prototype::Accessibility accessibility, const std::string &name, const Type &newType, bool isConst, const Subscripts &subscripts, const std::string &initializeExpression, const std::string &constructParameter )
    74         : MemberPrototype( accessibility )
    75         , name( name )
    76         , type( newType )
    77         , isConst( isConst )
    78         , subscripts( subscripts )
    79         , initializeExpression( initializeExpression )
    80         , constructParameter( constructParameter )
    81     {
    82     }
    83     Member::Member(Member &member)
    84         : MemberPrototype( member.GetAccessibility() )
    85         , name( member.GetName() )
    86         , type( member.GetType() )
    87         , isConst( member.IsConst() )
    88         , subscripts( member.GetSubscripts() )
    89     {
    90         //ソースコードの位置
    91         source_code_address=member.source_code_address;
    92     }
    93     Member()
    94     {
    95     }
    96     ~Member()
    97     {
    98     }
    9978};
    10079typedef std::vector<Member *> Members;

  • trunk/ab5.0/abdev/ab_common/include/Lexical/ObjectModule.h

    r603 r632  
    44{
    55public:
     6    // オブジェクトモジュール名
     7    std::string name;
     8
    69    // メタ情報
    710    Meta meta;
    … …  
    2932        trace_for_serialize( "serializing - objectModule" );
    3033
     34        ar & BOOST_SERIALIZATION_NVP( name );
    3135        ar & BOOST_SERIALIZATION_NVP( meta );
    3236        ar & BOOST_SERIALIZATION_NVP( globalNativeCode );
    … …  
    3943    void StaticLink( ObjectModule &objectModule );
    4044
     45    const std::string &GetName() const
     46    {
     47        return name;
     48    }
     49    void SetName( const std::string &name )
     50    {
     51        this->name = name;
     52    }
    4153    int GetCurrentSourceIndex() const
    4254    {

  • trunk/ab5.0/abdev/ab_common/include/Lexical/Parameter.h

    r603 r632  
    2626
    2727public:
    28     Parameter( const std::string &varName, const Type &type, bool isRef = false, const std::string initValue = "" ):
    29         Type( type ),
    30         varName( varName ),
    31         isRef( isRef ),
    32         isArray( false ),
    33         initValue( initValue )
    34     {
    35     }
    36     Parameter( const Parameter &param ):
    37         Type( param ),
    38         varName( param.varName ),
    39         isRef( param.isRef ),
    40         isArray( param.isArray ),
    41         subscripts( param.subscripts ),
    42         initValue( param.initValue )
    43     {
    44     }
    45     Parameter()
    46     {
    47     }
    48     ~Parameter(){}
     28    Parameter( const std::string &varName, const Type &type, bool isRef = false, const std::string initValue = "" );
     29    Parameter( const Parameter &param, const Type &type );
     30    Parameter( const Parameter &param );
     31    Parameter();
     32    ~Parameter();
    4933
    5034    void SetArray( const Subscripts &subscripts ){

  • trunk/ab5.0/abdev/ab_common/include/Lexical/Procedure.h

    r604 r632  
    2424    Type returnType;
    2525
     26private:
    2627    // ソースコードの位置
    27     int codePos;
     28    SourceCodePosition sourceCodePosition;
    2829
    2930    // XMLシリアライズ用
    … …  
    4041        ar & BOOST_SERIALIZATION_NVP( params );
    4142        ar & BOOST_SERIALIZATION_NVP( returnType );
    42         ar & BOOST_SERIALIZATION_NVP( codePos );
     43        ar & BOOST_SERIALIZATION_NVP( sourceCodePosition );
    4344    }
    4445
    … …  
    4950        , isCdecl( isCdecl )
    5051        , isUsing( false )
    51         , codePos( -1 )
    5252    {
    5353    }
    … …  
    8383    }
    8484
    85     int GetCodePos() const
    86     {
    87         return codePos;
    88     }
    89     void SetCodePos( int codePos )
    90     {
    91         this->codePos = codePos;
     85    const SourceCodePosition &GetSourceCodePosition() const
     86    {
     87        return sourceCodePosition;
     88    }
     89    void SetSourceCodePosition( const SourceCodePosition &sourceCodePosition )
     90    {
     91        this->sourceCodePosition = sourceCodePosition;
    9292    }
    9393
    … …  
    178178public:
    179179
    180     UserProc( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const std::string &name, Kind kind, bool isMacro, bool isCdecl, bool isExport )
    181         : Procedure( namespaceScopes, name, kind, isCdecl )
    182         , importedNamespaces( importedNamespaces )
    183         , pParentClass( NULL )
    184         , pInterface( NULL )
    185         , pMethod( NULL )
    186         , isMacro( isMacro )
    187         , secondParmNum( 0 )
    188         , realSecondParmNum( 1 )
    189         , isExport( isExport )
    190         , isSystem( false )
    191         , isAutoGeneration( false )
    192         , isCompiled( false )
    193         , beginOpAddress( 0 )
    194         , endOpAddress( 0 )
    195     {
    196         static int id_base=0;
    197         id = ( id_base ++ );
    198     }
    199     UserProc()
    200     {
    201     }
    202     ~UserProc()
    203     {
    204         BOOST_FOREACH( Parameter *pParam, realParams ){
    205             delete pParam;
    206         }
    207     }
     180    UserProc( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const std::string &name, Kind kind, bool isMacro, bool isCdecl, bool isExport );
     181    UserProc( const UserProc &userProc, const CClass *pParentClass );
     182    UserProc();
     183    ~UserProc();
    208184
    209185    void SetReturnType( const Type &newReturnType )

  • trunk/ab5.0/abdev/ab_common/include/Lexical/Source.h

    r603 r632  
    253253};
    254254typedef std::vector<BasicSource> BasicSources;
     255
     256class SourceCodePosition
     257{
     258    std::string objectModuleName;
     259    int pos;
     260
     261    // XMLシリアライズ用
     262private:
     263    friend class boost::serialization::access;
     264    template<class Archive> void serialize(Archive& ar, const unsigned int version)
     265    {
     266        trace_for_serialize( "serializing - IncludedFilesRelation" );
     267
     268        ar & BOOST_SERIALIZATION_NVP( objectModuleName );
     269        ar & BOOST_SERIALIZATION_NVP( pos );
     270    }
     271
     272public:
     273    SourceCodePosition( const std::string &objectModuleName, int pos )
     274        : objectModuleName( objectModuleName )
     275        , pos( pos )
     276    {
     277    }
     278    SourceCodePosition()
     279        : pos( -1 )
     280    {
     281    }
     282
     283    const std::string &GetObjectModuleName() const
     284    {
     285        return objectModuleName;
     286    }
     287    int GetPos() const
     288    {
     289        return pos;
     290    }
     291};

  • trunk/ab5.0/abdev/ab_common/include/Lexical/Type.h

    r603 r632  
    136136    void PtrLevelDown(){
    137137        PTR_LEVEL_DOWN( basicType );
     138    }
     139    void SetPtrLevel( int level )
     140    {
     141        basicType = MAKE_PTR_TYPE( NATURAL_TYPE( basicType ), level );
    138142    }
    139143
    … …  
    166170    bool IsReal() const;
    167171    bool Is64() const;
     172    bool IsValueType() const;
    168173    bool IsProcPtr() const;
    169174    bool IsStruct() const;
    … …  
    233238    static int GetBasicTypeFromSimpleName( const char *variable );
    234239};
    235 typedef std::vector<Type> Types;
     240
     241class Types
     242    : public std::vector<Type>
     243{
     244    // XMLシリアライズ用
     245private:
     246    friend class boost::serialization::access;
     247    template<class Archive> void serialize(Archive& ar, const unsigned int version)
     248    {
     249        ar & boost::serialization::make_nvp("vector_Type", boost::serialization::base_object<vector<Type>>(*this));
     250    }
     251
     252public:
     253    bool IsEquals( const Types &Types ) const;
     254};
    236255
    237256/*!

  • trunk/ab5.0/abdev/ab_common/include/Lexical/TypeDef.h

    r603 r632  
    5959
    6060    void Add( const NamespaceScopes &namespaceScopes, const std::string &name, const std::string &baseName, int nowLine );
    61     int GetIndex( const Symbol &symbol ) const;
     61    const TypeDef *Find( const Symbol &symbol ) const;
    6262};

  • trunk/ab5.0/abdev/ab_common/include/ab_common.h

    r622 r632  
    1919#include "Lexical/Interface.h"
    2020#include "Lexical/Member.h"
     21#include "Lexical/Template.h"
    2122#include "Lexical/Class.h"
    2223#include "Lexical/Parameter.h"

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

    r603 r632  
    11#include "stdafx.h"
     2
     3
     4CClass::CClass( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const std::string &name )
     5    : ClassPrototype( namespaceScopes, name )
     6    , importedNamespaces( importedNamespaces )
     7    , classType( Class )
     8    , pSuperClass( NULL )
     9    , blittableType( Type() )
     10    , isReady( false )
     11    , fixedAlignment( 0 )
     12    , ConstructorMemberSubIndex( -1 )
     13    , DestructorMemberSubIndex( -1 )
     14    , vtblNum( 0 )
     15    , vtbl_offset( -1 )
     16    , comVtblOffset( 0 )
     17    , isCompilingConstructor( false )
     18    , isCompilingDestructor( false )
     19    , cacheSize( 0 )
     20{
     21}
     22
     23CClass::CClass( const NamespaceScopes &namespaceScopes,
     24    const NamespaceScopesCollection &importedNamespaces,
     25    const std::string &name,
     26    ClassType classType,
     27    const GenericTypes &formalGenericTypes,
     28    const Types &superClassActualTypeParameters,
     29    int ConstructorMemberSubIndex,
     30    int DestructorMemberSubIndex,
     31    int vtblNum,
     32    int fixedAlignment )
     33    : ClassPrototype( namespaceScopes, name )
     34    , importedNamespaces( importedNamespaces )
     35    , classType( classType )
     36    , formalGenericTypes( formalGenericTypes )
     37    , pSuperClass( NULL )
     38    , superClassActualTypeParameters( superClassActualTypeParameters )
     39    , blittableType( Type() )
     40    , isReady( false )
     41    , ConstructorMemberSubIndex( ConstructorMemberSubIndex )
     42    , DestructorMemberSubIndex( DestructorMemberSubIndex )
     43    , vtblNum( vtblNum )
     44    , fixedAlignment( fixedAlignment )
     45    , vtbl_offset( -1 )
     46    , comVtblOffset( 0 )
     47    , isCompilingConstructor( false )
     48    , isCompilingDestructor( false )
     49    , cacheSize( 0 )
     50{
     51}
     52
     53CClass::CClass()
     54    : ClassPrototype()
     55    , importedNamespaces()
     56    , classType()
     57    , pSuperClass( NULL )
     58    , blittableType( Type() )
     59    , isReady( false )
     60    , fixedAlignment( 0 )
     61    , ConstructorMemberSubIndex( -1 )
     62    , DestructorMemberSubIndex( -1 )
     63    , vtblNum( 0 )
     64    , vtbl_offset( -1 )
     65    , comVtblOffset( 0 )
     66    , isCompilingConstructor( false )
     67    , isCompilingDestructor( false )
     68    , cacheSize( 0 )
     69{
     70}
     71
     72CClass::~CClass()
     73{
     74    // 動的メンバ
     75    BOOST_FOREACH( Member *member, dynamicMembers )
     76    {
     77        delete member;
     78    }
     79
     80    // 静的メンバ
     81    BOOST_FOREACH( Member *member, staticMembers )
     82    {
     83        delete member;
     84    }
     85
     86    // インターフェイス
     87    BOOST_FOREACH( ::Interface *pInterface, interfaces )
     88    {
     89        delete pInterface;
     90    }
     91
     92    // テンプレート展開済みのクラス
     93    BOOST_FOREACH( ExpandedTemplateClass *pExpandedTemplateClass, expandedTemplateClasses )
     94    {
     95        delete pExpandedTemplateClass;
     96    }
     97}
    298
    399void CClass::Using() const

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

    r603 r632  
    186186
    187187    // TypeDefも見る
    188     int index = this->GetTypeDefs().GetIndex( symbol );
    189     if( index != -1 ){
    190         Type type = this->GetTypeDefs()[index].GetBaseType();
    191         if( type.IsObject() ){
     188    const TypeDef *pTypeDef = this->GetTypeDefs().Find( symbol );
     189    if( pTypeDef )
     190    {
     191        Type type = pTypeDef->GetBaseType();
     192        if( type.IsObject() )
     193        {
    192194            return &type.GetClass();
    193195        }

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

    r603 r632  
    11#include "stdafx.h"
     2
     3Parameter::Parameter( const std::string &varName, const Type &type, bool isRef, const std::string initValue )
     4    : Type( type )
     5    , varName( varName )
     6    , isRef( isRef )
     7    , isArray( false )
     8    , initValue( initValue )
     9{
     10}
     11
     12Parameter::Parameter( const Parameter &param, const Type &type )
     13    : Type( type )
     14    , varName( param.varName )
     15    , isRef( param.isRef )
     16    , isArray( param.isArray )
     17    , subscripts( param.subscripts )
     18    , initValue( param.initValue )
     19{
     20}
     21
     22Parameter::Parameter( const Parameter &param )
     23    : Type( param )
     24    , varName( param.varName )
     25    , isRef( param.isRef )
     26    , isArray( param.isArray )
     27    , subscripts( param.subscripts )
     28    , initValue( param.initValue )
     29{
     30}
     31
     32Parameter::Parameter()
     33{
     34}
     35
     36Parameter::~Parameter()
     37{
     38}
    239
    340bool Parameter::Equals( const Parameter &param, bool isContravariant ) const

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

    r603 r632  
    11#include "stdafx.h"
     2
     3int id_base = 0;
     4
     5UserProc::UserProc( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const std::string &name, Kind kind, bool isMacro, bool isCdecl, bool isExport )
     6    : Procedure( namespaceScopes, name, kind, isCdecl )
     7    , importedNamespaces( importedNamespaces )
     8    , pParentClass( NULL )
     9    , pInterface( NULL )
     10    , pMethod( NULL )
     11    , isMacro( isMacro )
     12    , secondParmNum( 0 )
     13    , realSecondParmNum( 1 )
     14    , isExport( isExport )
     15    , isSystem( false )
     16    , isAutoGeneration( false )
     17    , isCompiled( false )
     18    , beginOpAddress( 0 )
     19    , endOpAddress( 0 )
     20    , id( id_base ++ )
     21{
     22}
     23
     24UserProc::UserProc( const UserProc &userProc, const CClass *pParentClass )
     25    : Procedure( userProc )
     26    , _paramStr( userProc._paramStr )
     27    , importedNamespaces( userProc.importedNamespaces )
     28    , pParentClass( pParentClass )
     29    , pInterface( NULL )
     30    , pMethod( NULL )
     31    , isMacro( userProc.isMacro )
     32    , secondParmNum( userProc.secondParmNum )
     33    , realParams( userProc.realParams )
     34    , realSecondParmNum( userProc.realSecondParmNum )
     35    , isExport( userProc.isExport )
     36    , isSystem( userProc.isSystem )
     37    , isAutoGeneration( userProc.isAutoGeneration )
     38    , isCompiled( false )
     39    , beginOpAddress( 0 )
     40    , endOpAddress( 0 )
     41    , localVars( Variables() )
     42    , id( id_base ++ )
     43    , nativeCode( NativeCode() )
     44{
     45}
     46
     47UserProc::UserProc()
     48{
     49}
     50
     51UserProc::~UserProc()
     52{
     53    BOOST_FOREACH( Parameter *pParam, realParams ){
     54        delete pParam;
     55    }
     56}
    257
    358bool UserProc::IsEqualForOverride( const Types &actualTypeParametersForThisProc, const UserProc *pUserProc ) const
    … …  
    54109const NamespaceScopes &UserProc::GetNamespaceScopes() const
    55110{
    56     if( HasParentClass() ){
     111    if( HasParentClass() )
     112    {
    57113        return GetParentClassPtr()->GetNamespaceScopes();
    58114    }

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

    r603 r632  
    55const NamespaceSupporter *Symbol::namespaceSupporter = NULL;
    66
    7 char *calcNames[255] = {
     7char *calcNames[256] = {
    88    "xor",
    99};

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

    r603 r632  
    384384    return false;
    385385}
     386
     387bool Type::IsValueType() const
     388{
     389    return ( IsWhole() || IsReal() );
     390}
     391
    386392bool Type::IsProcPtr() const
    387393{
    … …  
    550556}
    551557
     558bool Types::IsEquals( const Types &types ) const
     559{
     560    if( this->size() != types.size() )
     561    {
     562        // アイテム数が違う
     563        return false;
     564    }
     565
     566    const Types &thisTypes = *this;
     567    for( int i=0; i<static_cast<int>(this->size()); i++ )
     568    {
     569        if( !thisTypes[i].Equals( types[i] ) )
     570        {
     571            return false;
     572        }
     573    }
     574
     575    return true;
     576}
    552577
    553578void ResolveFormalGenericTypeParameter( Type &typeParameter, const Type &classType, const UserProc *pUserProc )

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

    r603 r632  
    1717}
    1818
    19 int TypeDefCollection::GetIndex( const Symbol &symbol ) const{
    20     int max = (int)(*this).size();
    21     for( int i=0; i<max; i++ ){
    22         if( (*this)[i].IsEqualSymbol( symbol ) ){
    23             return i;
     19const TypeDef *TypeDefCollection::Find( const Symbol &symbol ) const
     20{
     21    const TypeDefCollection &typeDefs = *this;
     22    BOOST_FOREACH( const TypeDef &typeDef, typeDefs )
     23    {
     24        if( typeDef.IsEqualSymbol( symbol ) )
     25        {
     26            return &typeDef;
    2427        }
    2528    }
    26     return -1;
     29    return NULL;
    2730}

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

    r603 r632  
    289289    }
    290290
    291     trace_for_sourcecodestep( "★★★ " << pUserProc->GetFullName() << "のコンパイルを開始" );
     291    trace_for_sourcecodestep( "★★★ " << FormatEscapeSequenceStringToDefaultString( pUserProc->GetFullName() ) << "のコンパイルを開始" );
    292292
    293293    pUserProc->CompleteCompile();
    … …  
    330330    if( !pUserProc->IsAutoGeneration() )
    331331    {
    332         cp=pUserProc->GetCodePos();
     332        cp=pUserProc->GetSourceCodePosition().GetPos();
    333333        for(;;cp++){
    334334            if(IsCommandDelimitation(basbuf[cp])) break;

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

    r603 r632  
    540540            }
    541541
    542             int typeDefIndex = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex(
     542            const TypeDef *pTypeDef = compiler.GetObjectModule().meta.GetTypeDefs().Find(
    543543                LexicalAnalyzer::FullNameToSymbol( VarName )
    544544            );
    545             if( typeDefIndex != -1 ){
     545            if( pTypeDef )
     546            {
    546547                // TypeDef後の型名だったとき
    547                 lstrcpy( VarName, compiler.GetObjectModule().meta.GetTypeDefs()[typeDefIndex].GetBaseName().c_str() );
     548                lstrcpy( VarName, pTypeDef->GetBaseName().c_str() );
    548549            }
    549550

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

    r622 r632  
    576576
    577577            if(!hLib){
    578                 compiler.errorMessenger.Output(-106,pDllProc->GetDllFileName().c_str(),pDllProc->GetCodePos());
     578                compiler.errorMessenger.Output(-106,pDllProc->GetDllFileName().c_str(),pDllProc->GetSourceCodePosition().GetPos());
    579579            }
    580580        }
    … …  
    583583            if(!GetProcAddress(hLib,pDllProc->GetAlias().c_str())){
    584584                FreeLibrary(hLib);
    585                 compiler.errorMessenger.Output(-107,pDllProc->GetAlias(),pDllProc->GetCodePos());
     585                compiler.errorMessenger.Output(-107,pDllProc->GetAlias(),pDllProc->GetSourceCodePosition().GetPos());
    586586            }
    587587            FreeLibrary(hLib);

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

    r600 r632  
    10321032                        isNothing_stack[sp] = true;
    10331033
    1034                         type_stack[sp] = DEF_OBJECT;
    10351034                        if( baseType.IsObject() ){
     1035                            type_stack[sp] = DEF_OBJECT;
    10361036                            index_stack[sp] = baseType.GetIndex();
    10371037                        }
    10381038                        else{
    1039                             index_stack[sp] = (LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr();
     1039                            type_stack[sp] = baseType.GetBasicType();
     1040                            index_stack[sp] = baseType.GetIndex();
    10401041                        }
    10411042
Note: See TracChangeset for help on using the changeset viewer.