Changeset 135 in dev


Ignore:
Timestamp:
Jun 6, 2007, 12:58:40 AM (17 years ago)
Author:
dai_9181
Message:

Method/Memberのリファクタリング

Files:
32 edited

Legend:

Unmodified
Added
Removed

  • BasicCompiler32/BasicCompiler.vcproj

    r134 r135  
    18221822                    Name="Meta Parts"
    18231823                    >
     1824                    <File
     1825                        RelativePath="..\BasicCompiler_Common\src\Member.cpp"
     1826                        >
     1827                    </File>
     1828                    <File
     1829                        RelativePath="..\BasicCompiler_Common\src\Method.cpp"
     1830                        >
     1831                    </File>
    18241832                    <File
    18251833                        RelativePath="..\BasicCompiler_Common\src\Namespace.cpp"
    … …  
    19561964                    </File>
    19571965                    <File
    1958                         RelativePath="..\BasicCompiler_Common\include\Prototype.h"
    1959                         >
    1960                     </File>
    1961                     <File
    19621966                        RelativePath="..\BasicCompiler_Common\Type.h"
    19631967                        >
    … …  
    19711975                        >
    19721976                    </File>
     1977                    <Filter
     1978                        Name="Prototype"
     1979                        >
     1980                        <File
     1981                            RelativePath="..\BasicCompiler_Common\include\Member.h"
     1982                            >
     1983                        </File>
     1984                        <File
     1985                            RelativePath="..\BasicCompiler_Common\include\Method.h"
     1986                            >
     1987                        </File>
     1988                        <File
     1989                            RelativePath="..\BasicCompiler_Common\include\Prototype.h"
     1990                            >
     1991                        </File>
     1992                    </Filter>
    19731993                </Filter>
    19741994                <Filter

  • BasicCompiler32/Compile_Calc.cpp

    r129 r135  
    622622        // Blittable型をオブジェクトとして扱う
    623623        vector<UserProc *> userProcs;
    624         Smoothie::Meta::blittableTypes.GetClass( calcType ).EnumStaticMethod( "_Create", userProcs );
     624        Smoothie::Meta::blittableTypes.GetClass( calcType ).GetStaticMethods().EnumStatic( "_Create", userProcs );
    625625        if( userProcs.size() != 1 ){
    626626            SetError();

  • BasicCompiler32/Compile_CallProc.cpp

    r113 r135  
    113113    bool isStatic = false;
    114114    const CClass *pobj_c = NULL;
    115     CMethod *pMethod = NULL;
     115    const CMethod *pMethod = NULL;
    116116    if( pUserProc->GetParentClassPtr() ){
    117117        //クラスのメンバ関数を呼び出す場合はアクセスチェックを行う
    … …  
    153153        /////////////////////////////////
    154154        pMethod = NULL;
    155         if( ! isStatic ) pMethod = pobj_c->GetMethodInfo( pUserProc );
     155        if( ! isStatic ) pMethod = pobj_c->GetMethods().GetMethodPtr( pUserProc );
    156156        if( ! pMethod ){
    157157            //動的メソッドが取得できなかったときは静的メソッドを当たる
    158             pMethod = pobj_c->GetStaticMethodInfo( pUserProc );
     158            pMethod = pobj_c->GetStaticMethods().GetMethodPtr( pUserProc );
    159159            if( !pMethod ){
    160160                SetError(300,NULL,cp);
    … …  
    276276            else{
    277277                RELATIVE_VAR RelativeVar;
    278                 if( pMethod->isConst ){
     278                if( pMethod->IsConst() ){
    279279                    //Constアクセスが可能なメソッドの場合
    280280                    if( !GetVarOffsetReadOnly( ObjectName, &RelativeVar, Type() ) ){

  • BasicCompiler32/Compile_Object.cpp

    r131 r135  
    3636
    3737    std::vector<UserProc *> subs;
    38     pobj_c->EnumMethod( pobj_c->GetName().c_str(), subs );
     38    pobj_c->GetMethods().Enum( pobj_c->GetName().c_str(), subs );
    3939
    4040    UserProc *pUserProc;
    … …  
    5656        // obj._System_SetType( _System_TypeBase.Search( strNamespace, name ) )
    5757        subs.clear();
    58         pobj_c->EnumMethod( "_System_SetType", subs );
     58        pobj_c->GetMethods().Enum( "_System_SetType", subs );
    5959        if( subs.size() == 1 ){
    6060            char temporary[VN_SIZE];
    … …  
    208208
    209209
    210     CMethod *method = classObj.GetDestructorMethod();
     210    const CMethod *method = classObj.GetDestructorMethod();
    211211    if( method == NULL ) return;
    212212

  • BasicCompiler32/Compile_ProcOp.cpp

    r131 r135  
    599599                    基底クラスのデストラクタを呼び出す */
    600600
    601                 CMethod *method = pobj_CompilingClass->pobj_InheritsClass->GetDestructorMethod();
     601                const CMethod *method = pobj_CompilingClass->pobj_InheritsClass->GetDestructorMethod();
    602602                if( method ){
    603603                    Opcode_CallProc("",

  • BasicCompiler32/Compile_Statement.cpp

    r129 r135  
    10751075                if(type1.IsObject()){
    10761076                    std::vector<UserProc *> subs;
    1077                     type1.GetClass().EnumMethod( CALC_EQUAL, subs );
     1077                    type1.GetClass().GetMethods().Enum( CALC_EQUAL, subs );
    10781078                    if( subs.size() == 0 ){
    10791079                        return;

  • BasicCompiler32/Compile_Var.cpp

    r131 r135  
    445445
    446446            for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
    447                 if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
     447                if( pobj_CompilingClass->ppobj_Member[i]->GetName() == VarName ){
     448                    break;
     449                }
    448450            }
    449451            if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
    … …  
    452454        //Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
    453455        //（コンストラクタ、デストラクタ内を除く）
    454         CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
     456        const CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
    455457        if( isWriteAccess &&
    456             pMethod->isConst &&
     458            pMethod->IsConst() &&
    457459            pobj_CompilingClass->IsCompilingConstructor() == false &&
    458460            pobj_CompilingClass->IsCompilingDestructor() == false
    … …  
    750752                i=GetOneParameter(InitBuf,i,temporary);
    751753
    752                 i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->name, NULL );
     754                i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->GetName().c_str(), NULL );
    753755
    754756                if(!SetInitGlobalData(offset+i3,
    … …  
    886888                i=GetOneParameter(InitBuf,i,temporary);
    887889
    888                 i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->name, NULL );
     890                i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->GetName().c_str(), NULL );
    889891
    890892                if(!InitLocalVar(offset+i3,

  • BasicCompiler32/NumOpe.cpp

    r128 r135  
    181181    GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
    182182
    183     objClass.EnumMethod( methodName, userProcs );
     183    objClass.GetMethods().Enum( methodName, userProcs );
    184184    UserProc *pUserProc;
    185185    if(userProcs.size()){

  • BasicCompiler32/OperatorProc.cpp

    r76 r135  
    55    if(!IsSafeReg(reg)) SetError(300,NULL,cp);
    66
    7     CMethod *method = pobj_c->GetDestructorMethod();
     7    const CMethod *method = pobj_c->GetDestructorMethod();
    88    if( method ){
    99        //push reg
    … …  
    2828
    2929    std::vector<UserProc *> subs;
    30     pobj_c->EnumMethod( idCalc, subs );
     30    pobj_c->GetMethods().Enum( idCalc, subs );
    3131    if( subs.size() == 0 ){
    3232        return 0;
    … …  
    250250void CallIndexerGetterProc(const CClass *pobj_Class,char *ObjectName,char *Parameter,Type &resultType){
    251251    std::vector<UserProc *> subs;
    252     pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
     252    pobj_Class->GetMethods().Enum( CALC_ARRAY_GET, subs );
    253253    if( subs.size() == 0 ){
    254254        return;

  • BasicCompiler64/BasicCompiler.vcproj

    r131 r135  
    480480                    >
    481481                    <File
     482                        RelativePath="..\BasicCompiler_Common\include\Member.h"
     483                        >
     484                    </File>
     485                    <File
     486                        RelativePath="..\BasicCompiler_Common\include\Method.h"
     487                        >
     488                    </File>
     489                    <File
    482490                        RelativePath="..\BasicCompiler_Common\include\Namespace.h"
    483491                        >
    … …  
    15601568                    >
    15611569                    <File
     1570                        RelativePath="..\BasicCompiler_Common\src\Member.cpp"
     1571                        >
     1572                    </File>
     1573                    <File
     1574                        RelativePath="..\BasicCompiler_Common\src\Method.cpp"
     1575                        >
     1576                    </File>
     1577                    <File
    15621578                        RelativePath="..\BasicCompiler_Common\src\Namespace.cpp"
    15631579                        >
    … …  
    15651581                    <File
    15661582                        RelativePath="..\BasicCompiler_Common\Procedure.cpp"
     1583                        >
     1584                    </File>
     1585                    <File
     1586                        RelativePath="..\BasicCompiler_Common\src\Prototype.cpp"
    15671587                        >
    15681588                    </File>

  • BasicCompiler64/Compile_Calc.cpp

    r129 r135  
    230230        // Blittable型をオブジェクトとして扱う
    231231        vector<UserProc *> userProcs;
    232         Smoothie::Meta::blittableTypes.GetClass( calcType ).EnumStaticMethod( "_Create", userProcs );
     232        Smoothie::Meta::blittableTypes.GetClass( calcType ).GetStaticMethods().EnumStatic( "_Create", userProcs );
    233233        if( userProcs.size() != 1 ){
    234234            SetError();

  • BasicCompiler64/Compile_CallProc.cpp

    r102 r135  
    118118    bool isStatic = false;
    119119    const CClass *pobj_c = NULL;
    120     CMethod *pMethod = NULL;
     120    const CMethod *pMethod = NULL;
    121121    if( pUserProc->GetParentClassPtr() ){
    122122        //クラスのメンバ関数を呼び出す場合はアクセスチェックを行う
    … …  
    158158        /////////////////////////////////
    159159        pMethod = NULL;
    160         if( ! isStatic ) pMethod = pobj_c->GetMethodInfo( pUserProc );
     160        if( ! isStatic ) pMethod = pobj_c->GetMethods().GetMethodPtr( pUserProc );
    161161        if( ! pMethod ){
    162162            //動的メソッドが取得できなかったときは静的メソッドを当たる
    163             pMethod = pobj_c->GetStaticMethodInfo( pUserProc );
     163            pMethod = pobj_c->GetStaticMethods().GetMethodPtr( pUserProc );
    164164            if( !pMethod ){
    165165                SetError(300,NULL,cp);
    … …  
    308308            else{
    309309                RELATIVE_VAR RelativeVar;
    310                 if( pMethod->isConst ){
     310                if( pMethod->IsConst() ){
    311311                    //Constアクセスが可能なメソッドの場合
    312312                    if( !GetVarOffsetReadOnly( ObjectName, &RelativeVar, Type() ) ){

  • BasicCompiler64/Compile_Object.cpp

    r131 r135  
    3434
    3535    std::vector<UserProc *> subs;
    36     pobj_c->EnumMethod( pobj_c->GetName().c_str(), subs );
     36    pobj_c->GetMethods().Enum( pobj_c->GetName().c_str(), subs );
    3737
    3838    UserProc *pUserProc;
    … …  
    5454        // obj._System_SetType( _System_TypeBase.Search( strNamespace, name ) )
    5555        subs.clear();
    56         pobj_c->EnumMethod( "_System_SetType", subs );
     56        pobj_c->GetMethods().Enum( "_System_SetType", subs );
    5757        if( subs.size() == 1 ){
    5858            char temporary[VN_SIZE];
    … …  
    179179
    180180
    181     CMethod *method = classObj.GetDestructorMethod();
     181    const CMethod *method = classObj.GetDestructorMethod();
    182182    if( method == NULL ) return;
    183183

  • BasicCompiler64/Compile_ProcOp.cpp

    r131 r135  
    650650                    基底クラスのデストラクタを呼び出す */
    651651
    652                 CMethod *method = pobj_CompilingClass->pobj_InheritsClass->GetDestructorMethod();
     652                const CMethod *method = pobj_CompilingClass->pobj_InheritsClass->GetDestructorMethod();
    653653                if( method ){
    654654                    Opcode_CallProc("",

  • BasicCompiler64/Compile_Statement.cpp

    r129 r135  
    733733                if(type1.IsObject()){
    734734                    std::vector<UserProc *> subs;
    735                     type1.GetClass().EnumMethod( CALC_EQUAL, subs );
     735                    type1.GetClass().GetMethods().Enum( CALC_EQUAL, subs );
    736736                    if( subs.size() == 0 ){
    737737                        return;

  • BasicCompiler64/Compile_Var.cpp

    r131 r135  
    472472
    473473            for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
    474                 if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
     474                if( pobj_CompilingClass->ppobj_Member[i]->GetName() == VarName ){
     475                    break;
     476                }
    475477            }
    476478            if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
    … …  
    479481        //Const修飾子のメソッド内でメンバ書き込みアクセスが発生したとき
    480482        //（コンストラクタ、デストラクタ内を除く）
    481         CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
     483        const CMethod *pMethod = pobj_DBClass->GetNowCompilingMethodInfo();
    482484        if( isWriteAccess &&
    483             pMethod->isConst &&
     485            pMethod->IsConst() &&
    484486            pobj_CompilingClass->IsCompilingConstructor() == false &&
    485487            pobj_CompilingClass->IsCompilingDestructor() == false
    … …  
    772774                i=GetOneParameter(InitBuf,i,temporary);
    773775
    774                 i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->name, NULL );
     776                i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->GetName().c_str(), NULL );
    775777
    776778                if(!SetInitGlobalData(offset+i3,
    … …  
    908910                i=GetOneParameter(InitBuf,i,temporary);
    909911
    910                 i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->name, NULL );
     912                i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->GetName().c_str(), NULL );
    911913
    912914                if(!InitLocalVar(offset+i3,

  • BasicCompiler64/NumOpe.cpp

    r131 r135  
    166166    GetVarFormatString(methodName,parameter,lpPtrOffset,dummy,refType);
    167167
    168     objClass.EnumMethod( methodName, userProcs );
     168    objClass.GetMethods().Enum( methodName, userProcs );
    169169    UserProc *pUserProc;
    170170    if(userProcs.size()){

  • BasicCompiler64/OperatorProc.cpp

    r76 r135  
    1010    ////////////////////////////////////////////////
    1111
    12     CMethod *method = pobj_c->GetDestructorMethod();
     12    const CMethod *method = pobj_c->GetDestructorMethod();
    1313    if( method ){
    1414        //mov rcx,reg
    … …  
    3333
    3434    std::vector<UserProc *> subs;
    35     pobj_c->EnumMethod( idCalc, subs );
     35    pobj_c->GetMethods().Enum( idCalc, subs );
    3636    if( subs.size() == 0 ){
    3737        return 0;
    … …  
    320320
    321321    std::vector<UserProc *> subs;
    322     pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
     322    pobj_Class->GetMethods().Enum( CALC_ARRAY_GET, subs );
    323323    if( subs.size() == 0 ){
    324324        return;

  • BasicCompiler_Common/Class.cpp

    r134 r135  
    1212
    1313CMember *pCompilingMethod;
    14 
    15 
    16 
    17 CMember::CMember( CClass *pobj_c, DWORD access, bool isConst, bool isRef, char *buffer, int nowLine ){
    18     extern int cp;
    19 
    20                         if( strstr(buffer,"environVarName")){
    21                             int test=0;
    22                         }
    23 
    24     //構文を解析
    25     char VarName[VN_SIZE];
    26     char init_buf[VN_SIZE];
    27     char constract_parameter[VN_SIZE];
    28     GetDimentionFormat(buffer,VarName,SubScripts,*this,init_buf,constract_parameter);
    29 
    30     //重複チェック
    31     if(pobj_c->DupliCheckAll(VarName)){
    32         SetError(15,VarName,cp);
    33     }
    34 
    35     //メンバ名
    36     name=(char *)HeapAlloc(hHeap,0,lstrlen(VarName)+1);
    37     lstrcpy(name,VarName);
    38 
    39     //アクセス権
    40     dwAccess=access;
    41 
    42     //定数扱いかどうか
    43     this->isConst = isConst;
    44 
    45     //初期データ
    46     InitBuf=(char *)HeapAlloc(hHeap,0,lstrlen(init_buf)+1);
    47     lstrcpy(InitBuf,init_buf);
    48 
    49     //コンストラクタ用のパラメータ
    50     ConstractParameter=(char *)HeapAlloc(hHeap,0,lstrlen(constract_parameter)+1);
    51     lstrcpy(ConstractParameter,constract_parameter);
    52 
    53     //ソースコードの位置
    54     source_code_address=nowLine;
    55 }
    56 CMember::CMember(CMember &member):
    57     Type( member )
    58 {
    59 
    60     //name
    61     name=(char *)HeapAlloc(hHeap,0,lstrlen(member.name)+1);
    62     lstrcpy(name,member.name);
    63 
    64     //定数扱いかどうか
    65     isConst = member.isConst;
    66 
    67     //SubScripts
    68     memcpy(SubScripts,member.SubScripts,MAX_ARRAYDIM*sizeof(int));
    69 
    70     //ソースコードの位置
    71     source_code_address=member.source_code_address;
    72 }
    73 CMember::CMember(){
    74     memset(this,0,sizeof(CMember));
    75 }
    76 CMember::~CMember(){
    77     HeapDefaultFree(name);
    78     if(InitBuf) HeapDefaultFree(InitBuf);
    79     if(ConstractParameter) HeapDefaultFree(ConstractParameter);
    80 }
    81 
    82 bool CMember::IsConst(){
    83     return isConst;
    84 }
    85 
    86 void CMember::InitStaticMember(void){
    87     //静的メンバをグローバル領域に作成
    88 
    89     //イテレータをリセット
    90     extern CDBClass *pobj_DBClass;
    91     pobj_DBClass->Iterator_Reset();
    92 
    93     int back_cp=cp;
    94 
    95     while(pobj_DBClass->Iterator_HasNext()){
    96         CClass &objClass = *pobj_DBClass->Iterator_GetNext();
    97 
    98         // 名前空間をセット
    99         Smoothie::Lexical::liveingNamespaceScopes = objClass.GetNamespaceScopes();
    100 
    101         int i=0;
    102         foreach( CMember *member, objClass.staticMembers ){
    103             char temporary[VN_SIZE];
    104             sprintf(temporary,"%s.%s",objClass.GetName().c_str(),member->name);
    105             dim(
    106                 temporary,
    107                 member->SubScripts,
    108                 *member,
    109                 member->InitBuf,
    110                 member->ConstractParameter,
    111                 0);
    112 
    113             //ネイティブコードバッファの再確保
    114             ReallocNativeCodeBuffer();
    115 
    116             i++;
    117         }
    118     }
    119 
    120     Smoothie::Lexical::liveingNamespaceScopes.clear();
    121 
    122     cp=back_cp;
    123 }
    124 
    125 
    126 
    127 //コピーコンストラクタ
    128 CMethod::CMethod(CMethod *pMethod)
    129     : pUserProc( pMethod->pUserProc )
    130     , dwAccess( pMethod->dwAccess )
    131     , bAbstract( pMethod->bAbstract )
    132     , bVirtual( pMethod->bVirtual )
    133     , isConst( pMethod->isConst )
    134     , isStatic( pMethod->isStatic )
    135 {
    136 }
    137 
    138 CMethod::CMethod( UserProc *pUserProc, DWORD dwAccess, BOOL bAbstract, BOOL bVirtual, bool isConst, bool isStatic )
    139     : pUserProc( pUserProc )
    140     , dwAccess( dwAccess )
    141     , bAbstract( bAbstract )
    142     , bVirtual( bVirtual )
    143     , isConst( isConst )
    144     , isStatic( isStatic )
    145     , pobj_InheritsClass( NULL )
    146 {
    147 }
    148 CMethod::~CMethod(){
    149 }
    150 
    15114
    15215
    … …  
    18447        delete member;
    18548    }
    186 
    187     //メソッド
    188     foreach( CMethod *method, methods ){
    189         delete method;
    190     }
    191 
    192     //静的メソッド
    193     foreach( CMethod *method, staticMethods ){
    194         delete method;
    195     }
    19649}
    19750
    … …  
    321174
    322175    //メソッドをコピー
    323     foreach( CMethod *baseMethod, inheritsClass.methods ){
    324         CMethod *method = new CMethod( baseMethod );
     176    foreach( const CMethod *pBaseMethod, inheritsClass.methods ){
     177        CMethod *pMethod = new DynamicMethod( *pBaseMethod );
    325178
    326179        //dwAccess
    327         if(baseMethod->dwAccess==ACCESS_PRIVATE)
    328             method->dwAccess=ACCESS_NON;
    329         else method->dwAccess=baseMethod->dwAccess;
     180        if(pBaseMethod->dwAccess==ACCESS_PRIVATE)
     181            pMethod->dwAccess=ACCESS_NON;
     182        else pMethod->dwAccess=pBaseMethod->dwAccess;
    330183
    331184        //pobj_Inherits
    332185        // ※継承元のClassIndexをセット（入れ子継承を考慮する）
    333         if(baseMethod->pobj_InheritsClass==0)
    334             method->pobj_InheritsClass=&inheritsClass;
    335         else
    336             method->pobj_InheritsClass=
    337                 baseMethod->pobj_InheritsClass;
    338 
    339         methods.push_back( method );
     186        if(pBaseMethod->GetInheritsClassPtr()==0){
     187            pMethod->SetInheritsClassPtr( &inheritsClass );
     188        }
     189        else{
     190            pMethod->SetInheritsClassPtr( pBaseMethod->GetInheritsClassPtr() );
     191        }
     192
     193        methods.push_back( pMethod );
    340194    }
    341195
    … …  
    364218
    365219    //メソッドをコピー
    366     foreach( CMethod *baseMethod, inheritsInterface.methods ){
    367         CMethod *method = new CMethod( baseMethod );
     220    foreach( const CMethod *pBaseMethod, inheritsInterface.methods ){
     221        CMethod *pMethod = new DynamicMethod( *pBaseMethod );
    368222
    369223        //dwAccess
    370         if(baseMethod->dwAccess==ACCESS_PRIVATE)
    371             method->dwAccess=ACCESS_NON;
    372         else method->dwAccess=baseMethod->dwAccess;
     224        if(pBaseMethod->dwAccess==ACCESS_PRIVATE)
     225            pMethod->dwAccess=ACCESS_NON;
     226        else pMethod->dwAccess=pBaseMethod->dwAccess;
    373227
    374228        //pobj_Inherits
    375229        // ※継承元のClassIndexをセット（入れ子継承を考慮する）
    376         if(baseMethod->pobj_InheritsClass==0)
    377             method->pobj_InheritsClass=&inheritsInterface;
    378         else
    379             method->pobj_InheritsClass=
    380                 baseMethod->pobj_InheritsClass;
    381 
    382         methods.push_back( method );
     230        if(pBaseMethod->GetInheritsClassPtr()==0){
     231            pMethod->SetInheritsClassPtr( &inheritsInterface );
     232        }
     233        else{
     234            pMethod->SetInheritsClassPtr( pBaseMethod->GetInheritsClassPtr() );
     235        }
     236
     237        methods.push_back( pMethod );
    383238    }
    384239
    … …  
    399254    staticMembers.push_back( member );
    400255}
    401 void CClass::AddMethod( UserProc *pUserProc,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual ){
    402     CMethod *method = new CMethod( pUserProc, dwAccess, bAbstract, bVirtual, isConst, false );
    403 
    404     methods.push_back( method );
    405 
    406     // プロシージャオブジェクトと関連付け
    407     pUserProc->SetMethod( method );
    408 }
    409 void CClass::AddStaticMethod(UserProc *pUserProc,DWORD dwAccess){
    410     CMethod *method = new CMethod( pUserProc, dwAccess, FALSE, FALSE, false, true );
    411 
    412     staticMethods.push_back( method );
    413 
    414     // プロシージャオブジェクトと関連付け
    415     pUserProc->SetMethod( method );
    416 }
    417256BOOL CClass::DupliCheckAll(const char *name){
    418257    //重複チェック
    … …  
    422261
    423262    //メソッド
    424     foreach( CMethod *method, methods ){
    425         if( lstrcmp( name, method->pUserProc->GetName().c_str() ) == 0 ){
     263    foreach( const CMethod *pMethod, methods ){
     264        if( lstrcmp( name, pMethod->pUserProc->GetName().c_str() ) == 0 ){
    426265            return 1;
    427266        }
    … …  
    435274    //メンバ
    436275    for( int i=0;i<iMemberNum;i++){
    437         if( GetName() == ppobj_Member[i]->name ){
     276        if( GetName() == ppobj_Member[i]->GetName() ){
    438277            return 1;
    439278        }
    … …  
    442281    //静的メンバ
    443282    foreach( CMember *member, staticMembers ){
    444         if( GetName() == member->name ){
     283        if( GetName() == member->GetName() ){
    445284            return 1;
    446285        }
    … …  
    449288    return 0;
    450289}
    451 CMethod *CClass::GetMethodInfo( UserProc *pUserProc ) const
    452 {
    453     for( int i=(int)methods.size()-1; i>=0; i-- ){
    454         if( pUserProc == methods[i]->pUserProc ){
    455             return methods[i];
    456         }
    457     }
    458     return NULL;
    459 }
    460 CMethod *CClass::GetStaticMethodInfo( UserProc *pUserProc ) const
    461 {
    462     for( int i=(int)staticMethods.size()-1; i>=0; i-- ){
    463         if( pUserProc == staticMethods[i]->pUserProc ) return staticMethods[i];
    464     }
    465     return NULL;
    466 }
    467 bool CClass::IsExistMethod( const char *name ) const
    468 {
    469     foreach( CMethod *method, methods ){
    470         if( method->pUserProc->GetName() == name ) return true;
    471     }
    472     return false;
    473 }
    474 bool CClass::IsExistStaticMethod( const char *name ) const
    475 {
    476     foreach( CMethod *method, staticMethods ){
    477         if( method->pUserProc->GetName() == name ) return true;
    478     }
    479     return false;
    480 }
    481 
    482 void CClass::EnumStaticMethod( const char *methodName, vector<UserProc *> &subs ) const
    483 {
    484     foreach( CMethod *method, staticMethods ){
    485         if( method->pUserProc->GetName() == methodName ){
    486             subs.push_back( method->pUserProc );
    487         }
    488     }
    489 }
    490 
    491 void CClass::EnumMethod( const char *methodName, vector<UserProc *> &subs ) const
    492 {
    493     //オブジェクトのメンバ関数の場合
    494     //※オーバーライドされた関数を先にサーチする必要があるため、バックサーチを行う
    495     for( int i=(int)methods.size()-1; i>=0; i-- ){
    496         if( methods[i]->pUserProc->GetName() == methodName ){
    497             subs.push_back( methods[i]->pUserProc );
    498         }
    499     }
    500 }
    501 
    502 void CClass::EnumMethod( const BYTE idOperatorCalc, vector<UserProc *> &subs ) const
    503 {
    504     //オブジェクトのメンバ関数の場合
    505     //※オーバーライドされた関数を先にサーチする必要があるため、バックサーチを行う
    506     for( int i=(int)methods.size()-1; i>=0; i-- ){
    507         UserProc *pUserProc = methods[i]->pUserProc;
    508         const char *temp = pUserProc->GetName().c_str();
    509         if(temp[0]==1&&temp[1]==ESC_OPERATOR){
    510             if((BYTE)temp[2]==idOperatorCalc){
    511                 subs.push_back( pUserProc );
    512             }
    513         }
    514     }
    515 }
    516290
    517291//デフォルト コンストラクタ メソッドを取得
    518 CMethod *CClass::GetConstructorMethod() const
     292const CMethod *CClass::GetConstructorMethod() const
    519293{
    520294    if( ConstructorMemberSubIndex == -1 ) return NULL;
    … …  
    523297
    524298//デストラクタ メソッドを取得
    525 CMethod *CClass::GetDestructorMethod() const
     299const CMethod *CClass::GetDestructorMethod() const
    526300{
    527301    if( DestructorMemberSubIndex == -1 ) return NULL;
    … …  
    584358        if(memberName){
    585359            //メンバ指定がある場合は、オフセットを返す
    586             if(lstrcmp(pMember->name,memberName)==0){
     360            if( pMember->GetName() == memberName ){
    587361                if(pMemberNum) *pMemberNum=i;
    588362                return offset;
    … …  
    644418{
    645419    int n = 0;
    646     foreach( CMethod *method, methods ){
    647         if( method->pUserProc == pUserProc ) break;
    648         if( method->bVirtual ) n++;
     420    foreach( const CMethod *pMethod, methods ){
     421        if( pMethod->pUserProc == pUserProc ) break;
     422        if( pMethod->IsVirtual() ) n++;
    649423    }
    650424    return n;
    … …  
    667441    //関数テーブルに値をセット
    668442    int i2 = 0;
    669     foreach( CMethod *method, methods ){
    670         if(method->bVirtual){
    671             method->pUserProc->Using();
    672 
    673             if(method->bAbstract){
     443    foreach( const CMethod *pMethod, methods ){
     444        if(pMethod->IsVirtual()){
     445            pMethod->pUserProc->Using();
     446
     447            if(pMethod->IsAbstract()){
    674448                extern int cp;
    675449                SetError(300,NULL,cp);
    … …  
    678452            }
    679453            else{
    680                 ppsi[i2]=method->pUserProc;
     454                ppsi[i2]=pMethod->pUserProc;
    681455            }
    682456            i2++;
    … …  
    712486    // 未実装(abstract)の仮想関数を持つ場合はtrueを返す
    713487
    714     foreach( CMethod *method, methods ){
    715         if(method->bVirtual){
    716             if(method->bAbstract){
     488    foreach( const CMethod *pMethod, methods ){
     489        if(pMethod->IsVirtual()){
     490            if(pMethod->IsAbstract()){
    717491                return true;
    718492            }
    … …  
    1063837
    1064838
    1065 void CDBClass::AddMethod(CClass *pobj_c, DWORD dwAccess, BOOL bStatic, bool isConst, BOOL bAbstract,
    1066                          BOOL bVirtual, BOOL bOverride, char *buffer, int nowLine){
     839void CDBClass::AddMethod(CClass *pobj_c, DWORD dwAccess, BOOL bStatic, bool isConst, bool isAbstract,
     840                         bool isVirtual, bool isOverride, char *buffer, int nowLine){
    1067841    int i,i2;
    1068842    char temporary[VN_SIZE];
    … …  
    1080854    //関数ハッシュへ登録
    1081855    GlobalProc *pUserProc;
    1082     pUserProc=AddSubData( NamespaceScopes(), NamespaceScopesCollection(), buffer,nowLine,bVirtual,pobj_c, (bStatic!=0) );
     856    pUserProc=AddSubData( NamespaceScopes(), NamespaceScopesCollection(), buffer,nowLine,isVirtual,pobj_c, (bStatic!=0) );
    1083857    if(!pUserProc) return;
    1084858
    … …  
    1129903
    1130904    //メソッド
    1131     foreach( CMethod *method, pobj_c->methods ){
     905    foreach( const CMethod *pMethod, pobj_c->methods ){
    1132906        //基底クラスと重複する場合はオーバーライドを行う
    1133         if(method->pobj_InheritsClass) continue;
    1134 
    1135         if( method->pUserProc->GetName() == temporary ){
    1136             if( method->pUserProc->Params().Equals( pUserProc->Params() ) ){
     907        if( pMethod->GetInheritsClassPtr() ) continue;
     908
     909        if( pMethod->pUserProc->GetName() == temporary ){
     910            if( pMethod->pUserProc->Params().Equals( pUserProc->Params() ) ){
    1137911                //関数名、パラメータ属性が合致したとき
    1138912                SetError(15,pUserProc->GetName().c_str(),nowLine);
    … …  
    1143917
    1144918    //仮想関数の場合
    1145     if(bAbstract) pUserProc->CompleteCompile();
     919    if( isAbstract ) pUserProc->CompleteCompile();
    1146920
    1147921    //メソッドのオーバーライド
    1148     foreach( CMethod *method, pobj_c->methods ){
    1149         if( method->pUserProc->GetName() == temporary ){
    1150             if( method->pUserProc->Params().Equals( pUserProc->Params() ) ){
    1151 
    1152                 if(method->bVirtual){
     922    foreach( CMethod *pMethod, pobj_c->methods ){
     923        if( pMethod->pUserProc->GetName() == temporary ){
     924            if( pMethod->pUserProc->Params().Equals( pUserProc->Params() ) ){
     925
     926                if(pMethod->IsVirtual()){
    1153927                    //メンバ関数を上書き
    1154                     method->pUserProc=pUserProc;
    1155                     method->bAbstract=0;
    1156 
    1157                     if(!bOverride){
     928                    pMethod->pUserProc=pUserProc;
     929                    pMethod->Override();
     930
     931                    if( !isOverride ){
    1158932                        SetError(127,NULL,nowLine);
    1159933                    }
    1160                     if(method->dwAccess!=dwAccess){
     934                    if(pMethod->dwAccess!=dwAccess){
    1161935                        SetError(128,NULL,nowLine);
    1162936                    }
    1163937
    1164                     pUserProc->SetMethod( method );
     938                    pUserProc->SetMethod( pMethod );
    1165939                    return;
    1166940                }
    … …  
    1169943    }
    1170944
    1171     if(bVirtual){
     945    if( isVirtual ){
    1172946        pobj_c->vtbl_num++;
    1173947    }
    1174948
    1175     if(bOverride){
     949    if( isOverride ){
    1176950        SetError(12,"Override",nowLine);
    1177951    }
    1178952
    1179953    if(bStatic){
    1180         pobj_c->AddStaticMethod(pUserProc,dwAccess);
     954        pobj_c->staticMethods.AddStatic(pUserProc,dwAccess);
    1181955    }
    1182956    else{
    1183         pobj_c->AddMethod(pUserProc, dwAccess, isConst, bAbstract, bVirtual);
     957        pobj_c->methods.Add(pUserProc, dwAccess, isConst, isAbstract, isVirtual);
    1184958    }
    1185959}
    … …  
    15171291                else i3=0;
    15181292
    1519                 BOOL bVirtual=0,bAbstract=0,bOverride=0;
     1293                bool isVirtual = false, isAbstract = false, isOverride = false;
    15201294                if(i3==ESC_ABSTRACT){
    1521                     bAbstract=1;
    1522                     bVirtual=1;
     1295                    isAbstract=1;
     1296                    isVirtual=1;
    15231297                    i+=2;
    15241298
    … …  
    15261300                }
    15271301                else if(i3==ESC_VIRTUAL){
    1528                     bAbstract=0;
    1529                     bVirtual=1;
     1302                    isAbstract=0;
     1303                    isVirtual=1;
    15301304                    i+=2;
    15311305
    … …  
    15331307                }
    15341308                else if(i3==ESC_OVERRIDE){
    1535                     bOverride=1;
    1536                     bVirtual=1;
     1309                    isOverride=1;
     1310                    isVirtual=1;
    15371311
    15381312                    i+=2;
    … …  
    16191393                        bStatic,
    16201394                        isConst,
    1621                         bAbstract,
    1622                         bVirtual,
    1623                         bOverride,
     1395                        isAbstract,
     1396                        isVirtual,
     1397                        isOverride,
    16241398                        temporary,
    16251399                        sub_address);
    16261400
    1627                     if(bAbstract) continue;
     1401                    if( isAbstract ) continue;
    16281402
    16291403                    for(;;i++){
    … …  
    16991473                sprintf( referenceOffsetsBuffer + lstrlen( referenceOffsetsBuffer ),
    17001474                    "%d",
    1701                     objClass.GetMemberOffset( member.name ) );
     1475                    objClass.GetMemberOffset( member.GetName().c_str() ) );
    17021476
    17031477                numOfReference++;
    … …  
    18221596        pCompilingClass->Using();
    18231597
    1824         pCompilingMethod = pCompilingClass->GetMethodInfo( pUserProc );
     1598        pCompilingMethod = pCompilingClass->methods.GetMethodPtr( pUserProc );
    18251599        if( !pCompilingMethod ){
    1826             pCompilingMethod = pCompilingClass->GetStaticMethodInfo( pUserProc );
     1600            pCompilingMethod = pCompilingClass->staticMethods.GetMethodPtr( pUserProc );
    18271601            if( !pCompilingMethod ){
    18281602                SetError(300,NULL,cp);
    … …  
    18381612    return pCompilingClass;
    18391613}
    1840 CMethod *CDBClass::GetNowCompilingMethodInfo(){
     1614const CMethod *CDBClass::GetNowCompilingMethodInfo(){
    18411615    return pCompilingMethod;
    18421616}

  • BasicCompiler_Common/Class.h

    r134 r135  
    55
    66#include <Prototype.h>
    7 #include "Type.h"
     7#include <Method.h>
     8#include <Member.h>
    89#include "Procedure.h"
    9 
    10 class CClass;
    1110
    1211#define ACCESS_NON          0
    … …  
    1413#define ACCESS_PUBLIC       2
    1514#define ACCESS_PROTECTED    3
    16 
    17 class CMember : public Type
    18 {
    19     bool isConst;
    20 public:
    21     char *name;
    22     int SubScripts[MAX_ARRAYDIM];
    23 
    24     DWORD dwAccess;
    25 
    26     char *InitBuf;
    27     char *ConstractParameter;
    28 
    29     int source_code_address;
    30 
    31 
    32     CMember( CClass *pobj_c, DWORD access, bool idConst, bool isRef, char *buffer, int nowLine=-1 );
    33     CMember( CMember &member );
    34     CMember();
    35     ~CMember();
    36 
    37     bool IsConst();
    38 
    39 
    40     static void InitStaticMember(void);
    41 };
    42 class CMethod
    43 {
    44 public:
    45     UserProc *pUserProc;
    46 
    47     DWORD dwAccess;
    48     BOOL bAbstract;
    49     BOOL bVirtual;
    50     bool isConst;
    51     bool isStatic;
    52 
    53     const CClass *pobj_InheritsClass;
    54 
    55     CMethod(CMethod *pobj);
    56     CMethod( UserProc *pUserProc, DWORD dwAccess, BOOL bAbstract, BOOL bVirtual, bool isConst, bool isStatic );
    57     ~CMethod();
    58 };
    5915
    6016class CDBClass;
    … …  
    10056
    10157    //メソッド情報
    102     std::vector<CMethod *> methods;
     58    Methods methods;
    10359    int ConstructorMemberSubIndex;
    10460    int DestructorMemberSubIndex;
    10561
    10662    //静的メソッド情報
    107     std::vector<CMethod *> staticMethods;
     63    Methods staticMethods;
    10864
    10965    enum ClassType{
    … …  
    176132    void AddMember( DWORD dwAccess, bool idConst, bool isRef, char *buffer );
    177133    void AddStaticMember( DWORD dwAccess, bool isConst, bool isRef, char *buffer, int nowLine );
    178     void AddMethod( UserProc *pUserProc,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual );
    179     void AddStaticMethod(UserProc *pUserProc,DWORD dwAccess);
    180134
    181135    //重複チェック
    … …  
    183137    BOOL DupliCheckMember(const char *name);
    184138
    185     //メソッド取得
    186     CMethod *GetMethodInfo( UserProc *pUserProc ) const;
    187     CMethod *GetStaticMethodInfo( UserProc *pUserProc ) const;
    188 
    189     //メソッドの存在を確認
    190     bool IsExistMethod( const char *name ) const;
    191     bool IsExistStaticMethod( const char *name ) const;
    192 
    193     //メソッドを列挙
    194     void EnumStaticMethod( const char *methodName, vector<UserProc *> &subs ) const;
    195     void EnumMethod( const char *methodName, vector<UserProc *> &subs ) const;
    196     void EnumMethod( const BYTE idOperatorCalc, vector<UserProc *> &subs ) const;
    197     const std::vector<CMethod *> &GetMethods() const
     139    const Methods &GetMethods() const
    198140    {
    199141        return methods;
    200142    }
    201     const std::vector<CMethod *> &GetStaticMethods() const
     143    const Methods &GetStaticMethods() const
    202144    {
    203145        return staticMethods;
    … …  
    205147
    206148    //デフォルト コンストラクタ メソッドを取得
    207     CMethod *GetConstructorMethod() const;
     149    const CMethod *GetConstructorMethod() const;
    208150
    209151    //デストラクタ メソッドを取得
    210     CMethod *GetDestructorMethod() const;
     152    const CMethod *GetDestructorMethod() const;
    211153
    212154    // メンバの総合サイズを取得
    … …  
    288230
    289231private:
    290     void AddMethod(CClass *pobj_c, DWORD dwAccess, BOOL bStatic, bool isConst, BOOL bAbstract,
    291         BOOL bVirtual, BOOL bOverride, char *buffer, int nowLine);
     232    void AddMethod(CClass *pobj_c, DWORD dwAccess, BOOL bStatic, bool isConst, bool isAbstract,
     233        bool isVirtual, bool isOverride, char *buffer, int nowLine);
    292234    BOOL MemberVar_LoopRefCheck(const CClass &objClass);
    293235public:
    … …  
    312254private:
    313255    const CClass *pCompilingClass;
    314     CMethod *pCompilingMethod;
     256    const CMethod *pCompilingMethod;
    315257public:
    316258    //コンパイル開始の通知を受け取るメソッド
    … …  
    319261    //現在コンパイル中のメソッド情報を取得
    320262    const CClass *GetNowCompilingClass() const;
    321     CMethod *GetNowCompilingMethodInfo();
     263    const CMethod *GetNowCompilingMethodInfo();
    322264
    323265

  • BasicCompiler_Common/DebugMiddleFile.cpp

    r131 r135  
    327327        i2+=sizeof(long);
    328328        for(i4=0;i4<pobj_c->iMemberNum;i4++){
    329             lstrcpy(buffer+i2,pobj_c->ppobj_Member[i4]->name);
     329            lstrcpy(buffer+i2,pobj_c->ppobj_Member[i4]->GetName().c_str());
    330330            i2+=lstrlen(buffer+i2)+1;
    331331
    … …  
    353353        *(long *)(buffer+i2)=(long)pobj_c->methods.size();
    354354        i2+=sizeof(long);
    355         foreach( CMethod *method, pobj_c->methods ){
    356             *(long *)(buffer+i2)=method->dwAccess;
    357             i2+=sizeof(long);
    358             if(method->pobj_InheritsClass){
    359                 lstrcpy(buffer+i2,method->pobj_InheritsClass->GetName().c_str());
     355        foreach( const CMethod *pMethod, pobj_c->methods ){
     356            *(long *)(buffer+i2)=pMethod->dwAccess;
     357            i2+=sizeof(long);
     358            if( pMethod->GetInheritsClassPtr() ){
     359                lstrcpy(buffer+i2,pMethod->GetInheritsClassPtr()->GetName().c_str());
    360360                i2+=lstrlen(buffer+i2)+1;
    361361            }
    … …  
    364364                i2+=lstrlen(buffer+i2)+1;
    365365            }
    366             lstrcpy(buffer+i2,method->pUserProc->GetName().c_str());
     366            lstrcpy(buffer+i2,pMethod->pUserProc->GetName().c_str());
    367367            i2+=lstrlen(buffer+i2)+1;
    368368        }
    … …  
    372372        i2+=sizeof(long);
    373373        foreach( CMember *member, pobj_c->staticMembers ){
    374             lstrcpy(buffer+i2,member->name);
     374            lstrcpy(buffer+i2,member->GetName().c_str());
    375375            i2+=lstrlen(buffer+i2)+1;
    376376
    … …  
    709709            pobj_c->ppobj_Member[i4]=new CMember();
    710710
    711             pobj_c->ppobj_Member[i4]->name=(char *)HeapAlloc(hHeap,0,lstrlen(buffer+i2)+1);
    712             lstrcpy(pobj_c->ppobj_Member[i4]->name,buffer+i2);
     711            pobj_c->ppobj_Member[i4]->SetName( (char *)(buffer+i2) );
    713712            i2+=lstrlen(buffer+i2)+1;
    714713
    … …  
    759758            }
    760759
    761             CMethod *method = new CMethod( pUserProc, dwAccess, 0,0,false, false);
    762             method->pobj_InheritsClass = pobj_InheritsClass;
    763 
    764             pobj_c->methods.push_back( method );
     760            CMethod *pMethod = new DynamicMethod( pUserProc, dwAccess, 0,0,false, pobj_InheritsClass);
     761
     762            pobj_c->methods.push_back( pMethod );
    765763        }
    766764
    … …  
    771769            CMember *member=new CMember();
    772770
    773             member->name=(char *)HeapAlloc(hHeap,0,lstrlen(buffer+i2)+1);
    774             lstrcpy(member->name,buffer+i2);
     771            member->SetName( (char *)(buffer+i2) );
    775772            i2+=lstrlen(buffer+i2)+1;
    776773

  • BasicCompiler_Common/Diagnose.cpp

    r131 r135  
    7777
    7878            // 動的メソッド
    79             foreach( const CMethod &method, objClass.GetMethods() ){
    80                 if( method.pUserProc->IsCompiled() ){
    81                     codeSizeOfClass += method.pUserProc->GetCodeSize();
     79            foreach( const CMethod *pMethod, objClass.GetMethods() ){
     80                if( pMethod->pUserProc->IsCompiled() ){
     81                    codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
    8282                }
    8383            }
    8484
    8585            // 静的メソッド
    86             foreach( const CMethod &method, objClass.GetStaticMethods() ){
    87                     codeSizeOfClass += method.pUserProc->GetCodeSize();
     86            foreach( const CMethod *pMethod, objClass.GetStaticMethods() ){
     87                    codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
    8888            }
    8989
    … …  
    112112
    113113            // 動的メソッド
    114             foreach( const CMethod &method, objClass.GetMethods() ){
    115                 if( method.pUserProc->IsCompiled() ){
    116                     codeSizeOfClass += method.pUserProc->GetCodeSize();
     114            foreach( const CMethod *pMethod, objClass.GetMethods() ){
     115                if( pMethod->pUserProc->IsCompiled() ){
     116                    codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
    117117                }
    118118            }
    119119
    120120            // 静的メソッド
    121             foreach( const CMethod &method, objClass.GetStaticMethods() ){
    122                     codeSizeOfClass += method.pUserProc->GetCodeSize();
     121            foreach( const CMethod *pMethod, objClass.GetStaticMethods() ){
     122                    codeSizeOfClass += pMethod->pUserProc->GetCodeSize();
    123123            }
    124124

  • BasicCompiler_Common/LexicalScoping.cpp

    r75 r135  
    214214    if(indexSystemGC!=-1){
    215215        //_System_GCオブジェクトのデストラクタの呼び出し処理
    216         CMethod *method = vars[indexSystemGC]->GetClass().GetDestructorMethod();
     216        const CMethod *method = vars[indexSystemGC]->GetClass().GetDestructorMethod();
    217217        if( method ){
    218218            Opcode_CallProc("",method->pUserProc,0,vars[indexSystemGC]->GetName().c_str(),DEF_OBJECT);

  • BasicCompiler_Common/NumOpe_GetType.cpp

    r129 r135  
    194194
    195195    std::vector<UserProc *> subs;
    196     pobj_c->EnumMethod( idCalc, subs );
     196    pobj_c->GetMethods().Enum( idCalc, subs );
    197197    if( subs.size() == 0 ){
    198198        return 0;
    … …  
    372372        GetVarFormatString(methodName,parameter,lpPtrOffset,member,refType);
    373373
    374         objClass.EnumMethod( methodName, userProcs );
     374        objClass.GetMethods().Enum( methodName, userProcs );
    375375        UserProc *pUserProc;
    376376        if(userProcs.size()){

  • BasicCompiler_Common/Procedure.cpp

    r131 r135  
    382382        return false;
    383383    }
    384     return ( pMethod->bVirtual != 0 );
     384    return ( pMethod->IsVirtual() != 0 );
    385385}
    386386const NamespaceScopes &UserProc::GetNamespaceScopes() const

  • BasicCompiler_Common/Subroutine.cpp

    r120 r135  
    300300bool GetReturnTypeOfIndexerGetterProc( const CClass &objClass, Type &resultType ){
    301301    vector<UserProc *> subs;
    302     objClass.EnumMethod( CALC_ARRAY_GET, subs );
     302    objClass.GetMethods().Enum( CALC_ARRAY_GET, subs );
    303303    if( subs.size() == 0 ){
    304304        return false;
    … …  
    462462}
    463463
    464 GlobalProc *AddSubData( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, char *buffer,int nowLine,BOOL bVirtual,CClass *pobj_c, bool isStatic){
     464GlobalProc *AddSubData( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, char *buffer,int nowLine,bool isVirtual,CClass *pobj_c, bool isStatic){
    465465    int i2,i3;
    466466    char temporary[8192];

  • BasicCompiler_Common/VarList.cpp

    r114 r135  
    168168        if(bPtr){
    169169            lstrcpy(VarName,"->");
    170             lstrcat(VarName,objClass.ppobj_Member[i]->name);
     170            lstrcat(VarName,objClass.ppobj_Member[i]->GetName().c_str());
    171171        }
    172172        else{
    173173            lstrcpy(VarName,".");
    174             lstrcat(VarName,objClass.ppobj_Member[i]->name);
     174            lstrcat(VarName,objClass.ppobj_Member[i]->GetName().c_str());
    175175        }
    176176
    177177        LONG_PTR offset;
    178178        int i2;
    179         offset=objClass.GetMemberOffset( objClass.ppobj_Member[i]->name, &i2 );
     179        offset=objClass.GetMemberOffset( objClass.ppobj_Member[i]->GetName().c_str(), &i2 );
    180180
    181181        if(objClass.ppobj_Member[i]->SubScripts[0]!=-1){
    … …  
    423423
    424424    for(i=0;i<pUserProc->GetParentClassPtr()->iMemberNum;i++){
    425         offset=pUserProc->GetParentClassPtr()->GetMemberOffset( pUserProc->GetParentClassPtr()->ppobj_Member[i]->name,&i2);
     425        offset=pUserProc->GetParentClassPtr()->GetMemberOffset( pUserProc->GetParentClassPtr()->ppobj_Member[i]->GetName().c_str(),&i2);
    426426
    427427        if(pUserProc->GetParentClassPtr()->ppobj_Member[i]->SubScripts[0]!=-1){
    428428            //配列
    429429            sprintf(temporary,"%s %s(&H%X)",
    430                 pUserProc->GetParentClassPtr()->ppobj_Member[i]->name,
     430                pUserProc->GetParentClassPtr()->ppobj_Member[i]->GetName().c_str(),
    431431                STRING_ARRAY,
    432432                (ULONG_PTR)offset);
    … …  
    442442        else{
    443443            VarList_Insert(hVarTree_This,&tv,
    444                 pUserProc->GetParentClassPtr()->ppobj_Member[i]->name,
     444                pUserProc->GetParentClassPtr()->ppobj_Member[i]->GetName().c_str(),
    445445                *pUserProc->GetParentClassPtr()->ppobj_Member[i],
    446446                pThis+offset);

  • BasicCompiler_Common/VariableOpe.cpp

    r131 r135  
    559559
    560560    for(i=0;i<objClass.iMemberNum;i++){
    561         if(lstrcmp(objClass.ppobj_Member[i]->name,VarName)==0) break;
     561        if( objClass.ppobj_Member[i]->GetName() == VarName ){
     562            break;
     563        }
    562564    }
    563565    if(i==objClass.iMemberNum){
    … …  
    692694
    693695            for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
    694                 if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
     696                if( pobj_CompilingClass->ppobj_Member[i]->GetName() == VarName ){
     697                    break;
     698                }
    695699            }
    696700            if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
    … …  
    11361140    if( type.IsObject() ){
    11371141        //デストラクタの利用フラグをオンにする
    1138         CMethod *method = type.GetClass().GetDestructorMethod();
     1142        const CMethod *method = type.GetClass().GetDestructorMethod();
    11391143        if( method ){
    11401144            method->pUserProc->Using();

  • BasicCompiler_Common/WatchList.cpp

    r100 r135  
    380380
    381381            for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
    382                 if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
     382                if( pobj_CompilingClass->ppobj_Member[i]->GetName() == VarName ){
     383                    break;
     384                }
    383385            }
    384386            if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;

  • BasicCompiler_Common/common.h

    r131 r135  
    430430BOOL GetConstCalcBuffer(const char *name,const char *Parameter,char *pCalcBuffer);
    431431DWORD GetConstValue(char *name,double *dbl,char *buffer,LONG_PTR *plpIndex);
    432 bool IsStringObjectType(const Type &TypeInfo);
    433432int IsStrCalculation(char *Command);
    434433BYTE GetCalcId(const char *Command,int *pi);
    … …  
    452451bool GetReturnTypeOfPropertyMethod( const char *variable, const char *rightSide, Type &resultType );
    453452bool GetReturnTypeOfIndexerGetterProc( const CClass &objClass, Type &resultType );
    454 GlobalProc *AddSubData( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, char *buffer,int nowLine,BOOL bVirtual,CClass *pobj_c, bool isStatic = false );
     453GlobalProc *AddSubData( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, char *buffer,int nowLine,bool isVirtual,CClass *pobj_c, bool isStatic = false );
    455454void GetSubInfo(void);
    456455void DeleteSubInfo(GlobalProc **ppSubHash,char **ppMacroNames,int MacroNum);

  • BasicCompiler_Common/hash.cpp

    r114 r135  
    9999            if( isStatic ){
    100100                // 静的メソッドから列挙
    101                 pobj_c->EnumStaticMethod( NestMember, subs );
     101                pobj_c->GetStaticMethods().EnumStatic( NestMember, subs );
    102102            }
    103103            else{
    104104                //動的メソッドから列挙
    105                 pobj_c->EnumMethod( NestMember, subs );
     105                pobj_c->GetMethods().Enum( NestMember, subs );
    106106            }
    107107            return;
    … …  
    114114
    115115        // 静的メソッド
    116         pobj_CompilingClass->EnumStaticMethod( name, subs );
     116        pobj_CompilingClass->GetStaticMethods().EnumStatic( name, subs );
    117117
    118118        // 動的メソッド
    119         pobj_CompilingClass->EnumMethod( name, subs );
     119        pobj_CompilingClass->GetMethods().Enum( name, subs );
    120120    }
    121121
    … …  
    190190    if( pClass ){
    191191        vector<UserProc *> userProcs;
    192         pClass->EnumMethod( methodName, userProcs );
     192        pClass->GetMethods().Enum( methodName, userProcs );
    193193        if( userProcs.size() == 1 ){
    194194            return userProcs[0];

  • BasicCompiler_Common/include/Prototype.h

    r134 r135  
    77
    88using namespace std;
     9
     10class CMethod;
     11class UserProc;
    912
    1013class Prototype
    … …  
    5255    // シンボル比較
    5356    bool IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const;
    54     bool IsEqualSymbol( const Prototype &objClass ) const;
     57    bool IsEqualSymbol( const Prototype &prototype ) const;
    5558    bool IsEqualSymbol( const string &name ) const;
    5659
Note: See TracChangeset for help on using the changeset viewer.