Ignore:
Timestamp:
Aug 21, 2007, 11:00:25 PM (17 years ago)
Author:
dai_9181
Message:

ジェネリクスのベースを実装

Location:
trunk/abdev/BasicCompiler_Common/src
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r282 r290  
    908908            source[i+1]==ESC_TYPE||
    909909            source[i+1]==ESC_INTERFACE
    910             )){
    911                 int nowLine;
    912                 nowLine=i;
     910            ))
     911        {
     912            int nowLine = i;
     913            i += 2;
     914
     915            Type blittableType;
     916            if(memicmp(source.GetBuffer()+i,"Align(",6)==0){
     917                //アラインメント修飾子
     918                i+=6;
     919                i=JumpStringInPare(source.GetBuffer(),i)+1;
     920            }
     921            else if( memicmp( source.GetBuffer() + i, "Blittable(", 10 ) == 0 ){
     922                // Blittable修飾子
     923                i+=10;
     924                i+=GetStringInPare_RemovePare(temporary,source.GetBuffer()+i)+1;
     925                compiler.StringToType( temporary, blittableType );
     926            }
     927
     928            bool isEnum = false;
     929            if( source[i] == 1 && source[i+1] == ESC_ENUM ){
     930                // 列挙型の場合
     931                isEnum = true;
    913932
    914933                i+=2;
    915                 Type blittableType;
    916                 if(memicmp(source.GetBuffer()+i,"Align(",6)==0){
    917                     //アラインメント修飾子
    918                     i+=6;
    919                     i=JumpStringInPare(source.GetBuffer(),i)+1;
    920                 }
    921                 else if( memicmp( source.GetBuffer() + i, "Blittable(", 10 ) == 0 ){
    922                     // Blittable修飾子
    923                     i+=10;
    924                     i+=GetStringInPare_RemovePare(temporary,source.GetBuffer()+i)+1;
    925                     compiler.StringToType( temporary, blittableType );
    926                 }
    927 
    928                 bool isEnum = false;
    929                 if( source[i] == 1 && source[i+1] == ESC_ENUM ){
    930                     // 列挙型の場合
    931                     isEnum = true;
    932 
    933                     i+=2;
    934                 }
    935 
    936                 int i2;
    937                 char temporary[VN_SIZE];
    938                 for(i2=0;;i++,i2++){
    939                     if(!IsVariableChar(source[i])){
    940                         temporary[i2]=0;
    941                         break;
    942                     }
    943                     temporary[i2]=source[i];
    944                 }
    945 
    946                 //クラスを追加
    947                 CClass *pClass = this->Add(namespaceScopes, importedNamespaces, temporary,nowLine);
    948                 if( pClass ){
    949                     if( source[nowLine+1] == ESC_CLASS ){
    950                         if( isEnum ){
    951                             pClass->SetClassType( CClass::Enum );
    952                         }
    953                         else{
    954                             pClass->SetClassType( CClass::Class );
    955                         }
    956                     }
    957                     else if( source[nowLine+1] == ESC_INTERFACE ){
    958                         pClass->SetClassType( CClass::Interface );
     934            }
     935
     936            for(i2=0;;i++,i2++){
     937                if(!IsVariableChar(source[i])){
     938                    temporary[i2]=0;
     939                    break;
     940                }
     941                temporary[i2]=source[i];
     942            }
     943
     944            //クラスを追加
     945            CClass *pClass = this->Add(namespaceScopes, importedNamespaces, temporary,nowLine);
     946            if( pClass ){
     947                if( source[nowLine+1] == ESC_CLASS ){
     948                    if( isEnum ){
     949                        pClass->SetClassType( CClass::Enum );
    959950                    }
    960951                    else{
    961                         pClass->SetClassType( CClass::Structure );
     952                        pClass->SetClassType( CClass::Class );
    962953                    }
    963954                }
    964 
    965                 // Blittable型の場合
    966                 if( !blittableType.IsNull() ){
    967                     pClass->SetBlittableType( blittableType );
    968 
    969                     // Blittable型として登録
    970                     compiler.GetObjectModule().meta.GetBlittableTypes().push_back( BlittableType( blittableType, pClass ) );
    971                 }
     955                else if( source[nowLine+1] == ESC_INTERFACE ){
     956                    pClass->SetClassType( CClass::Interface );
     957                }
     958                else{
     959                    pClass->SetClassType( CClass::Structure );
     960                }
     961            }
     962
     963            // Blittable型の場合
     964            if( !blittableType.IsNull() ){
     965                pClass->SetBlittableType( blittableType );
     966
     967                // Blittable型として登録
     968                compiler.GetObjectModule().meta.GetBlittableTypes().push_back( BlittableType( blittableType, pClass ) );
     969            }
    972970        }
    973971    }
    … …  
    12661264            if(!pobj_c) continue;
    12671265
     1266            compiler.pCompilingClass = pobj_c;
     1267
    12681268            if(lpszInheritsClass){
    12691269                if( pobj_c->GetName() != lpszInheritsClass ){
    … …  
    12771277                continue;
    12781278            }
     1279
     1280
     1281            /////////////////////////////////////////////////////////
     1282            // ☆★☆ ジェネリクスサポート ☆★☆
     1283            if( basbuf[i] == '<' )
     1284            {
     1285                // 型パラメータを取得
     1286                i++;
     1287                GetIdentifierToken( temporary, basbuf, i );
     1288
     1289                pobj_c->AddFormalGenericType( GenericType( temporary, Type(DEF_OBJECT,*GetObjectClassPtr()) ) );
     1290
     1291                if( basbuf[i] == '>' )
     1292                {
     1293                    i++;
     1294                }
     1295                else
     1296                {
     1297                    SetError();
     1298                }
     1299            }
     1300            /////////////////////////////////////////////////////////
     1301
    12791302
    12801303            pobj_c->SetFixedAlignment( iAlign );

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

    r273 r290  
    1919bool Compiler::StringToType( const string &typeName, Type &type ){
    2020    type.SetIndex( -1 );
     21
     22
     23    /////////////////////////////////////////////////////////
     24    // ☆★☆ ジェネリクスサポート ☆★☆
     25
     26    if( strstr( typeName.c_str(), "<" ) )
     27    {
     28        // ジェネリッククラスをインスタンス化した型の場合
     29        int i = 0;
     30        char className[VN_SIZE], typeParameter[VN_SIZE];
     31        GetIdentifierToken( className, typeName.c_str(), i );
     32        i++;
     33        GetIdentifierToken( typeParameter, typeName.c_str(), i );
     34
     35        // ジェネリクスクラスを取得
     36        const CClass *pGenericClass = compiler.GetObjectModule().meta.GetClasses().Find( className );
     37
     38        // 型パラメータの型情報を取得
     39        Type baseType;
     40        StringToType( typeParameter, baseType );
     41
     42        GenericTypes genericTypes;
     43        genericTypes.push_back( GenericType( "(non support)", baseType ) );
     44
     45        // 基本型をセット
     46        type.SetBasicType( DEF_OBJECT );
     47
     48        // 拡張情報をセット
     49        type.SetClassPtr( pGenericClass );
     50        type.SetActualGenericTypes( genericTypes );
     51
     52        return true;
     53    }
     54
     55    //
     56    /////////////////////////////////////////////////////////
     57
    2158
    2259    if( typeName[0] == '*' ){
    … …  
    74111    const CClass *pobj_c = compiler.GetObjectModule().meta.GetClasses().Find( typeName );
    75112    if(pobj_c){
    76         type.SetClassPtr( pobj_c );
    77 
    78113        if( pobj_c->IsStructure() ){
    79114            type.SetBasicType( DEF_STRUCT );
    … …  
    82117            type.SetBasicType( DEF_OBJECT );
    83118        }
     119        type.SetClassPtr( pobj_c );
    84120        return true;
    85121    }
     122
     123
     124    /////////////////////////////////////////////////////////
     125    // ☆★☆ ジェネリクスサポート ☆★☆
     126
     127    // 型パラメータ
     128    if( compiler.pCompilingClass )
     129    {
     130        // クラスに属するメソッドをコンパイルしているとき
     131        if( compiler.pCompilingClass->IsExistFormalGenericTypeParameter( typeName ) )
     132        {
     133            // コンパイル中クラスにおけるジェネリクス用の型パラメータのとき
     134            type.SetBasicType( DEF_TYPE_PARAMETER );
     135            type.SetClassPtr( compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr() );
     136            return true;
     137        }
     138    }
     139
     140    //
     141    /////////////////////////////////////////////////////////
    86142
    87143    return false;

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

    r288 r290  
    161161        const CMethod *method = (*pVariabls)[indexSystemGC]->GetType().GetClass().GetDestructorMethod();
    162162        if( method ){
    163             Opcode_CallProc("",&method->GetUserProc(),0,(*pVariabls)[indexSystemGC]->GetName().c_str(),DEF_OBJECT);
     163            Opcode_CallProc("",&method->GetUserProc(),0,(*pVariabls)[indexSystemGC]->GetName().c_str());
    164164        }
    165165    }

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

    r287 r290  
    815815
    816816    // basic.sbpをインクルード
    817     //const char *headCode = "#include <basic.sbp>\n";
    818     const char *headCode = "\n";
     817    const char *headCode = "#include <basic.sbp>\n";
     818    //const char *headCode = "\n";
    819819    Realloc( length + lstrlen(headCode) );
    820820    Text::SlideString( buffer, lstrlen(headCode) );

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

    r206 r290  
    5252};
    5353
     54Type::~Type()
     55{
     56}
     57
    5458bool Type::StringToBasicType( const string &typeName, int &basicType ){
    5559    for( int i=0; ; i++ ){
    … …  
    120124}
    121125
     126const CClass &Type::GetClass() const
     127{
     128    if( !HasMember() )
     129    {
     130        Jenga::Throw( "クラスまたは構造体でない型に対してGetClassを呼び出した" );
     131    }
     132
     133    return *pClass;
     134}
    122135
    123136bool Type::Equals( const Type &type ) const
    … …  
    185198
    186199    // 構造体
    187     if( basicType == DEF_STRUCT ){
     200    if( IsStruct() )
     201    {
    188202        if( !pClass ){
    189203            SmoothieException::Throw();
    … …  
    195209
    196210    // オブジェクト
    197     if(basicType==DEF_OBJECT){
     211    if( IsObject() )
     212    {
    198213        if( GetClass().IsInterface() ){
    199214            // vtblOffsetのサイズを含める
    … …  
    379394bool Type::IsObject() const
    380395{
    381     if( basicType == DEF_OBJECT ){
    382         return true;
    383     }
    384     return false;
     396    return (
     397        basicType == DEF_OBJECT
     398        || IsTypeParameter()
     399    );
    385400}
    386401bool Type::IsObjectPtr() const
    … …  
    390405    }
    391406    return false;
     407}
     408bool Type::IsTypeParameter() const
     409{
     410    return ( basicType == DEF_TYPE_PARAMETER );
    392411}
    393412bool Type::IsObjectClass() const
    … …  
    428447{
    429448    if( NATURAL_TYPE( basicType ) == DEF_OBJECT
    430         || NATURAL_TYPE( basicType ) == DEF_STRUCT ){
    431             return true;
    432     }
    433     return false;
     449        || NATURAL_TYPE( basicType ) == DEF_STRUCT
     450        || NATURAL_TYPE( basicType ) == DEF_TYPE_PARAMETER
     451    ){
     452        return true;
     453    }
     454    return false;
     455}
     456
     457const Type &Type::GetDummyActualGenericType() const
     458{
     459    return actualGenericTypes[0].GetType();
     460}
     461bool Type::HasActualGenericType() const
     462{
     463    return ( actualGenericTypes.size() > 0 );
    434464}
    435465
Note: See TracChangeset for help on using the changeset viewer.