Changeset 299 in dev


Ignore:
Timestamp:
Aug 23, 2007, 6:17:00 PM (17 years ago)
Author:
dai_9181
Message:
 
Location:
trunk/abdev
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler32/CParameter.cpp

    r292 r299  
    214214            bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
    215215
    216 
    217             /////////////////////////////////////////////////////////
    218             // ☆★☆ ジェネリクスサポート ☆★☆
    219 
    220             if( dummyType.IsTypeParameter() )
    221             {
    222                 // 型パラメータだったとき
    223 
    224                 int ptrLevel = PTR_LEVEL( dummyType.GetBasicType() );
    225 
    226                 if( leftType.HasActualGenericType() )
    227                 {
    228                     // TODO: GetDummyActualGenericTypeを適切な形に実装し直す
    229                     dummyType = leftType.GetDummyActualGenericType();
    230                 }
    231                 else
    232                 {
    233                     // TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
    234                     dummyType.SetBasicType( DEF_OBJECT );
    235                 }
    236 
    237                 for( int i=0; i<ptrLevel; i++ )
    238                 {
    239                     dummyType.PtrLevelUp();
    240                 }
    241             }
    242 
    243             //
    244             /////////////////////////////////////////////////////////
     216            // 型パラメータを解決
     217            ResolveFormalGenericTypeParameter( dummyType, leftType );
    245218        }
    246219

  • trunk/abdev/BasicCompiler32/Compile_Func.cpp

    r290 r299  
    324324void Opcode_Func_SizeOf( const string &typeName ){
    325325    Type tempType;
    326     if( !Compiler::StringToType( typeName, tempType ) ){
     326    if( !compiler.StringToType( typeName, tempType ) ){
    327327        SetError(3,typeName,cp);
    328328        return;

  • trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp

    r294 r299  
    388388        else{
    389389            if( pUserProc->ReturnType().IsObject() ){
    390                 sprintf(temporary,"%s=Nothing%c%c%s",temp,1,ESC_AS, Compiler::TypeToString( pUserProc->ReturnType() ).c_str() );
     390                sprintf(temporary,"%s=Nothing%c%c%s",temp,1,ESC_AS, compiler.TypeToString( pUserProc->ReturnType() ).c_str() );
    391391            }
    392392            else{
    393393                //戻り値用の変数の定義
    394                 sprintf(temporary,"%s%c%c%s",temp,1,ESC_AS, Compiler::TypeToString( pUserProc->ReturnType() ).c_str() );
     394                sprintf(temporary,"%s%c%c%s",temp,1,ESC_AS, compiler.TypeToString( pUserProc->ReturnType() ).c_str() );
    395395            }
    396396

  • trunk/abdev/BasicCompiler32/Compile_Var.cpp

    r292 r299  
    223223    resultType = pMember->GetType();
    224224
    225 
    226     /////////////////////////////////////////////////////////
    227     // ☆★☆ ジェネリクスサポート ☆★☆
    228 
    229     if( resultType.IsTypeParameter() )
    230     {
    231         // 型パラメータだったとき
    232 
    233         int ptrLevel = PTR_LEVEL( resultType.GetBasicType() );
    234 
    235         if( classType.HasActualGenericType() )
    236         {
    237             // TODO: GetDummyActualGenericTypeを適切な形に実装し直す
    238             resultType = classType.GetDummyActualGenericType();
    239         }
    240         else
    241         {
    242             // TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
    243             resultType.SetBasicType( DEF_OBJECT );
    244         }
    245 
    246         for( int i=0; i<ptrLevel; i++ )
    247         {
    248             resultType.PtrLevelUp();
    249         }
    250     }
    251 
    252     //
    253     /////////////////////////////////////////////////////////
     225    // 型パラメータを解決
     226    ResolveFormalGenericTypeParameter( resultType, classType );
    254227
    255228
    … …  
    11211094}
    11221095
    1123 void dim( char *VarName, const Subscripts &subscripts, Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlags){
     1096void dim( char *VarName, const Subscripts &subscripts, const Type &type,const char *InitBuf,const char *ConstractParameter,DWORD dwFlags){
    11241097    if( UserProc::IsGlobalAreaCompiling() ){
    11251098        /////////////////////////

  • trunk/abdev/BasicCompiler32/NumOpe.cpp

    r293 r299  
    221221                //SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
    222222
    223 
    224                 /////////////////////////////////////////////////////////
    225                 // ☆★☆ ジェネリクスサポート ☆★☆
    226 
    227                 if( resultType.IsTypeParameter() )
    228                 {
    229                     // 型パラメータだったとき
    230 
    231                     int ptrLevel = PTR_LEVEL( resultType.GetBasicType() );
    232 
    233                     if( leftType.HasActualGenericType() )
    234                     {
    235                         // TODO: GetDummyActualGenericTypeを適切な形に実装し直す
    236                         resultType = leftType.GetDummyActualGenericType();
    237                     }
    238                     else
    239                     {
    240                         // TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
    241                         resultType.SetBasicType( DEF_OBJECT );
    242                     }
    243 
    244                     for( int i=0; i<ptrLevel; i++ )
    245                     {
    246                         resultType.PtrLevelUp();
    247                     }
    248                 }
    249 
    250                 //
    251                 /////////////////////////////////////////////////////////
     223                // 型パラメータを解決
     224                ResolveFormalGenericTypeParameter( resultType, leftType, pUserProc );
    252225            }
    253226           
    … …  
    780753                    // As演算子の右辺値
    781754                    //型名
    782                     if( Compiler::StringToType( term, resultType ) ){
     755                    if( compiler.StringToType( term, resultType ) ){
    783756                        resultType.SetBasicType( resultType.GetBasicType() | FLAG_CAST );
    784757                    }

  • trunk/abdev/BasicCompiler32/Opcode.h

    r293 r299  
    164164#define DIMFLAG_STATIC                  4
    165165#define DIMFLAG_CONST                   8
    166 void dim( char *VarName, const Subscripts &subscripts, Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags);
     166void dim( char *VarName, const Subscripts &subscripts, const Type &type, const char *InitBuf,const char *ConstractParameter,DWORD dwFlags);
    167167void SetVarPtrToEax(RELATIVE_VAR *pRelativeVar);
    168168void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar);

  • trunk/abdev/BasicCompiler32/OperatorProc.cpp

    r293 r299  
    259259    }
    260260
    261     Opcode_CallProc(Parameter,subs[0],0,ObjectName);
    262     resultType = subs[0]->ReturnType();
    263 
    264 
    265     /////////////////////////////////////////////////////////
    266     // ☆★☆ ジェネリクスサポート ☆★☆
    267 
    268     if( resultType.IsTypeParameter() )
    269     {
    270         // 型パラメータだったとき
    271 
    272         int ptrLevel = PTR_LEVEL( resultType.GetBasicType() );
    273 
    274         if( classType.HasActualGenericType() )
    275         {
    276             // TODO: GetDummyActualGenericTypeを適切な形に実装し直す
    277             resultType = classType.GetDummyActualGenericType();
    278         }
    279         else
    280         {
    281             // TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
    282             resultType.SetBasicType( DEF_OBJECT );
    283         }
    284 
    285         for( int i=0; i<ptrLevel; i++ )
    286         {
    287             resultType.PtrLevelUp();
    288         }
    289     }
    290 
    291     //
    292     /////////////////////////////////////////////////////////
    293 }
     261    const UserProc *pUserProc = subs[0];
     262
     263    Opcode_CallProc(Parameter,pUserProc,0,ObjectName);
     264    resultType = pUserProc->ReturnType();
     265
     266    // 型パラメータを解決
     267    ResolveFormalGenericTypeParameter( resultType, classType, pUserProc );
     268}

  • trunk/abdev/BasicCompiler32/stdafx.h

    r288 r299  
    1717#include <boost/foreach.hpp>
    1818
     19#include <jenga/include/common/String.h>
     20
    1921#include "../BasicCompiler_Common/common.h"
    2022

  • trunk/abdev/BasicCompiler_Common/Compile.cpp

    r296 r299  
    5656// ジェネリクスのクラス型記述を分析
    5757///////////////////////////////////////////////////
    58 void SplitGenericClassInstance( const char *fullName, char *className, std::vector<std::string> &typeParameters )
     58void SplitGenericClassInstance( const char *fullName, char *className, Jenga::Common::Strings &typeParameters )
    5959{
    6060    int i = 0;

  • trunk/abdev/BasicCompiler_Common/MakeExe.cpp

    r294 r299  
    155155        compiler.staticLibraries.push_back( new ObjectModule() );
    156156        compiler.staticLibraries.back()->Read( coreFilePath );
     157
     158        Jenga::Common::Path path( coreFilePath );
     159        CompileMessage( ((string)"\"" + path.GetFileName() + path.GetExt() + "\" を読み込みました。").c_str() );
    157160    }
    158161

  • trunk/abdev/BasicCompiler_Common/NumOpe_GetType.cpp

    r292 r299  
    389389                resultType = pUserProc->ReturnType();
    390390
    391                 /////////////////////////////////////////////////////////
    392                 // ☆★☆ ジェネリクスサポート ☆★☆
    393 
    394                 if( resultType.IsTypeParameter() )
    395                 {
    396                     // 型パラメータだったとき
    397 
    398                     int ptrLevel = PTR_LEVEL( resultType.GetBasicType() );
    399 
    400                     if( leftType.HasActualGenericType() )
    401                     {
    402                         // TODO: GetDummyActualGenericTypeを適切な形に実装し直す
    403                         resultType = leftType.GetDummyActualGenericType();
    404                     }
    405                     else
    406                     {
    407                         // TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
    408                         resultType.SetBasicType( DEF_OBJECT );
    409                     }
    410 
    411                     for( int i=0; i<ptrLevel; i++ )
    412                     {
    413                         resultType.PtrLevelUp();
    414                     }
    415                 }
    416 
    417                 //
    418                 /////////////////////////////////////////////////////////
     391                // 型パラメータを解決
     392                ResolveFormalGenericTypeParameter( resultType, leftType, pUserProc );
    419393
    420394                return true;

  • trunk/abdev/BasicCompiler_Common/Subroutine.cpp

    r292 r299  
    232232        GetVarType( ObjectName, leftType, false );
    233233
    234         /////////////////////////////////////////////////////////
    235         // ☆★☆ ジェネリクスサポート ☆★☆
    236 
    237         if( resultType.IsTypeParameter() )
    238         {
    239             // 型パラメータだったとき
    240 
    241             int ptrLevel = PTR_LEVEL( resultType.GetBasicType() );
    242 
    243             if( leftType.HasActualGenericType() )
    244             {
    245                 // TODO: GetDummyActualGenericTypeを適切な形に実装し直す
    246                 resultType = leftType.GetDummyActualGenericType();
    247             }
    248             else
    249             {
    250                 // TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
    251                 resultType.SetBasicType( DEF_OBJECT );
    252             }
    253 
    254             for( int i=0; i<ptrLevel; i++ )
    255             {
    256                 resultType.PtrLevelUp();
    257             }
    258         }
    259 
    260         //
    261         /////////////////////////////////////////////////////////
     234        // 型パラメータを解決
     235        ResolveFormalGenericTypeParameter( resultType, leftType, pUserProc );
    262236    }
    263237
    … …  
    314288    }
    315289
    316     resultType = subs[0]->ReturnType();
    317 
    318 
    319     /////////////////////////////////////////////////////////
    320     // ☆★☆ ジェネリクスサポート ☆★☆
    321 
    322     if( resultType.IsTypeParameter() )
    323     {
    324         // 型パラメータだったとき
    325 
    326         int ptrLevel = PTR_LEVEL( resultType.GetBasicType() );
    327 
    328         if( classType.HasActualGenericType() )
    329         {
    330             // TODO: GetDummyActualGenericTypeを適切な形に実装し直す
    331             resultType = classType.GetDummyActualGenericType();
    332         }
    333         else
    334         {
    335             // TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
    336             resultType.SetBasicType( DEF_OBJECT );
    337         }
    338 
    339         for( int i=0; i<ptrLevel; i++ )
    340         {
    341             resultType.PtrLevelUp();
    342         }
    343     }
    344 
    345     //
    346     /////////////////////////////////////////////////////////
     290    const UserProc *pUserProc = subs[0];
     291
     292    resultType = pUserProc->ReturnType();
     293
     294
     295    // 型パラメータを解決
     296    ResolveFormalGenericTypeParameter( resultType, classType, pUserProc );
    347297
    348298    return true;

  • trunk/abdev/BasicCompiler_Common/VariableOpe.cpp

    r292 r299  
    868868        }
    869869
     870        if( (string)temporary == "T" )
     871        {
     872            int test=0;
     873        }
     874
    870875        if( !compiler.StringToType( temporary, type ) ){
    871876            SetError(3,temporary,cp);

  • trunk/abdev/BasicCompiler_Common/common.h

    r296 r299  
    375375void GetIdentifierToken( char *token, const char *source, int &pos );
    376376void GetCommandToken( char *token, const char *source, int &pos );
    377 void SplitGenericClassInstance( const char *fullName, char *className, std::vector<std::string> &typeParameters );
     377void SplitGenericClassInstance( const char *fullName, char *className, Jenga::Common::Strings &typeParameters );
    378378int JumpStatement(const char *source, int &pos);
    379379void DebugVariable(void);

  • trunk/abdev/BasicCompiler_Common/error.cpp

    r290 r299  
    404404    else temporary[0]=0;
    405405
    406     std::string varTypeName = Compiler::TypeToString( varType );
     406    std::string varTypeName = compiler.TypeToString( varType );
    407407    if(memcmp( varTypeName.c_str(),STRING_SYSTEM_DECLAREHANDLE,lstrlen(STRING_SYSTEM_DECLAREHANDLE))==0)
    408408    {
    … …  
    410410    }
    411411
    412     std::string calcTypeName = Compiler::TypeToString( calcType );
     412    std::string calcTypeName = compiler.TypeToString( calcType );
    413413    if(memcmp( calcTypeName.c_str(),STRING_SYSTEM_DECLAREHANDLE,lstrlen(STRING_SYSTEM_DECLAREHANDLE))==0)
    414414    {

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

    r293 r299  
    5656    const CClass *pSuperClass;
    5757
     58    // 継承クラスの型パラメータ（実パラメータ）
     59    Types superClassActualTypeParameters;
     60
    5861    // Blittable型情報
    5962    Type blittableType;
    … …  
    9396        ar & BOOST_SERIALIZATION_NVP( formalGenericTypes );
    9497        ar & boost::serialization::make_nvp( "pSuperClass", const_cast<CClass *&>(pSuperClass) );
     98        ar & BOOST_SERIALIZATION_NVP( superClassActualTypeParameters );
    9599        ar & BOOST_SERIALIZATION_NVP( blittableType );
    96100        //ar & BOOST_SERIALIZATION_NVP( interfaces );
    … …  
    185189        this->formalGenericTypes.push_back( genericType );
    186190    }
     191    int GetFormalGenericTypeParameterIndex( const std::string &name ) const
     192    {
     193        int i = 0;
     194        BOOST_FOREACH( const GenericType &genericType, formalGenericTypes )
     195        {
     196            if( genericType.GetName() == name )
     197            {
     198                return i;
     199            }
     200            i++;
     201        }
     202        return -1;
     203    }
    187204    bool IsExistFormalGenericTypeParameter( const std::string &name ) const
    188205    {
    … …  
    210227        this->pSuperClass = pSuperClass;
    211228    }
     229    const Types &GetSuperClassActualTypeParameters() const
     230    {
     231        return superClassActualTypeParameters;
     232    }
     233    void SetSuperClassActualTypeParameters( const Types &actualTypeParameters )
     234    {
     235        this->superClassActualTypeParameters = actualTypeParameters;
     236    }
    212237
    213238    // Blittable型
    … …  
    270295    //継承させる
    271296    bool Inherits( const char *inheritNames, int nowLine );
    272     bool InheritsClass( const CClass &inheritsClass, int nowLine );
     297    bool InheritsClass( const CClass &inheritsClass, const Types &actualTypeParameters, int nowLine );
    273298    bool InheritsInterface( const CClass &inheritsClass, int nowLine );
    274299

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

    r294 r299  
    123123
    124124
    125     static bool StringToType( const std::string &typeName, Type &type );
    126     static const std::string TypeToString( const Type &type );
     125    bool StringToType( const std::string &typeName, Type &type );
     126    const std::string TypeToString( const Type &type );
    127127
    128128    // コンパイル中のクラス

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

    r266 r299  
    5353    }
    5454
    55     Type GetType() const
     55    const Type &GetType() const
    5656    {
    5757        return type;
     58    }
     59    void ResetType( const Type &type )
     60    {
     61        this->type = type;
    5862    }
    5963

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

    r293 r299  
    2626        const CClass *pClass;
    2727    };
     28
     29    // ジェネリクス クラス インスタンス型の場合に使う
    2830    GenericTypes actualGenericTypes;
     31
     32    // 型パラメータで使う
     33    std::string formalTypeName; // 型パラメータの名前
     34    int formalTypeIndex;        // 型パラメータの引数番号
    2935
    3036    // XMLシリアライズ用
    … …  
    4450        {
    4551            ar & BOOST_SERIALIZATION_NVP( index );
     52        }
     53
     54        if( IsTypeParameter() )
     55        {
     56            ar & BOOST_SERIALIZATION_NVP( formalTypeName );
     57            ar & BOOST_SERIALIZATION_NVP( formalTypeIndex );
    4658        }
    4759    }
    … …  
    7183        , index( type.index )
    7284        , actualGenericTypes( type.actualGenericTypes )
     85        , formalTypeName( type.formalTypeName )
     86        , formalTypeIndex( type.formalTypeIndex )
    7387    {
    7488    }
    … …  
    8195        index = type.index;
    8296        actualGenericTypes = type.actualGenericTypes;
     97        formalTypeName = type.formalTypeName;
     98        formalTypeIndex = type.formalTypeIndex;
    8399    }
    84100
    … …  
    176192    bool HasMember() const;
    177193
     194    // 型パラメータの名前を取得
     195    const std::string &GetFormalTypeName() const
     196    {
     197        if( !IsTypeParameter() )
     198        {
     199            Jenga::Throw( "型パラメータでない型に対してGetFormalTypeNameメソッドが呼ばれた" );
     200        }
     201        return formalTypeName;
     202    }
     203    void SetFormalTypeName( const std::string &formalTypeName )
     204    {
     205        if( !IsTypeParameter() )
     206        {
     207            Jenga::Throw( "型パラメータでない型に対してSetFormalTypeNameメソッドが呼ばれた" );
     208        }
     209        this->formalTypeName = formalTypeName;
     210    }
     211    int GetFormalTypeIndex() const
     212    {
     213        if( !IsTypeParameter() )
     214        {
     215            Jenga::Throw( "型パラメータでない型に対してGetFormalTypeIndexメソッドが呼ばれた" );
     216        }
     217        return formalTypeIndex;
     218    }
     219    void SetFormalTypeIndex( int formalTypeIndex )
     220    {
     221        if( !IsTypeParameter() )
     222        {
     223            Jenga::Throw( "型パラメータでない型に対してSetFormalTypeIndexメソッドが呼ばれた" );
     224        }
     225        this->formalTypeIndex = formalTypeIndex;
     226    }
     227
    178228    // 未完成
    179229    const Type &GetDummyActualGenericType() const;
    … …  
    189239    static int GetBasicTypeFromSimpleName( const char *variable );
    190240};
     241typedef std::vector<Type> Types;
     242
     243void ResolveFormalGenericTypeParameter( Type &typeParameter, const Type &classType, const UserProc *pUserProc = NULL );
    191244
    192245class GenericType

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

    r288 r299  
    1414//boost libraries
    1515#include <boost/foreach.hpp>
     16
     17#include <jenga/include/common/String.h>
    1618
    1719#include "../common.h"

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

    r297 r299  
    188188        }
    189189
     190        // ジェネリクス構文を分解
    190191        char className[VN_SIZE];
    191         std::vector<std::string> typeParameters;
    192         SplitGenericClassInstance( temporary, className, typeParameters );
     192        Jenga::Common::Strings typeParameterStrings;
     193        SplitGenericClassInstance( temporary, className, typeParameterStrings );
     194
     195        // 型パラメータ文字列から型データを取得
     196        std::vector<Type> actualTypeParameters;
     197        BOOST_FOREACH( const std::string &typeParameterStr, typeParameterStrings )
     198        {
     199            Type type;
     200            compiler.StringToType( typeParameterStr, type );
     201            actualTypeParameters.push_back( type );
     202        }
    193203
    194204        //継承元クラスを取得
    … …  
    206216            isInheritsClass = true;
    207217
    208             if( !InheritsClass( *pInheritsClass, nowLine ) ){
     218            if( !InheritsClass( *pInheritsClass, actualTypeParameters, nowLine ) ){
    209219                return false;
    210220            }
    … …  
    223233    if( !isInheritsClass ){
    224234        // クラスを一つも継承していないとき
    225         if( !InheritsClass( *compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr(), nowLine ) ){
     235        if( !InheritsClass( *compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr(), Types(), nowLine ) ){
    226236            return false;
    227237        }
    … …  
    241251
    242252        char className[VN_SIZE];
    243         std::vector<std::string> typeParameters;
     253        Jenga::Common::Strings typeParameters;
    244254        SplitGenericClassInstance( temporary, className, typeParameters );
    245255
    … …  
    273283    return true;
    274284}
    275 bool CClass::InheritsClass( const CClass &inheritsClass, int nowLine ){
     285bool CClass::InheritsClass( const CClass &inheritsClass, const Types &actualTypeParameters, int nowLine ){
    276286
    277287    //ループ継承でないかをチェック
    … …  
    300310        }
    301311
     312        // メンバのみ、型パラメータを解決する（メソッドのほうは呼び出し時に解決する）
     313        if( pMember->GetType().IsTypeParameter() )
     314        {
     315            pMember->ResetType( actualTypeParameters[pMember->GetType().GetFormalTypeIndex()] );
     316        }
     317
    302318        dynamicMembers.push_back( pMember );
    303319    }
    … …  
    332348    //継承先のクラスをメンバとして保持する
    333349    SetSuperClass( &inheritsClass );
     350    SetSuperClassActualTypeParameters( actualTypeParameters );
    334351
    335352    return true;
    … …  
    10751092    namespaceScopes.clear();
    10761093
     1094    // 呼び出し元でコンパイル中のクラスポインタをバックアップ
     1095    const CClass *pBackCompilingClass = compiler.pCompilingClass;
     1096
    10771097    for(i=0;;i++){
    10781098        if(basbuf[i]=='\0') break;
    … …  
    11621182
    11631183                //継承させる
    1164                 if( !pobj_c->InheritsClass( *pInheritsClass, i ) ){
     1184                if( !pobj_c->InheritsClass( *pInheritsClass, Types(), i ) ){
    11651185                    goto Interface_InheritsError;
    11661186                }
    … …  
    12701290
    12711291            char className[VN_SIZE];
    1272             std::vector<std::string> typeParameters;
     1292            Jenga::Common::Strings typeParameters;
    12731293            SplitGenericClassInstance( temporary, className, typeParameters );
    12741294
    … …  
    14761496                            if(!MemberVar_LoopRefCheck(pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().GetClass())){
    14771497                                //エラー回避
    1478                                 pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().SetBasicType( DEF_PTR_VOID );
     1498                                Type &type = const_cast<Type &>(pobj_c->GetDynamicMembers().back()->GetType());
     1499                                type.SetBasicType( DEF_PTR_VOID );
    14791500                            }
    14801501                            pobj_LoopRefCheck->del(pobj_c->GetName().c_str());
    … …  
    15241545    }
    15251546
     1547    // 呼び出し元でコンパイル中のクラスポインタを元に戻す
     1548    compiler.pCompilingClass = pBackCompilingClass;
    15261549
    15271550    // 名前空間を元に戻す

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

    r290 r299  
    3434
    3535        // ジェネリクスクラスを取得
    36         const CClass *pGenericClass = compiler.GetObjectModule().meta.GetClasses().Find( className );
     36        const CClass *pGenericClass = this->GetObjectModule().meta.GetClasses().Find( className );
    3737
    3838        // 型パラメータの型情報を取得
    … …  
    6262                //関数ポインタ（*Function）
    6363                type.SetBasicType( DEF_PTR_PROC );
    64                 type.SetIndex( compiler.GetObjectModule().meta.GetProcPointers().Add( typeName ) );
     64                type.SetIndex( this->GetObjectModule().meta.GetProcPointers().Add( typeName ) );
    6565                return true;
    6666        }
    … …  
    8888    // Object型だったとき
    8989    if( typeName == "Object" ){
    90         type.SetType( DEF_OBJECT, compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr() );
     90        type.SetType( DEF_OBJECT, this->GetObjectModule().meta.GetClasses().GetObjectClassPtr() );
    9191        return true;
    9292    }
    … …  
    9494    // String型だったとき
    9595    if( typeName == "String" ){
    96         type.SetType( DEF_OBJECT, compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr() );
     96        type.SetType( DEF_OBJECT, this->GetObjectModule().meta.GetClasses().GetStringClassPtr() );
    9797        return true;
    9898    }
    … …  
    102102    // TypeDefされた型
    103103    ////////////////////
    104     int i=compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( typeName );
     104    int i=this->GetObjectModule().meta.GetTypeDefs().GetIndex( typeName );
    105105    if(i!=-1){
    106         type = compiler.GetObjectModule().meta.GetTypeDefs()[i].GetBaseType();
     106        type = this->GetObjectModule().meta.GetTypeDefs()[i].GetBaseType();
    107107        return true;
    108108    }
    109109
    110110    //クラス
    111     const CClass *pobj_c = compiler.GetObjectModule().meta.GetClasses().Find( typeName );
     111    const CClass *pobj_c = this->GetObjectModule().meta.GetClasses().Find( typeName );
    112112    if(pobj_c){
    113113        if( pobj_c->IsStructure() ){
    … …  
    126126
    127127    // 型パラメータ
    128     if( compiler.pCompilingClass )
     128    if( this->pCompilingClass )
    129129    {
    130130        // クラスに属するメソッドをコンパイルしているとき
    131         if( compiler.pCompilingClass->IsExistFormalGenericTypeParameter( typeName ) )
     131        int formalTypeIndex = this->pCompilingClass->GetFormalGenericTypeParameterIndex( typeName );
     132        if( formalTypeIndex != -1 )
    132133        {
    133134            // コンパイル中クラスにおけるジェネリクス用の型パラメータのとき
    134135            type.SetBasicType( DEF_TYPE_PARAMETER );
    135             type.SetClassPtr( compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr() );
     136            type.SetClassPtr( this->GetObjectModule().meta.GetClasses().GetObjectClassPtr() );
     137            type.SetFormalTypeName( typeName );
     138            type.SetFormalTypeIndex( formalTypeIndex );
    136139            return true;
    137140        }
    … …  
    169172        }
    170173        else{
    171             if( compiler.GetObjectModule().meta.GetProcPointers()[type.GetIndex()]->ReturnType().IsNull() ){
     174            if( this->GetObjectModule().meta.GetProcPointers()[type.GetIndex()]->ReturnType().IsNull() ){
    172175                return "*Sub";
    173176            }

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

    r292 r299  
    493493
    494494
     495void ResolveFormalGenericTypeParameter( Type &typeParameter, const Type &classType, const UserProc *pUserProc )
     496{
     497    /////////////////////////////////////////////////////////
     498    // ☆★☆ ジェネリクスサポート ☆★☆
     499
     500    if( typeParameter.IsTypeParameter() )
     501    {
     502        // 型パラメータだったとき
     503
     504        // ポインタレベルを抽出
     505        int ptrLevel = PTR_LEVEL( typeParameter.GetBasicType() );
     506
     507        if( pUserProc )
     508        {
     509            // 基底クラスでの自己解決
     510            const CClass *pClass = &classType.GetClass();
     511            while( pClass->HasSuperClass() )
     512            {
     513                if( pUserProc->GetParentClassPtr() == &pClass->GetSuperClass() )
     514                {
     515                    if( pClass->GetSuperClassActualTypeParameters().size() )
     516                    {
     517                        typeParameter = pClass->GetSuperClassActualTypeParameters()[0];
     518                    }
     519                }
     520                pClass = &pClass->GetSuperClass();
     521            }
     522        }
     523
     524        if( typeParameter.IsTypeParameter() )
     525        {
     526            if( classType.HasActualGenericType() )
     527            {
     528                // TODO: GetDummyActualGenericTypeを適切な形に実装し直す
     529                typeParameter = classType.GetDummyActualGenericType();
     530            }
     531            else
     532            {
     533                // TODO: ベースオブジェクト（指定されていないときはObjectクラス）にセットする
     534                typeParameter.SetBasicType( DEF_OBJECT );
     535            }
     536        }
     537
     538        for( int i=0; i<ptrLevel; i++ )
     539        {
     540            typeParameter.PtrLevelUp();
     541        }
     542    }
     543
     544    //
     545    /////////////////////////////////////////////////////////
     546}
     547
     548
    495549const string BlittableType::GetCreateStaticMethodFullName() const
    496550{

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

    r272 r299  
    1313    , baseName( baseName )
    1414{
    15     if( !Compiler::StringToType( baseName, baseType ) ){
     15    if( !compiler.StringToType( baseName, baseType ) ){
    1616        SmoothieException::Throw(3, baseName, nowLine );
    1717        return;
Note: See TracChangeset for help on using the changeset viewer.