source: dev/BasicCompiler_Common/Class.cpp@ 60

#include "common.h"

#ifdef _AMD64_
#include "../BasicCompiler64/opcode.h"
#else
#include "../BasicCompiler32/opcode.h"
#endif

CDBClass *pobj_DBClass;

CClass *pobj_CompilingClass;
CClass *pobj_StringClass;

CMember *pCompilingMethod;



CMember::CMember( CClass *pobj_c, DWORD access, bool isConst, bool isRef, char *buffer, int NowLine ){
    extern int cp;

    //構文を解析
    char VarName[VN_SIZE];
    char init_buf[VN_SIZE];
    char constract_parameter[VN_SIZE];
    GetDimentionFormat(buffer,isRef,VarName,SubScripts,&TypeInfo,init_buf,constract_parameter);

    //重複チェック
    if(pobj_c->DupliCheckAll(VarName)){
        SetError(15,VarName,cp);
    }

    if(TypeInfo.type==DEF_OBJECT){
        if(TypeInfo.u.pobj_Class->IsAbstract()){
            //抽象クラスだったとき
            SetError(125,TypeInfo.u.pobj_Class->name,cp);
        }
    }

    //メンバ名
    name=(char *)HeapAlloc(hHeap,0,lstrlen(VarName)+1);
    lstrcpy(name,VarName);

    //アクセス権
    dwAccess=access;

    //定数扱いかどうか
    this->isConst = isConst;

    //参照型かどうか
    this->isRef = isRef;

    //初期データ
    InitBuf=(char *)HeapAlloc(hHeap,0,lstrlen(init_buf)+1);
    lstrcpy(InitBuf,init_buf);

    //コンストラクタ用のパラメータ
    ConstractParameter=(char *)HeapAlloc(hHeap,0,lstrlen(constract_parameter)+1);
    lstrcpy(ConstractParameter,constract_parameter);

    //ソースコードの位置
    source_code_address=NowLine;
}
CMember::CMember(CMember *pobj){
    //コピーコンストラクタ
    memset(this,0,sizeof(CMember));

    //name
    name=(char *)HeapAlloc(hHeap,0,lstrlen(pobj->name)+1);
    lstrcpy(name,pobj->name);

    //定数扱いかどうか
    isConst = pobj->isConst;

    //参照型かどうか
    isRef = pobj->isRef;

    //SubScripts
    memcpy(SubScripts,pobj->SubScripts,MAX_ARRAYDIM*sizeof(int));

    //TypeInfo
    TypeInfo=pobj->TypeInfo;

    //ソースコードの位置
    source_code_address=pobj->source_code_address;
}
CMember::CMember(){
    memset(this,0,sizeof(CMember));
}
CMember::~CMember(){
    HeapDefaultFree(name);
    if(InitBuf) HeapDefaultFree(InitBuf);
    if(ConstractParameter) HeapDefaultFree(ConstractParameter);
}

bool CMember::IsConst(){
    return isConst;
}
bool CMember::IsRef(){
    return isRef;
}

int CMember::GetSize(){
    if( IsRef() ){
        // 参照型
        return PTR_SIZE;
    }

    //メンバサイズを取得
    return GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
}

void CMember::InitStaticMember(void){
    //静的メンバをグローバル領域に作成

    //イテレータをリセット
    extern CDBClass *pobj_DBClass;
    pobj_DBClass->Iterator_Reset();

    int back_cp=cp;

    while(pobj_DBClass->Iterator_HasNext()){
        CClass *pobj_c;
        pobj_c=pobj_DBClass->Iterator_GetNext();

        foreach( CMember *member, pobj_c->staticMembers ){
            char temporary[VN_SIZE];
            sprintf(temporary,"%s.%s",pobj_c->name,member->name);
            AddGlobalVariable(
                temporary,
                member->SubScripts,
                &member->TypeInfo,
                GetTypeSize(member->TypeInfo.type,member->TypeInfo.u.lpIndex),
                member->InitBuf,
                member->ConstractParameter,
                0);

            if(member->TypeInfo.type==DEF_OBJECT){
                //エラー用
                cp=member->source_code_address;

                CallConstructor(temporary,
                    member->SubScripts,
                    member->TypeInfo,
                    member->ConstractParameter);
            }

            //ネイティブコードバッファの再確保
            extern int obp_AllocSize;
            if(obp_AllocSize<obp+8192){
                obp_AllocSize+=8192;
                OpBuffer=(char *)HeapReAlloc(hHeap,0,OpBuffer,obp_AllocSize); //matea
            }
        }
    }

    cp=back_cp;
}



CMethod::CMethod(CMethod *pobj){
    //コピーコンストラクタ
    memset(this,0,sizeof(CMethod));

    psi=pobj->psi;

    bAbstract=pobj->bAbstract;

    bVirtual=pobj->bVirtual;
}
CMethod::CMethod(){
    memset(this,0,sizeof(CMethod));
}
CMethod::~CMethod(){
}




CClass::CClass(const char *name){
    memset(this,0,sizeof(CClass));

    vtbl_offset=-1;

    this->name=(char *)HeapAlloc(hHeap,0,lstrlen(name)+1);
    lstrcpy(this->name,name);

    isCompilingConstructor = false;
    isCompilingDestructor = false;
}
CClass::~CClass(){
    int i;

    //クラス名
    HeapDefaultFree(name);

    if(ppobj_Member){
        //メンバ
        for(i=0;i<iMemberNum;i++){
            delete ppobj_Member[i];
        }
        HeapDefaultFree(ppobj_Member);
        ppobj_Member=0;
    }

    //静的メンバ
    foreach( CMember *member, staticMembers ){
        delete member;
    }

    //メソッド
    foreach( CMethod *method, methods ){
        delete method;
    }

    //静的メソッド
    foreach( CMethod *method, staticMethods ){
        delete method;
    }
}
void CClass::Inherits( CClass *pInheritsClass ){
    int i3;

    //メンバをコピー
    ppobj_Member=(CMember **)HeapReAlloc(
        hHeap,
        0,
        ppobj_Member,
        pInheritsClass->iMemberNum*sizeof(CMember *));
    iMemberNum=pInheritsClass->iMemberNum;
    for(i3=0;i3<pInheritsClass->iMemberNum;i3++){
        ppobj_Member[i3]=new CMember(pInheritsClass->ppobj_Member[i3]);

        //dwAccess
        if(pInheritsClass->ppobj_Member[i3]->dwAccess==ACCESS_PRIVATE)
            ppobj_Member[i3]->dwAccess=ACCESS_NON;
        else ppobj_Member[i3]->dwAccess=pInheritsClass->ppobj_Member[i3]->dwAccess;
    }

    //メソッドをコピー
    foreach( CMethod *baseMethod, pInheritsClass->methods ){
        CMethod *method = new CMethod( baseMethod );

        //dwAccess
        if(baseMethod->dwAccess==ACCESS_PRIVATE)
            method->dwAccess=ACCESS_NON;
        else method->dwAccess=baseMethod->dwAccess;

        //pobj_Inherits
        // ※継承元のClassIndexをセット（入れ子継承を考慮する）
        if(baseMethod->pobj_InheritsClass==0)
            method->pobj_InheritsClass=pInheritsClass;
        else
            method->pobj_InheritsClass=
                baseMethod->pobj_InheritsClass;

        methods.push_back( method );
    }

    //仮想関数の数
    vtbl_num=pInheritsClass->vtbl_num;

    //継承先のクラスをメンバとして保持する
    pobj_InheritsClass = pInheritsClass;
}
void CClass::AddMember( DWORD dwAccess, bool isConst, bool isRef, char *buffer ){
    ppobj_Member = (CMember **)HeapReAlloc( hHeap, 0, ppobj_Member, ( iMemberNum + 1 ) * sizeof(CMember *) );
    ppobj_Member[iMemberNum] = new CMember( this, dwAccess, isConst, isRef, buffer );
    iMemberNum++;
}
void CClass::AddStaticMember( DWORD dwAccess, bool isConst, bool isRef, char *buffer, int NowLine ){
    CMember *member = new CMember( this, dwAccess, isConst, isRef, buffer, NowLine );
    staticMembers.push_back( member );
}
void CClass::AddMethod( SUBINFO *psi,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual ){
    CMethod *method = new CMethod();
    method->psi = psi;
    method->dwAccess = dwAccess;
    method->isConst = isConst;
    method->bAbstract = bAbstract;
    method->bVirtual = bVirtual;
    method->pobj_InheritsClass = 0;

    methods.push_back( method );
}
void CClass::AddStaticMethod(SUBINFO *psi,DWORD dwAccess){
    CMethod *method = new CMethod();
    method->psi=psi;
    method->dwAccess=dwAccess;
    method->bAbstract=0;
    method->bVirtual=0;
    method->pobj_InheritsClass=0;

    staticMethods.push_back( method );
}
BOOL CClass::DupliCheckAll(const char *name){
    //重複チェック

    //メンバ
    if(DupliCheckMember(name)) return 1;

    //メソッド
    foreach( CMethod *method, methods ){
        if( lstrcmp( name, method->psi->name ) == 0 ){
            return 1;
        }
    }

    return 0;
}
BOOL CClass::DupliCheckMember(const char *name){
    //重複チェック

    //メンバ
    for( int i=0;i<iMemberNum;i++){
        if(lstrcmp(name,ppobj_Member[i]->name)==0){
            return 1;
        }
    }

    //静的メンバ
    foreach( CMember *member, staticMembers ){
        if( lstrcmp( name, member->name ) == 0 ){
            return 1;
        }
    }

    return 0;
}
CMethod *CClass::GetMethodInfo( SUBINFO *psi ){
    for( int i=(int)methods.size()-1; i>=0; i-- ){
        if( psi == methods[i]->psi ) return methods[i];
    }
    return NULL;
}
CMethod *CClass::GetStaticMethodInfo( SUBINFO *psi ){
    for( int i=(int)staticMethods.size()-1; i>=0; i-- ){
        if( psi == staticMethods[i]->psi ) return staticMethods[i];
    }
    return NULL;
}
bool CClass::IsExistMethod( const char *name ){
    foreach( CMethod *method, methods ){
        if( lstrcmp( method->psi->name, name ) == 0 ) return true;
    }
    return false;
}
bool CClass::IsExistStaticMethod( const char *name ){
    foreach( CMethod *method, staticMethods ){
        if( lstrcmp( method->psi->name, name ) == 0 ) return true;
    }
    return false;
}

void CClass::EnumStaticMethod( const char *methodName, std::vector<SUBINFO *> &subs ) const
{
    foreach( CMethod *method, staticMethods ){
        if(lstrcmp(methodName,method->psi->name)==0){
            subs.push_back( method->psi );
        }
    }
}

void CClass::EnumMethod( const char *methodName, std::vector<SUBINFO *> &subs ) const
{
    //オブジェクトのメンバ関数の場合
    //※オーバーライドされた関数を先にサーチする必要があるため、バックサーチを行う
    for( int i=(int)methods.size()-1; i>=0; i-- ){
        if(lstrcmp(methodName,methods[i]->psi->name)==0){
            subs.push_back( methods[i]->psi );
        }
    }
}

void CClass::EnumMethod( const BYTE idOperatorCalc, std::vector<SUBINFO *> &subs ) const
{
    //オブジェクトのメンバ関数の場合
    //※オーバーライドされた関数を先にサーチする必要があるため、バックサーチを行う
    for( int i=(int)methods.size()-1; i>=0; i-- ){
        char *temp;
        temp=methods[i]->psi->name;
        if(temp[0]==1&&temp[1]==ESC_OPERATOR){
            if((BYTE)temp[2]==idOperatorCalc){
                subs.push_back( methods[i]->psi );
            }
        }
    }
}

//デフォルト コンストラクタ メソッドを取得
CMethod *CClass::GetConstructorMethod() const
{
    if( ConstructorMemberSubIndex == -1 ) return NULL;
    return methods[ConstructorMemberSubIndex];
}

//デフォルト コピーコンストラクタ メソッドを取得
CMethod *CClass::GetCopyConstructorMethod() const
{
    if( CopyConstructorMemberSubIndex == -1 ) return NULL;
    return methods[CopyConstructorMemberSubIndex];
}

//デストラクタ メソッドを取得
CMethod *CClass::GetDestructorMethod() const
{
    if( DestructorMemberSubIndex == -1 ) return NULL;
    return methods[DestructorMemberSubIndex];
}


int CClass::GetFuncNumInVtbl( const SUBINFO *psi ) const
{
    int n = 0;
    foreach( CMethod *method, methods ){
        if( method->psi == psi ) break;
        if( method->psi->bVirtual ) n++;
    }
    return n;
}
LONG_PTR CClass::GetVtblGlobalOffset(void){

    //既に存在する場合はそれを返す
    if(vtbl_offset!=-1) return vtbl_offset;


    //////////////////////////////////////
    // 存在しないときは新たに生成する
    //////////////////////////////////////

    SUBINFO **ppsi;
    ppsi=(SUBINFO **)HeapAlloc(hHeap,0,vtbl_num*sizeof(SUBINFO *));

    //関数テーブルに値をセット
    int i2 = 0;
    foreach( CMethod *method, methods ){
        if(method->bVirtual){
            method->psi->bUse=1;

            if(method->bAbstract){
                extern int cp;
                SetError(300,NULL,cp);

                ppsi[i2]=0;
            }
            else ppsi[i2]=method->psi;
            i2++;
        }
    }

    vtbl_offset=dataTable.AddBinary((void *)ppsi,vtbl_num*sizeof(LONG_PTR));

    for( int i=0; i < vtbl_num; i++ ){
        pobj_Reloc->AddSchedule_DataSection(vtbl_offset+i*sizeof(LONG_PTR));
    }

    HeapDefaultFree(ppsi);

    return vtbl_offset;
}
void CClass::ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection){
    if(vtbl_offset==-1) return;

    LONG_PTR *pVtbl;
    pVtbl=(LONG_PTR *)((char *)dataTable.GetPtr()+vtbl_offset);

    int i;
    for(i=0;i<vtbl_num;i++){
        SUBINFO *psi;
        psi=(SUBINFO *)pVtbl[i];
        if(!psi) continue;
        pVtbl[i]=psi->CompileAddress+ImageBase+MemPos_CodeSection;
    }
}
bool CClass::IsAbstract(){
    //未実装の仮想関数を持つ場合はtrueを返す

    foreach( CMethod *method, methods ){
        if(method->bVirtual){
            if(method->bAbstract){
                return true;
            }
        }
    }

    //コンポジションの関係にあるメンバも検査する
    for(int i=0;i < iMemberNum;i++){
        if(ppobj_Member[i]->TypeInfo.type==DEF_OBJECT && ppobj_Member[i]->IsRef() == false){
            if(ppobj_Member[i]->TypeInfo.u.pobj_Class->IsAbstract())
                return true;
        }
    }

    return false;
}

// コンストラクタのコンパイルを開始
void CClass::NotifyStartConstructorCompile(){
    isCompilingConstructor = true;
}

//コンストラクタのコンパイルを終了
void CClass::NotifyFinishConstructorCompile(){
    isCompilingConstructor = false;
}

//コンストラクタをコンパイル中かどうかを判別
bool CClass::IsCompilingConstructor(){
    return isCompilingConstructor;
}

//デストラクタのコンパイルを開始
void CClass::NotifyStartDestructorCompile(){
    isCompilingDestructor = true;
}

//デストラクタのコンパイルを終了
void CClass::NotifyFinishDestructorCompile(){
    isCompilingDestructor = false;
}

//デストラクタをコンパイル中かどうかを判別
bool CClass::IsCompilingDestructor(){
    return isCompilingDestructor;
}


//自身と等しいクラスかどうかを確認
bool CClass::IsEquals( CClass *pClass ){
    if( this == pClass ) return true;
    return false;
}

//自身の派生クラスかどうかを確認
bool CClass::IsSubClass( CClass *pClass ){
    pClass = pClass->pobj_InheritsClass;
    while( pClass ){
        if( this == pClass ) return true;
        pClass = pClass->pobj_InheritsClass;
    }
    return false;
}

//自身と等しいまたは派生クラスかどうかを確認
bool CClass::IsEqualsOrSubClass( CClass *pClass ){
    if( IsEquals( pClass ) ) return true;
    return IsSubClass( pClass );
}



int CDBClass::hash(const char *name){
    int key;

    for(key=0;*name!='\0';name++){
        key=((key<<8)+ *name )%MAX_CLASS_HASH;
    }

    return key;
}

void CDBClass::DestroyClass(CClass *pobj_c){
    if(pobj_c->pobj_NextClass){
        DestroyClass(pobj_c->pobj_NextClass);
    }

    delete pobj_c;
}

CDBClass::CDBClass(){
    memset(this,0,sizeof(CDBClass));
}
CDBClass::~CDBClass(){
    int i;
    for(i=0;i<MAX_CLASS_HASH;i++){
        if(pobj_ClassHash[i]) DestroyClass(pobj_ClassHash[i]);
    }

    if(ppobj_IteClass) HeapDefaultFree(ppobj_IteClass);
}

void CDBClass::ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection){
    int i;
    for(i=0;i<MAX_CLASS_HASH;i++){
        if(pobj_ClassHash[i]){
            CClass *pobj_c;
            pobj_c=pobj_ClassHash[i];
            while(1){
                pobj_c->ActionVtblSchedule(ImageBase,MemPos_CodeSection);

                if(pobj_c->pobj_NextClass==0) break;
                pobj_c=pobj_c->pobj_NextClass;
            }
        }
    }
}

CClass *CDBClass::check(const char *name){
    int key;
    key=hash(name);

    if(pobj_ClassHash[key]){
        CClass *pobj_c;
        pobj_c=pobj_ClassHash[key];
        while(1){
            if(lstrcmp(name,pobj_c->name)==0){
                //重複した場合
                return pobj_c;
            }

            if(pobj_c->pobj_NextClass==0) break;
            pobj_c=pobj_c->pobj_NextClass;
        }
    }
    return 0;
}

CClass *CDBClass::AddClass(const char *name,int NowLine){
    //////////////////////////////////////////////////////////////////////////
    // クラスを追加
    // ※名前のみを登録。その他の情報はSetClassメソッドで！
    //////////////////////////////////////////////////////////////////////////

    CClass *pobj_c;
    pobj_c=new CClass(name);

    if(lstrcmp(name,"String")==0){
        //Stringクラス
        pobj_StringClass=pobj_c;
    }


    /////////////////////////////////
    // ハッシュデータに追加
    /////////////////////////////////

    int key;
    key=hash(name);

    if(pobj_ClassHash[key]){
        CClass *pobj_c2;
        pobj_c2=pobj_ClassHash[key];
        while(1){
            if(lstrcmp(name,pobj_c2->name)==0){
                //重複した場合
                SetError(15,name,NowLine);
                return 0;
            }

            if(pobj_c2->pobj_NextClass==0) break;
            pobj_c2=pobj_c2->pobj_NextClass;
        }
        pobj_c2->pobj_NextClass=pobj_c;
    }
    else{
        pobj_ClassHash[key]=pobj_c;
    }

    return pobj_c;  
}

void CDBClass::InitNames(void){
    extern char *basbuf;
    int i;

    for(i=0;;i++){
        if(basbuf[i]=='\0') break;

        if(basbuf[i]==1&&(
            basbuf[i+1]==ESC_CLASS||
            basbuf[i+1]==ESC_TYPE||
            basbuf[i+1]==ESC_INTERFACE
            )){
                int NowLine;
                NowLine=i;

                i+=2;
                //アラインメント修飾子
                if(_memicmp(basbuf+i,"Align(",6)==0){
                    i+=6;
                    i=JumpStringInPare(basbuf,i)+1;
                }

                int i2;
                char temporary[VN_SIZE];
                for(i2=0;;i++,i2++){
                    if(!IsVariableChar(basbuf[i])){
                        temporary[i2]=0;
                        break;
                    }
                    temporary[i2]=basbuf[i];
                }

                //クラスを追加
                pobj_DBClass->AddClass(temporary,NowLine);
        }
    }
}


void CDBClass::AddMethod(CClass *pobj_c, DWORD dwAccess, BOOL bStatic, bool isConst, BOOL bAbstract,
                         BOOL bVirtual, BOOL bOverride, char *buffer, int NowLine){
    int i,i2;
    char temporary[VN_SIZE];

    i=2;
    for(i2=0;;i++,i2++){
        if(buffer[i]=='('||buffer[i]=='\0'){
            temporary[i2]=0;
            break;
        }
        temporary[i2]=buffer[i];
    }


    //関数ハッシュへ登録
    SUBINFO *psi;
    psi=AddSubData(buffer,NowLine,bVirtual,pobj_c,bStatic);
    if(!psi) return;


    ////////////////////////////////////////////////////////////
    // コンストラクタ、デストラクタの場合の処理
    ////////////////////////////////////////////////////////////
    BOOL fConstructor=0,bDestructor=0;

    if(lstrcmp(temporary,pobj_c->name)==0){
        //コンストラクタの場合

        //標準コンストラクタ（引数なし）
        if(psi->ParmNum==0) fConstructor=1;

        //コピーコンストラクタ
        if(psi->ParmNum==1){
            if(psi->pParmInfo[0].type==DEF_OBJECT&&
                psi->pParmInfo[0].u.pobj_c==pobj_c) fConstructor=2;
        }

        //強制的にConst修飾子をつける
        isConst = true;
    }
    else if(temporary[0]=='~'){
        //デストラクタの場合はその名前が正しいかチェックを行う
        if(lstrcmp(temporary+1,pobj_c->name)!=0)
            SetError(117,NULL,NowLine);
        else
            bDestructor=1;
    }
    if(fConstructor||bDestructor){
        // コンストラクタ、デストラクタのアクセシビリティをチェック
        if(dwAccess!=ACCESS_PUBLIC){
            SetError(116,NULL,NowLine);
            dwAccess=ACCESS_PUBLIC;
        }

        //強制的にConst修飾子をつける
        isConst = true;
    }

    if( fConstructor == 1 )
        pobj_c->ConstructorMemberSubIndex = (int)pobj_c->methods.size();
    else if( fConstructor == 2 )
        pobj_c->CopyConstructorMemberSubIndex = (int)pobj_c->methods.size();
    else if( bDestructor )
        pobj_c->DestructorMemberSubIndex = (int)pobj_c->methods.size();



    //////////////////
    // 重複チェック
    //////////////////

    if(pobj_c->DupliCheckMember(temporary)){
        SetError(15,temporary,NowLine);
        return;
    }

    //メソッド
    foreach( CMethod *method, pobj_c->methods ){
        //基底クラスと重複する場合はオーバーライドを行う
        if(method->pobj_InheritsClass) continue;

        if(lstrcmp(temporary,method->psi->name)==0){
            if(CompareParameter(
                method->psi->pParmInfo,method->psi->ParmNum,
                psi->pParmInfo,psi->ParmNum
                )==0){
                //関数名、パラメータ属性が合致したとき
                SetError(15,psi->name,NowLine);
                return;
            }
        }
    }

    //仮想関数の場合
    if(bAbstract) psi->bCompile=1;

    //メソッドのオーバーライド
    foreach( CMethod *method, pobj_c->methods ){
        if(lstrcmp(temporary,method->psi->name)==0){
            if(CompareParameter(
                method->psi->pParmInfo,method->psi->ParmNum,
                psi->pParmInfo,psi->ParmNum
                )==0){

                if(method->psi->bVirtual){
                    //メンバ関数を上書き
                    method->psi=psi;
                    method->bAbstract=0;

                    if(!bOverride){
                        SetError(127,NULL,NowLine);
                    }
                    if(method->dwAccess!=dwAccess){
                        SetError(128,NULL,NowLine);
                    }
                    return;
                }
            }
        }
    }

    if(psi->bVirtual){
        pobj_c->vtbl_num++;
    }

    if(bOverride){
        SetError(12,"Override",NowLine);
    }

    if(bStatic){
        pobj_c->AddStaticMethod(psi,dwAccess);
    }
    else{
        pobj_c->AddMethod(psi, dwAccess, isConst, bAbstract, bVirtual);
    }
}

BOOL CDBClass::MemberVar_LoopRefCheck(CClass *pobj_c){
    int i,i2,bRet=1;
    for(i=0;i<pobj_c->iMemberNum;i++){
        CMember *pMember = pobj_c->ppobj_Member[i];
        if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef()==false ){
            //循環参照でないかをチェック
            if(pobj_LoopRefCheck->check(pMember->TypeInfo.u.pobj_Class->name)){
                extern int cp;
                SetError(124,pMember->TypeInfo.u.pobj_Class->name,cp);
                return 0;
            }

            pobj_LoopRefCheck->add(pobj_c->name);

            i2=MemberVar_LoopRefCheck(pMember->TypeInfo.u.pobj_Class);
            if(bRet==1) bRet=i2;

            pobj_LoopRefCheck->del(pobj_c->name);
        }
    }

    return bRet;
}

void CDBClass::GetClass_recur(const char *lpszInheritsClass){
    extern char *basbuf;
    int i,i2,i3,sub_address,top_pos;
    DWORD dwClassType;
    DWORD dwAccess;
    char temporary[8192];

    for(i=0;;i++){
        if(basbuf[i]=='\0') break;

        CClass *pobj_c;

        if(basbuf[i]==1&&basbuf[i+1]==ESC_INTERFACE){
            //////////////////////////
            // インターフェイス
            //////////////////////////

            top_pos=i;

            i+=2;

            //インターフェイス名を取得
            GetIdentifierToken( temporary, basbuf, i );

            pobj_c=pobj_DBClass->check(temporary);
            if(!pobj_c) continue;

            if(lpszInheritsClass){
                if(lstrcmp(lpszInheritsClass,pobj_c->name)!=0){
                    //継承先先読み用
                    continue;
                }
            }

            if(pobj_c->ppobj_Member){
                //既に先読みされているとき
                continue;
            }

            //メンバ用メモリを初期化
            pobj_c->ppobj_Member=(CMember **)HeapAlloc(hHeap,0,1);
            pobj_c->iMemberNum=0;

            pobj_c->ConstructorMemberSubIndex=-1;
            pobj_c->CopyConstructorMemberSubIndex=-1;
            pobj_c->DestructorMemberSubIndex=-1;

            if(basbuf[i+1]==1&&basbuf[i+2]==ESC_INHERITS){
                //継承を行う場合
                for(i+=3,i2=0;;i++,i2++){
                    if(IsCommandDelimitation(basbuf[i])){
                        temporary[i2]=0;
                        break;
                    }
                    temporary[i2]=basbuf[i];
                }

                if(lstrcmpi(temporary,pobj_c->name)==0){
                    SetError(105,temporary,i);
                    goto Interface_InheritsError;
                }

                //継承元クラスを取得
                CClass *pInheritsClass = check(temporary);
                if( !pInheritsClass ){
                    SetError(106,temporary,i);
                    goto Interface_InheritsError;
                }

                //ループ継承でないかをチェック
                if(pobj_LoopRefCheck->check(temporary)){
                    SetError(123,temporary,i);
                    goto Interface_InheritsError;
                }

                if( pInheritsClass->ppobj_Member == 0 ){
                    //継承先が読み取られていないとき
                    pobj_LoopRefCheck->add(pobj_c->name);
                    GetClass_recur(temporary);
                    pobj_LoopRefCheck->del(pobj_c->name);
                }

                //継承させる
                pobj_c->Inherits( pInheritsClass );
            }
            else{
                //継承無し
                pobj_c->pobj_InheritsClass=0;

                //仮想関数の数を初期化
                pobj_c->vtbl_num=0;
            }
Interface_InheritsError:

            //メンバ変数、関数を取得
            while(1){
                i++;

                //エラー
                if(basbuf[i]==1&&(basbuf[i+1]==ESC_CLASS||basbuf[i+1]==ESC_TYPE||basbuf[i+1]==ESC_INTERFACE)){
                    SetError(22,"Interface",i);
                    i--;
                    break;
                }

                if(basbuf[i]==1&&basbuf[i+1]==ESC_INHERITS){
                    SetError(111,NULL,i);
                    break;
                }

                sub_address=i;

                for(i2=0;;i++,i2++){
                    if(IsCommandDelimitation(basbuf[i])){
                        temporary[i2]=0;
                        break;
                    }
                    temporary[i2]=basbuf[i];
                }
                if(temporary[0]=='\0'){
                    if(basbuf[i]=='\0'){
                        i--;
                        SetError(22,"Interface",top_pos);
                        break;
                    }
                    continue;
                }

                //End Interface記述の場合
                if(temporary[0]==1&&temporary[1]==ESC_ENDINTERFACE) break;

                if(!(temporary[0]==1&&(
                    temporary[1]==ESC_SUB||temporary[1]==ESC_FUNCTION
                    ))){
                    SetError(1,NULL,i);
                    break;
                }

                //メンバ関数を追加
                AddMethod(pobj_c,
                    ACCESS_PUBLIC,      //Publicアクセス権
                    0,                  //Static指定なし
                    false,              //Constではない
                    1,                  //Abstract
                    1,                  //Virtual
                    0,
                    temporary,
                    sub_address
                    );
            }
        }

        if(basbuf[i]==1&&(basbuf[i+1]==ESC_CLASS||basbuf[i+1]==ESC_TYPE)){
            //////////////////////////
            // クラス
            //////////////////////////

            top_pos=i;

            dwClassType=basbuf[i+1];

            i+=2;

            //アラインメント修飾子
            int iAlign=0;
            if(_memicmp(basbuf+i,"Align(",6)==0){
                i+=6;
                i+=GetStringInPare_RemovePare(temporary,basbuf+i)+1;
                iAlign=atoi(temporary);

                if(!(iAlign==1||iAlign==2||iAlign==4||iAlign==8||iAlign==16))
                    SetError(51,NULL,i);
            }


            //クラス名を取得
            GetIdentifierToken( temporary, basbuf, i );

            pobj_c=pobj_DBClass->check(temporary);
            if(!pobj_c) continue;

            if(lpszInheritsClass){
                if(lstrcmp(lpszInheritsClass,pobj_c->name)!=0){
                    //継承先先読み用
                    continue;
                }
            }

            if(pobj_c->ppobj_Member){
                //既に先読みされているとき
                continue;
            }

            pobj_c->iAlign=iAlign;

            //メンバ用メモリを初期化
            pobj_c->ppobj_Member=(CMember **)HeapAlloc(hHeap,0,1);
            pobj_c->iMemberNum=0;

            pobj_c->ConstructorMemberSubIndex=-1;
            pobj_c->CopyConstructorMemberSubIndex=-1;
            pobj_c->DestructorMemberSubIndex=-1;

            //アクセス制限の初期値をセット
            if(dwClassType==ESC_CLASS) dwAccess=ACCESS_PRIVATE;
            else dwAccess=ACCESS_PUBLIC;

            if( lstrcmp( pobj_c->name, "Object" ) == 0 || dwClassType == ESC_TYPE ){
                //継承無し
                pobj_c->pobj_InheritsClass=0;

                //仮想関数の数を初期化
                pobj_c->vtbl_num=0;
            }
            else{
                if(basbuf[i+1]==1&&basbuf[i+2]==ESC_INHERITS){
                    //継承を行う場合
                    for(i+=3,i2=0;;i++,i2++){
                        if(IsCommandDelimitation(basbuf[i])){
                            temporary[i2]=0;
                            break;
                        }
                        temporary[i2]=basbuf[i];
                    }

                    if(lstrcmpi(temporary,pobj_c->name)==0){
                        SetError(105,temporary,i);
                        goto InheritsError;
                    }
                }
                else{
                    //Objectを継承する
                    lstrcpy( temporary, "Object" );
                }

                //継承元クラスを取得
                CClass *pInheritsClass = check(temporary);
                if( !pInheritsClass ){
                    SetError(106,temporary,i);
                    goto InheritsError;
                }

                //ループ継承でないかをチェック
                if(pobj_LoopRefCheck->check(temporary)){
                    SetError(123,temporary,i);
                    goto InheritsError;
                }

                if( pInheritsClass->ppobj_Member == 0 ){
                    //継承先が読み取られていないとき
                    pobj_LoopRefCheck->add(pobj_c->name);
                    GetClass_recur(temporary);
                    pobj_LoopRefCheck->del(pobj_c->name);
                }

                //継承させる
                pobj_c->Inherits( pInheritsClass );
            }
InheritsError:

            //メンバとメソッドを取得
            while(1){
                i++;

                //エラー
                if(basbuf[i]==1&&(basbuf[i+1]==ESC_CLASS||basbuf[i+1]==ESC_TYPE)){
                    SetError(22,"Class",i);
                    i--;
                    break;
                }

                if(basbuf[i]==1&&basbuf[i+1]==ESC_INHERITS){
                    SetError(111,NULL,i);
                    break;
                }

                //Static修飾子
                BOOL bStatic;
                if(basbuf[i]==1&&basbuf[i+1]==ESC_STATIC){
                    bStatic=1;
                    i+=2;
                }
                else bStatic=0;

                //Const修飾子
                bool isConst = false;
                if( basbuf[i] == 1 && basbuf[i + 1] == ESC_CONST ){
                    isConst = true;
                    i += 2;
                }

                //Ref修飾子
                bool isRef = false;
                if( basbuf[i] == 1 && basbuf[i + 1] == ESC_BYREF ){
                    isRef = true;
                    i += 2;
                }

                if(basbuf[i]==1&&(
                    basbuf[i+1]==ESC_ABSTRACT||basbuf[i+1]==ESC_VIRTUAL||basbuf[i+1]==ESC_OVERRIDE||
                    basbuf[i+1]==ESC_SUB||basbuf[i+1]==ESC_FUNCTION
                    )){
                    i3=basbuf[i+1];
                    sub_address=i;
                }
                else i3=0;

                BOOL bVirtual=0,bAbstract=0,bOverride=0;
                if(i3==ESC_ABSTRACT){
                    bAbstract=1;
                    bVirtual=1;
                    i+=2;

                    i3=basbuf[i+1];
                }
                else if(i3==ESC_VIRTUAL){
                    bAbstract=0;
                    bVirtual=1;
                    i+=2;

                    i3=basbuf[i+1];
                }
                else if(i3==ESC_OVERRIDE){
                    bOverride=1;
                    bVirtual=1;

                    i+=2;

                    i3=basbuf[i+1];
                }

                for(i2=0;;i++,i2++){
                    if(IsCommandDelimitation(basbuf[i])){
                        temporary[i2]=0;
                        break;
                    }
                    temporary[i2]=basbuf[i];
                }
                if(temporary[0]=='\0'){
                    if(basbuf[i]=='\0'){

                        if(dwClassType==ESC_CLASS)
                            SetError(22,"Class",top_pos);
                        else
                            SetError(22,"Type",top_pos);

                        i--;
                        break;
                    }
                    continue;
                }

                //End Class記述の場合
                if(temporary[0]==1&&temporary[1]==ESC_ENDCLASS&&dwClassType==ESC_CLASS) break;
                if(temporary[0]==1&&temporary[1]==ESC_ENDTYPE&&dwClassType==ESC_TYPE) break;

                //アクセスを変更
                if(lstrcmpi(temporary,"Private")==0){
                    dwAccess=ACCESS_PRIVATE;
                    continue;
                }
                if(lstrcmpi(temporary,"Public")==0){
                    dwAccess=ACCESS_PUBLIC;
                    continue;
                }
                if(lstrcmpi(temporary,"Protected")==0){
                    dwAccess=ACCESS_PROTECTED;
                    continue;
                }

                extern int cp;
                if(i3==0){
                    if(bStatic){
                        //静的メンバを追加
                        cp=i;   //エラー用
                        pobj_c->AddStaticMember( dwAccess, isConst, isRef, temporary, i);
                    }
                    else{
                        //メンバを追加
                        cp=i;   //エラー用
                        pobj_c->AddMember( dwAccess, isConst, isRef, temporary );


                        if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_OBJECT){
                            if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.u.pobj_Class->ppobj_Member==0){
                                //参照先が読み取られていないとき
                                GetClass_recur(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.u.pobj_Class->name);
                            }
                        }


                        if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_OBJECT){
                            //循環参照のチェック
                            pobj_LoopRefCheck->add(pobj_c->name);
                            if(!MemberVar_LoopRefCheck(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.u.pobj_Class)){
                                //エラー回避
                                pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type=DEF_PTR_VOID;
                            }
                            pobj_LoopRefCheck->del(pobj_c->name);
                        }
                    }
                }
                else{
                    // 文法エラーチェック
                    if( isRef ){
                        SetError(1,NULL,cp);
                    }

                    //メソッドを追加
                    cp=i;   //エラー用
                    AddMethod(pobj_c,
                        dwAccess,
                        bStatic,
                        isConst,
                        bAbstract,
                        bVirtual,
                        bOverride,
                        temporary,
                        sub_address);

                    if(bAbstract) continue;

                    for(;;i++){
                        if(basbuf[i]=='\0'){
                            i--;
                            break;
                        }
                        if(basbuf[i-1]!='*'&&
                            basbuf[i]==1&&(
                            basbuf[i+1]==ESC_SUB||
                            basbuf[i+1]==ESC_FUNCTION||
                            basbuf[i+1]==ESC_MACRO||
                            basbuf[i+1]==ESC_TYPE||
                            basbuf[i+1]==ESC_CLASS||
                            basbuf[i+1]==ESC_INTERFACE||
                            basbuf[i+1]==ESC_ENUM)){
                            GetDefaultNameFromES(i3,temporary);
                            SetError(22,temporary,i);
                        }
                        if(basbuf[i]==1&&basbuf[i+1]==GetEndXXXCommand((char)i3)){
                            i+=2;
                            break;
                        }
                    }
                }
            }
        }
    }
}

void CDBClass::GetObjectClassInfo(void){
    //ループ継承チェック用のクラス
    pobj_LoopRefCheck=new CLoopRefCheck();

    //クラスを取得
    GetClass_recur(0);

    delete pobj_LoopRefCheck;
    pobj_LoopRefCheck=0;
}

void CDBClass::StartCompile( SUBINFO *psi ){
    pCompilingClass = psi->pobj_ParentClass;
    if( pCompilingClass ){
        pCompilingMethod = pCompilingClass->GetMethodInfo( psi );
        if( !pCompilingMethod ){
            pCompilingMethod = pCompilingClass->GetStaticMethodInfo( psi );
            if( !pCompilingMethod ){
                SetError(300,NULL,cp);
            }
        }
    }
    else{
        pCompilingMethod = NULL;
    }
}
CClass *CDBClass::GetNowCompilingClass(){
    return pCompilingClass;
}
CMethod *CDBClass::GetNowCompilingMethodInfo(){
    return pCompilingMethod;
}




//////////////////////
// イテレータ
//////////////////////

void CDBClass::Iterator_Reset(void){
    if(ppobj_IteClass) HeapDefaultFree(ppobj_IteClass);

    iIteMaxNum=0;
    iIteNextNum=0;
    ppobj_IteClass=(CClass **)HeapAlloc(hHeap,0,1);

    int i;
    for(i=0;i<MAX_CLASS_HASH;i++){
        if(pobj_ClassHash[i]){
            CClass *pobj_c;
            pobj_c=pobj_ClassHash[i];
            while(1){
                ppobj_IteClass=(CClass **)HeapReAlloc(hHeap,0,ppobj_IteClass,(iIteMaxNum+1)*sizeof(CClass *));
                ppobj_IteClass[iIteMaxNum]=pobj_c;
                iIteMaxNum++;

                if(pobj_c->pobj_NextClass==0) break;
                pobj_c=pobj_c->pobj_NextClass;
            }
        }
    }
}
BOOL CDBClass::Iterator_HasNext(void){
    if(iIteNextNum<iIteMaxNum) return 1;
    return 0;
}
CClass *CDBClass::Iterator_GetNext(void){
    CClass *pobj_c;
    pobj_c=ppobj_IteClass[iIteNextNum];
    iIteNextNum++;
    return pobj_c;
}
int CDBClass::Iterator_GetMaxCount(void){
    return iIteMaxNum;
}