source: dev/trunk/abdev/BasicCompiler_Common/src/Class.cpp@ 353

#include "stdafx.h"

#include <jenga/include/smoothie/Smoothie.h>
#include <jenga/include/smoothie/SmoothieException.h>
#include <jenga/include/smoothie/LexicalAnalysis.h>

#include <Source.h>
#include <Class.h>
#include <Compiler.h>
#include <NamespaceSupporter.h>

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


class CLoopRefCheck{
    char **names;
    int num;
    void init(){
        int i;
        for(i=0;i<num;i++){
            free(names[i]);
        }
        free(names);
    }
public:
    CLoopRefCheck()
    {
        names=(char **)malloc(1);
        num=0;
    }
    ~CLoopRefCheck()
    {
        init();
    }
    void add(const char *lpszInheritsClass)
    {
        names=(char **)realloc(names,(num+1)*sizeof(char *));
        names[num]=(char *)malloc(lstrlen(lpszInheritsClass)+1);
        lstrcpy(names[num],lpszInheritsClass);
        num++;
    }
    void del(const char *lpszInheritsClass)
    {
        int i;
        for(i=0;i<num;i++){
            if(lstrcmp(names[i],lpszInheritsClass)==0){
                free(names[i]);
                break;
            }
        }
        if(i!=num){
            num--;
            for(;i<num;i++){
                names[i]=names[i+1];
            }
        }
    }
    BOOL check(const CClass &inheritsClass) const
    {
        //ループ継承チェック
        int i;
        for(i=0;i<num;i++){
            if( inheritsClass.GetName() == names[i] ){
                return 1;
            }
        }
        return 0;
    }
};
CLoopRefCheck *pobj_LoopRefCheck;


Interface::Interface( const CClass *pInterfaceClass )
    : DynamicMethodsPrototype()
    , pInterfaceClass( pInterfaceClass )
    , vtblOffset( -1 )
{
    //メソッドをコピー
    BOOST_FOREACH( const CMethod *pBaseMethod, pInterfaceClass->GetDynamicMethods() )
    {
        CMethod *pMethod = new DynamicMethod( *pBaseMethod );

        // アクセシビリティ
        if(pBaseMethod->GetAccessibility() == Prototype::Private){
            pMethod->SetAccessibility( Prototype::None );
        }
        else{
            pMethod->SetAccessibility( pBaseMethod->GetAccessibility() );
        }

        //pobj_Inherits
        // ※継承元のClassIndexをセット（入れ子継承を考慮する）
        if(pBaseMethod->GetInheritsClassPtr()==0){
            pMethod->SetInheritsClassPtr( pInterfaceClass );
        }
        else{
            pMethod->SetInheritsClassPtr( pBaseMethod->GetInheritsClassPtr() );
        }

        AddDynamicMethods( pMethod );
    }
}


bool CClass::IsClass() const
{
    return classType == CClass::Class;
}
bool CClass::IsInterface() const
{
    return classType == CClass::Interface;
}
bool CClass::IsEnum() const
{
    return classType == CClass::Enum;
}
bool CClass::IsDelegate() const
{
    return classType == CClass::Delegate;
}
bool CClass::IsStructure() const
{
    return classType == CClass::Structure;
}


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

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

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

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

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

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

//自身の派生クラスかどうかを確認
bool CClass::IsSubClass( const CClass *pClass ) const
{
    if( !pClass->HasSuperClass() )
    {
        return false;
    }

    const CClass *pTempClass = &pClass->GetSuperClass();
    while( pTempClass ){
        if( this == pTempClass ) return true;
        pTempClass = &pTempClass->GetSuperClass();
    }
    return false;
}

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

// 自身と等しいまたは派生クラス、基底クラスかどうかを確認
bool CClass::IsEqualsOrSubClassOrSuperClass( const CClass &objClass ) const
{
    if( IsEquals( &objClass ) ) return true;
    if( IsSubClass( &objClass ) ) return true;
    if( objClass.IsSubClass( this ) ) return true;
    return false;
}

bool CClass::IsInheritsInterface( const CClass *pInterfaceClass ) const
{
    BOOST_FOREACH( const ::Interface *pInterface, interfaces ){
        if( pInterfaceClass == &pInterface->GetClass() ){
            return true;
        }
    }
    return false;
}

bool CClass::Inherits( const char *inheritNames, int nowLine ){
    int i = 0;
    bool isInheritsClass = false;
    while( true ){

        char temporary[VN_SIZE];
        for( int i2=0;; i++, i2++ ){
            if( inheritNames[i] == '\0' || inheritNames[i] == ',' ){
                temporary[i2] = 0;
                break;
            }
            temporary[i2] = inheritNames[i];
        }

        // ジェネリクス構文を分解
        char className[VN_SIZE];
        Jenga::Common::Strings typeParameterStrings;
        SplitGenericClassInstance( temporary, className, typeParameterStrings );

        // 型パラメータ文字列から型データを取得
        std::vector<Type> actualTypeParameters;
        BOOST_FOREACH( const std::string &typeParameterStr, typeParameterStrings )
        {
            Type type;
            compiler.StringToType( typeParameterStr, type );
            actualTypeParameters.push_back( type );
        }

        //継承元クラスを取得
        const CClass *pInheritsClass = compiler.GetObjectModule().meta.GetClasses().Find(className);
        if( !pInheritsClass ){
            SmoothieException::Throw(106,className,nowLine);
            return false;
        }

        if( pInheritsClass->IsInterface() ){
            // インターフェイスはあとで継承する
        }
        else if( pInheritsClass->IsClass() ){
            // クラスを継承する
            isInheritsClass = true;

            if( !InheritsClass( *pInheritsClass, actualTypeParameters, nowLine ) ){
                return false;
            }
        }
        else{
            SmoothieException::Throw(135,NULL,nowLine);
            return false;
        }

        if( inheritNames[i] == '\0' ){
            break;
        }
        i++;
    }

    if( !isInheritsClass ){
        // クラスを一つも継承していないとき
        if( !InheritsClass( *compiler.GetObjectModule().meta.GetClasses().GetObjectClassPtr(), Types(), nowLine ) ){
            return false;
        }
    }

    i=0;
    while( true ){

        char temporary[VN_SIZE];
        for( int i2=0;; i++, i2++ ){
            if( inheritNames[i] == '\0' || inheritNames[i] == ',' ){
                temporary[i2] = 0;
                break;
            }
            temporary[i2] = inheritNames[i];
        }

        char className[VN_SIZE];
        Jenga::Common::Strings typeParameters;
        SplitGenericClassInstance( temporary, className, typeParameters );

        //継承元クラスを取得
        const CClass *pInheritsClass = compiler.GetObjectModule().meta.GetClasses().Find(className);
        if( !pInheritsClass ){
            SmoothieException::Throw(106,className,nowLine);
            return false;
        }

        if( pInheritsClass->IsInterface() ){
            // インターフェイスを継承する
            if( !InheritsInterface( *pInheritsClass, nowLine ) ){
                return false;
            }
        }
        else if( pInheritsClass->IsClass() ){
            // クラスはさっき継承した
        }
        else{
            SmoothieException::Throw(135,NULL,nowLine);
            return false;
        }

        if( inheritNames[i] == '\0' ){
            break;
        }
        i++;
    }

    return true;
}
bool CClass::InheritsClass( const CClass &inheritsClass, const Types &actualTypeParameters, int nowLine ){

    //ループ継承でないかをチェック
    if(pobj_LoopRefCheck->check(inheritsClass)){
        SmoothieException::Throw(123,inheritsClass.GetName(),nowLine);
        return false;
    }

    if( !inheritsClass.IsReady() ){
        //継承先が読み取られていないとき
        pobj_LoopRefCheck->add(this->GetName().c_str());
        compiler.GetObjectModule().meta.GetClasses().GetClass_recur(inheritsClass.GetName().c_str());
        pobj_LoopRefCheck->del(this->GetName().c_str());
    }

    //メンバをコピー
    BOOST_FOREACH( CMember *inheritsClassDynamicMember, inheritsClass.GetDynamicMembers() ){
        CMember *pMember = new CMember( *inheritsClassDynamicMember );

        // アクセシビリティ
        if( inheritsClassDynamicMember->IsPrivate() ){
            pMember->SetAccessibility( Prototype::None );
        }
        else{
            pMember->SetAccessibility( inheritsClassDynamicMember->GetAccessibility() );
        }

        // メンバのみ、型パラメータを解決する（メソッドのほうは呼び出し時に解決する）
        if( pMember->GetType().IsTypeParameter() )
        {
            pMember->ResetType( actualTypeParameters[pMember->GetType().GetFormalTypeIndex()] );
        }

        dynamicMembers.push_back( pMember );
    }

    //メソッドをコピー
    BOOST_FOREACH( const CMethod *pBaseMethod, inheritsClass.GetDynamicMethods() ){
        CMethod *pMethod = new DynamicMethod( *pBaseMethod );

        // アクセシビリティ
        if(pBaseMethod->GetAccessibility() == Prototype::Private){
            pMethod->SetAccessibility( Prototype::None );
        }
        else{
            pMethod->SetAccessibility( pBaseMethod->GetAccessibility() );
        }

        //pobj_Inherits
        // ※継承元のClassIndexをセット（入れ子継承を考慮する）
        if(pBaseMethod->GetInheritsClassPtr()==0){
            pMethod->SetInheritsClassPtr( &inheritsClass );
        }
        else{
            pMethod->SetInheritsClassPtr( pBaseMethod->GetInheritsClassPtr() );
        }

        GetDynamicMethods().push_back( pMethod );
    }

    //仮想関数の数
    AddVtblNum( inheritsClass.GetVtblNum() );

    //継承先のクラスをメンバとして保持する
    SetSuperClass( &inheritsClass );
    SetSuperClassActualTypeParameters( actualTypeParameters );

    // インターフェイスを引き継ぐ
    BOOST_FOREACH( ::Interface *pInterface, inheritsClass.GetInterfaces() )
    {
        interfaces.push_back( new ::Interface( *pInterface ) );
    }

    return true;
}
bool CClass::InheritsInterface( const CClass &inheritsInterface, int nowLine ){

    //ループ継承でないかをチェック
    if(pobj_LoopRefCheck->check(inheritsInterface)){
        SmoothieException::Throw(123,inheritsInterface.GetName(),nowLine);
        return false;
    }

    if( !inheritsInterface.IsReady() ){
        //継承先が読み取られていないとき
        pobj_LoopRefCheck->add(this->GetName().c_str());
        compiler.GetObjectModule().meta.GetClasses().GetClass_recur(inheritsInterface.GetName().c_str());
        pobj_LoopRefCheck->del(this->GetName().c_str());
    }

    //メソッドをコピー
    BOOST_FOREACH( const CMethod *pBaseMethod, inheritsInterface.GetDynamicMethods() ){
        CMethod *pMethod = new DynamicMethod( *pBaseMethod );

        // アクセシビリティ
        if(pBaseMethod->GetAccessibility() == Prototype::Private){
            pMethod->SetAccessibility( Prototype::None );
        }
        else{
            pMethod->SetAccessibility( pBaseMethod->GetAccessibility() );
        }

        //pobj_Inherits
        // ※継承元のClassIndexをセット（入れ子継承を考慮する）
        if(pBaseMethod->GetInheritsClassPtr()==0){
            pMethod->SetInheritsClassPtr( &inheritsInterface );
        }
        else{
            pMethod->SetInheritsClassPtr( pBaseMethod->GetInheritsClassPtr() );
        }

        GetDynamicMethods().push_back( pMethod );
    }

    //interfaces.push_back( Interface( &inheritsInterface, vtblNum ) );

    //仮想関数の数
    AddVtblNum( inheritsInterface.GetVtblNum() );

    return true;
}

bool CClass::Implements( const CClass &interfaceClass, int nowLine )
{
    if( !interfaceClass.IsInterface() )
    {
        // インターフェイスではないとき
        SetError(138,interfaceClass.GetName().c_str(),nowLine );
        return false;
    }

    if( !interfaceClass.IsReady() ){
        // インターフェイスが未解析のとき
        pobj_LoopRefCheck->add(this->GetName().c_str());
        compiler.GetObjectModule().meta.GetClasses().GetClass_recur(interfaceClass.GetName().c_str());
        pobj_LoopRefCheck->del(this->GetName().c_str());
    }

    ::Interface *pDestInterface = new ::Interface( &interfaceClass );

    interfaces.push_back( pDestInterface );


    /////////////////////////////////////////////////////////////////
    // 基底クラスのメソッドからインターフェイスメソッドを再実装する
    /////////////////////////////////////////////////////////////////
    BOOST_FOREACH( CMethod *pMethod, GetDynamicMethods() )
    {
        CMethod *pMethodForOverride = pDestInterface->GetDynamicMethods().FindForOverride( &pMethod->GetUserProc() );
        if( pMethodForOverride )
        {
            pMethodForOverride->Override( &pMethod->GetUserProc(), pMethod->GetAccessibility(), false );

            // 実装元になるメソッドは呼び出し不可にしておく（オーバーロードの解決から除外する）
            pMethod->SetNotUseMark( true );
        }
    }


    /////////////////////////////////////////////////////////////////
    // キャストメソッドを追加（内部コードは自動生成すること）
    /////////////////////////////////////////////////////////////////
    {
        // Function Operator() As ITest

        char temporary[1024];
        sprintf(temporary,"%c%c%c%c()%c%c%s",
            1, ESC_FUNCTION,
            1, ESC_OPERATOR,
            1, ESC_AS,
            interfaceClass.GetName().c_str()
        );

        this->AddMethod(this,
            Prototype::Public,
            0,
            false,          // isConst
            false,          // isAbstract
            false,          // isVirtual
            false,          // isOverride
            true,           // isAutoGeneration
            temporary,
            -1
        );
    }


    return true;
}
bool CClass::Implements( const char *interfaceNames, int nowLine )
{
    Jenga::Common::Strings paramStrs;
    SplitParameter( interfaceNames, paramStrs );
    
    BOOST_FOREACH( const std::string &paramStr, paramStrs )
    {
        //継承元クラスを取得
        const CClass *pInterfaceClass = compiler.GetObjectModule().meta.GetClasses().Find( paramStr.c_str() );
        if( !pInterfaceClass ){
            SetError(106,paramStr.c_str(),nowLine);
            continue;
        }

        // インターフェイスを継承する
        Implements( *pInterfaceClass, nowLine );
    }

    return true;
}

CMember *CClass::CreateMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine )
{
    extern int cp;

    //構文を解析
    char VarName[VN_SIZE];
    char initBuffer[VN_SIZE];
    char lpszConstructParameter[VN_SIZE];
    Subscripts subscripts;
    Type type;
    GetDimentionFormat(buffer,VarName,subscripts,type,initBuffer,lpszConstructParameter);

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

    CMember *pMember = new CMember( accessibility, VarName, type, isConst, subscripts, initBuffer, lpszConstructParameter );
    pMember->source_code_address = nowLine;
    return pMember;
}
void CClass::AddMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine ){
    dynamicMembers.push_back(
        CreateMember( accessibility, isConst, isRef, buffer, nowLine )
    );
}
void CClass::AddStaticMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine ){
    staticMembers.push_back(
        CreateMember( accessibility, isConst, isRef, buffer, nowLine )
    );
}

void CClass::AddMethod(CClass *pobj_c, Prototype::Accessibility accessibility, BOOL bStatic, bool isConst, bool isAbstract,
                         bool isVirtual, bool isOverride, bool isAutoGeneration, 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];
    }


    //関数ハッシュへ登録
    char interfaceName[VN_SIZE] = "";
    UserProc *pUserProc = compiler.GetObjectModule().meta.GetUserProcs().AddUserProc( NamespaceScopes(), NamespaceScopesCollection(), buffer,nowLine,isVirtual,pobj_c, (bStatic!=0), interfaceName );
    if(!pUserProc) return;

    if( isAutoGeneration )
    {
        // コード自動生成
        pUserProc->ThisIsAutoGenerationProc();
    }


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

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

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

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

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

    if( fConstructor == 1 )
        pobj_c->SetConstructorMemberSubIndex( (int)pobj_c->GetDynamicMethods().size() );
    else if( bDestructor )
        pobj_c->SetDestructorMemberSubIndex( (int)pobj_c->GetDynamicMethods().size() );



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

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

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

        if( pMethod->GetUserProc().IsEqualForOverride( pUserProc ) )
        {
            //関数名、パラメータ、戻り値が合致したとき
            SetError(15,pUserProc->GetName().c_str(),nowLine);
            return;
        }
    }

    //仮想関数の場合
    if( isAbstract ) pUserProc->CompleteCompile();

    // メソッドのオーバーライド
    CMethod *pMethodForOverride = pobj_c->GetDynamicMethods().FindForOverride( pUserProc );
    if( pMethodForOverride )
    {
        pMethodForOverride->Override( pUserProc, accessibility, isOverride );
        pUserProc->SetMethod( pMethodForOverride );
        return;
    }
    else
    {
        // インターフェイス メソッドのオーバーライド
        BOOST_FOREACH( ::Interface *pInterface, pobj_c->GetInterfaces() )
        {
            if( interfaceName[0] )
            {
                if( pInterface->GetClass().GetName() != interfaceName )
                {
                    // 指定されたインターフェイス名と整合しないとき
                    continue;
                }
            }

            CMethod *pMethodForOverride = pInterface->GetDynamicMethods().FindForOverride( pUserProc );
            if( pMethodForOverride )
            {
                pMethodForOverride->Override( pUserProc, accessibility, isOverride );
                pUserProc->SetMethod( pMethodForOverride );
                return;
            }
        }
    }

    if( interfaceName[0] )
    {
        SetError(139,interfaceName,nowLine);
    }

    if( isVirtual ){
        pobj_c->AddVtblNum( 1 );
    }

    if( isOverride ){
        SetError(12,"Override",nowLine);
    }

    if(bStatic){
        pobj_c->GetStaticMethods().AddStatic( pUserProc, accessibility );
    }
    else{
        pobj_c->GetDynamicMethods().Add(pUserProc, accessibility, isConst, isAbstract, isVirtual);
    }
}

bool CClass::DupliCheckAll(const char *name){
    //重複チェック

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

    //メソッド
    BOOST_FOREACH( const CMethod *pMethod, GetDynamicMethods() ){
        if( lstrcmp( name, pMethod->GetUserProc().GetName().c_str() ) == 0 ){
            return 1;
        }
    }

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

    // 動的メンバ
    BOOST_FOREACH( CMember *pMember, dynamicMembers ){
        if( GetName() == pMember->GetName() ){
            return 1;
        }
    }

    // 静的メンバ
    BOOST_FOREACH( CMember *pMember, staticMembers ){
        if( GetName() == pMember->GetName() ){
            return 1;
        }
    }

    return 0;
}

void CClass::EnumDynamicMethodsOrInterfaceMethods( const char *methodName, std::vector<const UserProc *> &subs ) const
{
    // 動的メソッド
    GetDynamicMethods().Enum( methodName, subs );

    // インターフェイス メソッド
    BOOST_FOREACH( ::Interface *pInterface, GetInterfaces() )
    {
        pInterface->GetDynamicMethods().Enum( methodName, subs );
    }
}
const CMethod *CClass::GetDynamicMethodOrInterfaceMethod( const UserProc *pUserProc ) const
{
    // 動的メソッド
    const CMethod *result = GetDynamicMethods().GetMethodPtr( pUserProc );

    if( !result )
    {
        // インターフェイス メソッド
        BOOST_FOREACH( ::Interface *pInterface, GetInterfaces() )
        {
            result = pInterface->GetDynamicMethods().GetMethodPtr( pUserProc );
            if( result )
            {
                return result;
            }
        }
    }

    return result;
}

const ::Delegate &CClass::GetDelegate() const
{
    const ::Delegate *dg = compiler.GetObjectModule().meta.GetDelegates().GetHashArrayElement( GetName().c_str() );
    while( dg )
    {
        if( dg->IsEqualSymbol( GetNamespaceScopes(), GetName() ) ){
            //名前空間とクラス名が一致した
            return *dg;
        }
        dg = dg->GetChainNext();
    }

    Jenga::Throw( "CClass::GetDelegateメソッドに失敗" );
    static ::Delegate dummy;
    return dummy;
}

//サイズを取得
int CClass::GetSize() const
{
    return GetMemberOffset( NULL, NULL );
}

//メンバのオフセットを取得
int CClass::GetMemberOffset( const char *memberName, int *pMemberNum ) const
{
    int i2;

    //仮想関数が存在する場合は関数リストへのポインタのサイズを追加
    int offset = IsExistVirtualFunctions() ? PTR_SIZE : 0;

    int alignment = 1;
    if( GetFixedAlignment() )
    {
        alignment = GetFixedAlignment();
    }

    int iMaxAlign=0;
    int i = -1;
    BOOST_FOREACH( CMember *pMember, dynamicMembers ){
        i++;

        i2 = pMember->GetType().GetSize();

        //アラインメントを算出
        int member_size;
        if( pMember->GetType().IsStruct() ){
            //メンバクラスのアラインメントを取得
            member_size=pMember->GetType().GetClass().GetAlignment();
        }
        else{
            //メンバサイズを取得
            member_size=i2;
        }
        if(iMaxAlign<member_size) iMaxAlign=member_size;

        //アラインメントを考慮
        if(GetFixedAlignment()&&GetFixedAlignment()<member_size){
            if(offset%alignment) offset+=alignment-(offset%alignment);
        }
        else{
            if(alignment<member_size) alignment=member_size;

            if(member_size==0){
                //メンバを持たないクラス
                //※何もしない（オフセットの計算をしない）
            }
            else{
                if(offset%member_size) offset+=member_size-(offset%member_size);
            }
        }

        if(memberName){
            //メンバ指定がある場合は、オフセットを返す
            if( pMember->GetName() == memberName ){
                if(pMemberNum) *pMemberNum=i;
                return offset;
            }
        }

        //配列を考慮したメンバサイズを取得
        member_size = i2 * Variable::GetSubScriptCounts( pMember->GetSubscripts() );

        //メンバサイズを加算
        offset+= member_size;
    }

    if(iMaxAlign<alignment) alignment=iMaxAlign;

    //アラインメントを考慮
    if(alignment){
        if(offset%alignment) offset+=alignment-(offset%alignment);
    }

    if(pMemberNum) *pMemberNum=i;
    return offset;
}
int CClass::GetAlignment() const
{
    //仮想関数が存在する場合は関数リストへのポインタのサイズを追加
    int alignment = IsExistVirtualFunctions() ? PTR_SIZE : 0;

    BOOST_FOREACH( CMember *pMember, dynamicMembers ){
        int member_size;
        if(pMember->GetType().IsStruct()){
            //メンバクラスのアラインメントを取得
            member_size=pMember->GetType().GetClass().GetAlignment();
        }
        else{
            //メンバサイズを取得
            member_size = pMember->GetType().GetSize();
        }

        //アラインメントをセット
        if(alignment<member_size) alignment=member_size;
    }

    if(alignment==0) return 0;

    if(GetFixedAlignment()) alignment=GetFixedAlignment();

    return alignment;
}

void CClass::GetVtblMasterListIndexAndVtblIndex( const UserProc *pUserProc, int &vtblMasterListIndex, int &vtblIndex ) const
{
    vtblMasterListIndex = 0;

    vtblIndex = 0;
    BOOST_FOREACH( const CMethod *pMethod, GetDynamicMethods() ){
        if( &pMethod->GetUserProc() == pUserProc )
        {
            return;
        }

        if( pMethod->IsVirtual() )
        {
            vtblIndex++;
        }
    }

    BOOST_FOREACH( const ::Interface *pInterface, interfaces )
    {
        vtblMasterListIndex++;

        vtblIndex = 0;
        BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
            if( &pMethod->GetUserProc() == pUserProc )
            {
                return;
            }

            if( pMethod->IsVirtual() )
            {
                vtblIndex++;
            }
        }
    }

    SetError();
    return;
}
int CClass::GetVtblMasterListIndex( const CClass *pClass ) const
{
    int result = 0;

    BOOST_FOREACH( const ::Interface *pInterface, interfaces )
    {
        result++;
        
        if( &pInterface->GetClass() == pClass )
        {
            return result;
        }
    }

    SetError();
    return 0;
}
long CClass::GetVtblMasterListOffset() const
{
    //既に存在する場合はそれを返す
    if( vtblMasterListOffset == -1 )
    {
        SetError();
    }

    return vtblMasterListOffset;
}
void CClass::GenerateVTableMasterList( const std::vector<long> &vtableMasterList, long &offset )
{
    offset = compiler.GetObjectModule().dataTable.AddBinary(
        (void *)&vtableMasterList[0],
        static_cast<int>(vtableMasterList.size()*sizeof(LONG_PTR))
    );
}
void CClass::GenerateFullVTables()
{
    if( IsAbstract() )
    {
        // 抽象クラスは無視
        return;
    }
    if( !IsUsing() )
    {
        // 使われていないクラスは無視
        return;
    }

    // vtblマスターリストの元データに不要なデータが含まれていたらエラー
    if( vtblMasterList.size() )
    {
        SetError();
    }

    // 自身のクラスのvtblを生成
    GetDynamicMethods().GenerateVTablePart( this->vtbl_offset );
    vtblMasterList.push_back( this->vtbl_offset );

    // インターフェイスのvtblを生成
    BOOST_FOREACH( const ::Interface *pInterface, interfaces )
    {
        long tempVtblOffset;
        pInterface->GetDynamicMethods().GenerateVTablePart( tempVtblOffset );
        vtblMasterList.push_back( tempVtblOffset );

        pInterface->SetVtblOffset( tempVtblOffset );
    }

    // vtblマスターリストを生成
    GenerateVTableMasterList( vtblMasterList, this->vtblMasterListOffset );
}
void CClass::ActionVtblSchedule( LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection, LONG_PTR MemPos_DataSection )
{
    if( IsAbstract() )
    {
        // 抽象クラスは無視
        return;
    }
    if( !IsUsing() )
    {
        // 使われていないクラスは無視
        return;
    }
    if(vtbl_offset==-1) return;

    // 自身のクラスのvtbl
    {
        LONG_PTR *pVtbl = (LONG_PTR *)((char *)compiler.GetObjectModule().dataTable.GetPtr() + vtbl_offset);

        for( int i=0; i<GetVtblNum(); i++ ){
            const UserProc *pUserProc = (UserProc *)pVtbl[i];
            if(!pUserProc) continue;

            if( pUserProc->GetBeginOpAddress() == 0
                && pUserProc->GetEndOpAddress() == 0 )
            {
                Jenga::Throw( "未解決の仮想関数が存在する" );
            }

            pVtbl[i] = pUserProc->GetBeginOpAddress() + ImageBase + MemPos_CodeSection;
        }
    }

    // インターフェイスのvtbl
    BOOST_FOREACH( const ::Interface *pInterface, interfaces )
    {
        LONG_PTR *pVtbl = (LONG_PTR *)((char *)compiler.GetObjectModule().dataTable.GetPtr() + pInterface->GetVtblOffset());

        for( int i=0; i<pInterface->GetClass().GetVtblNum(); i++ ){
            const UserProc *pUserProc = (UserProc *)pVtbl[i];
            if(!pUserProc) continue;

            if( pUserProc->GetBeginOpAddress() == 0
                && pUserProc->GetEndOpAddress() == 0 )
            {
                Jenga::Throw( "未解決の仮想関数が存在する" );
            }

            pVtbl[i] = pUserProc->GetBeginOpAddress() + ImageBase + MemPos_CodeSection;
        }
    }

    // vtblマスターリスト
    LONG_PTR *pVtblMasterList = (LONG_PTR *)((char *)compiler.GetObjectModule().dataTable.GetPtr() + vtblMasterListOffset );
    for( int i=0; i<static_cast<int>(vtblMasterList.size()); i++ )
    {
        pVtblMasterList[i] = vtblMasterList[i] + ImageBase + MemPos_DataSection;
    }
}
bool CClass::IsAbstract() const
{
    // 未実装(abstract)の仮想関数を持つ場合はtrueを返す

    BOOST_FOREACH( const CMethod *pMethod, GetDynamicMethods() ){
        if(pMethod->IsVirtual()){
            if(pMethod->IsAbstract()){
                return true;
            }
        }
    }

    // インターフェイスのvtbl
    BOOST_FOREACH( const ::Interface *pInterface, interfaces )
    {
        BOOST_FOREACH( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
            if(pMethod->IsVirtual()){
                if(pMethod->IsAbstract()){
                    return true;
                }
            }
        }
    }

    return false;
}

CClass *Classes::Create( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name){
    return new CClass(namespaceScopes, importedNamespaces, name);
}
bool Classes::Insert( CClass *pClass )
{
    /////////////////////////////////
    // ハッシュデータに追加
    /////////////////////////////////

    if( !Put( pClass ) )
    {
        SetError(15,pClass->GetName(), cp);
        return false;
    }
    return true;
}
CClass *Classes::Add( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name,int nowLine){
    //////////////////////////////////////////////////////////////////////////
    // クラスを追加
    // ※名前のみを登録。その他の情報はSetClassメソッドで！
    //////////////////////////////////////////////////////////////////////////

    CClass *pClass = Create(namespaceScopes, importedNamespaces, name);

    if( !Insert( pClass ) )
    {
        return NULL;
    }

    return pClass;  
}

void Classes::CollectClassesForNameOnly( const BasicSource &source )
{
    int i, i2;
    char temporary[VN_SIZE];

    // 名前空間管理
    NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
    namespaceScopes.clear();

    // Importsされた名前空間の管理
    NamespaceScopesCollection &importedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
    importedNamespaces.clear();

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

        if( source[i] == 1 && source[i+1] == ESC_NAMESPACE ){
            for(i+=2,i2=0;;i2++,i++){
                if( IsCommandDelimitation( source[i] ) ){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=source[i];
            }
            namespaceScopes.push_back( temporary );

            continue;
        }
        else if( source[i] == 1 && source[i+1] == ESC_ENDNAMESPACE ){
            if( namespaceScopes.size() <= 0 ){
                SmoothieException::Throw(12, "End Namespace", i );
            }
            else{
                namespaceScopes.pop_back();
            }

            i += 2;
            continue;
        }
        else if( source[i] == 1 && source[i+1] == ESC_IMPORTS ){
            for(i+=2,i2=0;;i2++,i++){
                if( IsCommandDelimitation( source[i] ) ){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=source[i];
            }
            if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
            {
                SmoothieException::Throw(64,temporary,i );
            }

            continue;
        }
        else if( source[i] == 1 && source[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
            importedNamespaces.clear();
            continue;
        }

        if(source[i]==1&&(
            source[i+1]==ESC_CLASS||
            source[i+1]==ESC_TYPE||
            source[i+1]==ESC_INTERFACE
            ))
        {
            int nowLine = i;
            i += 2;

            Type blittableType;
            if(memicmp(source.GetBuffer()+i,"Align(",6)==0){
                //アラインメント修飾子
                i+=6;
                i=JumpStringInPare(source.GetBuffer(),i)+1;
            }
            else if( memicmp( source.GetBuffer() + i, "Blittable(", 10 ) == 0 ){
                // Blittable修飾子
                i+=10;
                i+=GetStringInPare_RemovePare(temporary,source.GetBuffer()+i)+1;
                compiler.StringToType( temporary, blittableType );
            }

            bool isEnum = false;
            bool isDelegate = false;
            if( source[i] == 1 && source[i+1] == ESC_ENUM ){
                // 列挙型の場合
                isEnum = true;

                i += 2;
            }
            else if( source[i] == 1 && source[i+1] == ESC_DELEGATE )
            {
                // デリゲートの場合
                isDelegate = true;

                i += 2;
            }

            for(i2=0;;i++,i2++){
                if(!IsVariableChar(source[i])){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=source[i];
            }

            //クラスを追加
            CClass *pClass = this->Add(namespaceScopes, importedNamespaces, temporary,nowLine);
            if( pClass ){
                if( source[nowLine+1] == ESC_CLASS ){
                    if( isEnum )
                    {
                        pClass->SetClassType( CClass::Enum );
                    }
                    else if( isDelegate )
                    {
                        pClass->SetClassType( CClass::Delegate );
                    }
                    else{
                        pClass->SetClassType( CClass::Class );
                    }
                }
                else if( source[nowLine+1] == ESC_INTERFACE ){
                    pClass->SetClassType( CClass::Interface );
                }
                else{
                    pClass->SetClassType( CClass::Structure );
                }
            }

            // Blittable型の場合
            if( !blittableType.IsNull() ){
                pClass->SetBlittableType( blittableType );

                // Blittable型として登録
                compiler.GetObjectModule().meta.GetBlittableTypes().push_back( BlittableType( blittableType, pClass ) );
            }
        }
    }
}

void Classes::GenerateVTables()
{
    Iterator_Reset();
    while( Iterator_HasNext() )
    {
        CClass *pClass = Iterator_GetNext();
        pClass->GenerateFullVTables();
    }
}

void Classes::ActionVtblSchedule( LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection, LONG_PTR MemPos_DataSection ){
    Iterator_Reset();
    while( Iterator_HasNext() )
    {
        CClass *pClass = Iterator_GetNext();
        pClass->ActionVtblSchedule( ImageBase, MemPos_CodeSection, MemPos_DataSection);
    }
}


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

    //イテレータをリセット

    extern int cp;
    int back_cp=cp;

    this->Iterator_Reset();
    while(this->Iterator_HasNext()){
        CClass &objClass = *this->Iterator_GetNext();
        if( objClass.isTargetObjectModule == false )
        {
            // 静的リンクライブラリの場合は飛ばす（既にインスタンスが定義済みであるため）
            continue;
        }

        // 名前空間をセット
        compiler.GetNamespaceSupporter().GetLivingNamespaceScopes() = objClass.GetNamespaceScopes();

        int i=0;
        BOOST_FOREACH( CMember *member, objClass.GetStaticMembers() ){
            char temporary[VN_SIZE];
            sprintf(temporary,"%s.%s",objClass.GetName().c_str(),member->GetName().c_str());
            dim(
                temporary,
                member->GetSubscripts(),
                member->GetType(),
                member->GetInitializeExpression().c_str(),
                member->GetConstructParameter().c_str(),
                0);

            i++;
        }
    }

    compiler.GetNamespaceSupporter().GetLivingNamespaceScopes().clear();

    cp=back_cp;
}
bool Classes::MemberVar_LoopRefCheck(const CClass &objClass){
    bool result = true;
    BOOST_FOREACH( CMember *pMember, objClass.GetDynamicMembers() ){
        if(pMember->GetType().IsStruct()){
            //循環参照でないかをチェック
            if(pobj_LoopRefCheck->check(pMember->GetType().GetClass())){
                extern int cp;
                SetError(124,pMember->GetType().GetClass().GetName(),cp);
                return false;
            }

            pobj_LoopRefCheck->add(objClass.GetName().c_str());

            bool tempResult = MemberVar_LoopRefCheck(pMember->GetType().GetClass());
            if( result )
            {
                result = tempResult;
            }

            pobj_LoopRefCheck->del(objClass.GetName().c_str());
        }
    }

    return result;
}
void Classes::GetClass_recur(const char *lpszInheritsClass){
    extern char *basbuf;
    int i,i2,i3,sub_address,top_pos;
    char temporary[8192];

    // 名前空間管理
    NamespaceScopes backupNamespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
    NamespaceScopes &namespaceScopes = compiler.GetNamespaceSupporter().GetLivingNamespaceScopes();
    namespaceScopes.clear();

    // Importsされた名前空間の管理
    NamespaceScopesCollection backupImportedNamespaces = compiler.GetNamespaceSupporter().GetImportedNamespaces();
    compiler.GetNamespaceSupporter().GetImportedNamespaces().clear();

    // 呼び出し元でコンパイル中のクラスポインタをバックアップ
    const CClass *pBackCompilingClass = compiler.pCompilingClass;

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


        // 名前空間
        if( basbuf[i] == 1 && basbuf[i+1] == ESC_NAMESPACE ){
            for(i+=2,i2=0;;i2++,i++){
                if( IsCommandDelimitation( basbuf[i] ) ){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=basbuf[i];
            }
            namespaceScopes.push_back( temporary );

            continue;
        }
        else if( basbuf[i] == 1 && basbuf[i+1] == ESC_ENDNAMESPACE ){
            if( namespaceScopes.size() <= 0 ){
                SetError(12, "End Namespace", i );
            }
            else{
                namespaceScopes.pop_back();
            }

            i += 2;
            continue;
        }

        else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPORTS ){
            for(i+=2,i2=0;;i2++,i++){
                if( IsCommandDelimitation( basbuf[i] ) ){
                    temporary[i2]=0;
                    break;
                }
                temporary[i2]=basbuf[i];
            }
            if( !compiler.GetNamespaceSupporter().ImportsNamespace( temporary ) )
            {
                SmoothieException::Throw(64,temporary,i );
            }

            continue;
        }
        else if( basbuf[i] == 1 && basbuf[i+1] == ESC_CLEARNAMESPACEIMPORTED ){
            compiler.GetNamespaceSupporter().GetImportedNamespaces().clear();
            continue;
        }



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

            top_pos=i;

            i+=2;

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

            CClass *pobj_c = const_cast<CClass *>( this->Find(namespaceScopes, temporary) );
            if(!pobj_c) continue;

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

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

            pobj_c->Readed();

            pobj_c->SetConstructorMemberSubIndex( -1 );
            pobj_c->SetDestructorMemberSubIndex( -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->GetName().c_str())==0){
                    SetError(105,temporary,i);
                    goto Interface_InheritsError;
                }

                //継承元クラスを取得
                const Classes &classes = *this;
                const CClass *pInheritsClass = classes.Find(temporary);
                if( !pInheritsClass ){
                    SetError(106,temporary,i);
                    goto Interface_InheritsError;
                }

                //継承させる
                if( !pobj_c->InheritsClass( *pInheritsClass, Types(), i ) ){
                    goto Interface_InheritsError;
                }
            }
            else{
                //継承無し
                if( &pobj_c->GetSuperClass() || pobj_c->GetVtblNum() )
                {
                    // TODO: ここに来ないことが実証できたらこの分岐は消す
                    Jenga::Throw( "GetClass_recur内の例外" );
                }
            }
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;
                }
                else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPLEMENTS )
                {
                    SetError(137, 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;
                }

                //メンバ関数を追加
                pobj_c->AddMethod(pobj_c,
                    Prototype::Public,  //Publicアクセス権
                    0,                  // bStatic
                    false,              // isConst
                    true,               // isAbstract
                    true,               // isVirtual
                    false,              // isOverride
                    false,              // isAutoGeneration
                    temporary,
                    sub_address
                    );
            }
        }

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

            top_pos=i;

            const DWORD 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);
            }
            else if( memicmp( basbuf + i, "Blittable(", 10 ) == 0 ){
                // Blittable修飾子
                i+=10;
                i=JumpStringInPare(basbuf,i)+1;
            }

            if( basbuf[i] == 1 && basbuf[i+1] == ESC_ENUM )
            {
                // 列挙型の場合
                i += 2;
            }
            else if( basbuf[i] == 1 && basbuf[i+1] == ESC_DELEGATE )
            {
                // デリゲートの場合
                i += 2;
            }

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

            char className[VN_SIZE];
            Jenga::Common::Strings typeParameters;
            SplitGenericClassInstance( temporary, className, typeParameters );

            CClass *pobj_c =  const_cast<CClass *>( this->Find(namespaceScopes, className) );
            if(!pobj_c) continue;

            compiler.pCompilingClass = pobj_c;

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

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


            /////////////////////////////////////////////////////////
            // ☆★☆ ジェネリクスサポート ☆★☆
            BOOST_FOREACH( const std::string &typeParameter, typeParameters )
            {
                pobj_c->AddFormalGenericType( GenericType( typeParameter, Type(DEF_OBJECT,*GetObjectClassPtr()) ) );
            }
            /////////////////////////////////////////////////////////


            pobj_c->SetFixedAlignment( iAlign );

            pobj_c->Readed();

            pobj_c->SetConstructorMemberSubIndex( -1 );
            pobj_c->SetDestructorMemberSubIndex( -1 );

            //アクセス制限の初期値をセット
            Prototype::Accessibility accessibility;
            if(dwClassType==ESC_CLASS){
                accessibility = Prototype::Private;
            }
            else{
                accessibility = Prototype::Public;
            }

            if( pobj_c->GetName() == "Object"
                || dwClassType == ESC_TYPE )
            {
                // 何も継承しない

                if( &pobj_c->GetSuperClass() || pobj_c->GetVtblNum() )
                {
                    // TODO: ここに来ないことが実証できたらこの分岐は消す
                    Jenga::Throw( "GetClass_recur内の例外" );
                }
            }
            else{
                if(basbuf[i+1]==1&&basbuf[i+2]==ESC_INHERITS)
                {
                    // クラス継承先が指定されているとき
                    i += 3;
                    GetCommandToken( temporary, basbuf, i );

                    if(lstrcmpi(temporary,pobj_c->GetName().c_str())==0){
                        SetError(105,temporary,i);
                        goto InheritsError;
                    }
                }
                else
                {
                    // 何の指定もないときはObjectクラスを継承する
                    lstrcpy( temporary, "Object" );
                }
                pobj_c->Inherits( temporary, i );

                if( basbuf[i+1] == 1 && basbuf[i+2] == ESC_IMPLEMENTS )
                {
                    // インターフェイス実装を行う場合
                    i += 3;
                    GetCommandToken( temporary, basbuf, i );

                    pobj_c->Implements( temporary, i );
                }
            }
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;
                }
                else if( basbuf[i] == 1 && basbuf[i+1] == ESC_IMPLEMENTS )
                {
                    SetError(137, 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;
                }

                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 isVirtual = false, isAbstract = false, isOverride = false;
                if(i3==ESC_ABSTRACT){
                    isAbstract=1;
                    isVirtual=1;
                    i+=2;

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

                    i3=basbuf[i+1];
                }
                else if(i3==ESC_OVERRIDE){
                    isOverride=1;
                    isVirtual=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){
                    accessibility = Prototype::Private;
                    continue;
                }
                if(lstrcmpi(temporary,"Public")==0){
                    accessibility = Prototype::Public;
                    continue;
                }
                if(lstrcmpi(temporary,"Protected")==0){
                    accessibility = Prototype::Protected;
                    continue;
                }

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


                        if(pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().IsStruct()){
                            if( !pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().GetClass().IsReady() ){
                                //参照先が読み取られていないとき
                                GetClass_recur(pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().GetClass().GetName().c_str());
                            }
                        }


                        if(pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().IsStruct()){
                            //循環参照のチェック
                            pobj_LoopRefCheck->add(pobj_c->GetName().c_str());
                            if(!MemberVar_LoopRefCheck(pobj_c->GetDynamicMembers()[pobj_c->GetDynamicMembers().size()-1]->GetType().GetClass())){
                                //エラー回避
                                Type &type = const_cast<Type &>(pobj_c->GetDynamicMembers().back()->GetType());
                                type.SetBasicType( DEF_PTR_VOID );
                            }
                            pobj_LoopRefCheck->del(pobj_c->GetName().c_str());
                        }
                    }
                }
                else{
                    //メソッドを追加
                    cp=i;   //エラー用
                    pobj_c->AddMethod(pobj_c,
                        accessibility,
                        bStatic,
                        isConst,
                        isAbstract,
                        isVirtual,
                        isOverride,
                        false,
                        temporary,
                        sub_address);

                    if( isAbstract ) 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;
                        }
                    }
                }
            }
        }
    }

    // 呼び出し元でコンパイル中のクラスポインタを元に戻す
    compiler.pCompilingClass = pBackCompilingClass;

    // 名前空間を元に戻す
    compiler.GetNamespaceSupporter().GetLivingNamespaceScopes() = backupNamespaceScopes;

    // インポートされた名前空間を元に戻す
    compiler.GetNamespaceSupporter().GetImportedNamespaces() = backupImportedNamespaces;
}
void Classes::GetAllClassInfo(void){
    //ループ継承チェック用のクラス
    pobj_LoopRefCheck=new CLoopRefCheck();

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

    delete pobj_LoopRefCheck;
    pobj_LoopRefCheck=0;

    // イテレータの準備
    this->Iterator_Init();
}
void Classes::Compile_System_InitializeUserTypes(){
    char temporary[VN_SIZE];

    ////////////////////////////////////////////////////////////////////
    // クラス登録
    ////////////////////////////////////////////////////////////////////

    // イテレータをリセット
    Iterator_Reset();

    while( Iterator_HasNext() ){
        const CClass &objClass = *Iterator_GetNext();

        if( !objClass.IsUsing() ){
            // 未使用のクラスは無視する
            continue;
        }

        char referenceOffsetsBuffer[1024] = "";
        int numOfReference = 0;
        BOOST_FOREACH( CMember *pMember, objClass.GetDynamicMembers() ){
            if( pMember->GetType().IsObject() || pMember->GetType().IsPointer() ){
                if( referenceOffsetsBuffer[0] ){
                    lstrcat( referenceOffsetsBuffer, "," );
                }

                sprintf( referenceOffsetsBuffer + lstrlen( referenceOffsetsBuffer ),
                    "%d",
                    objClass.GetMemberOffset( pMember->GetName().c_str() ) );

                numOfReference++;
            }
        }

        sprintf( temporary
            , "Add(%c%c_System_TypeForClass(\"%s\",\"%s\",[%s],%d))"
            , 1
            , ESC_NEW
            , ""                            // 名前空間 (TODO: 実装)
            , objClass.GetName().c_str()    // クラス名
            , referenceOffsetsBuffer        // 参照メンバオフセット配列
            , numOfReference                // 参照メンバの個数
            );

        // コンパイル
        ChangeOpcode( temporary );
    }


    ////////////////////////////////////////////////////////////////////
    // 基底クラスを登録
    ////////////////////////////////////////////////////////////////////

    sprintf(temporary, "%c%ctempType=Nothing%c%cTypeBaseImpl"
        , HIBYTE( COM_DIM )
        , LOBYTE( COM_DIM )
        , 1
        , ESC_AS
        );
    ChangeOpcode( temporary );

    // イテレータをリセット
    Iterator_Reset();

    while( Iterator_HasNext() ){
        const CClass &objClass = *Iterator_GetNext();

        if( !objClass.IsUsing() ){
            // 未使用のクラスは無視する
            continue;
        }

        if( objClass.HasSuperClass() ){
            sprintf( temporary
                , "tempType=Search(\"%s\",\"%s\")"
                , ""                            // 名前空間 (TODO: 実装)
                , objClass.GetName().c_str()    // クラス名
                );

            // コンパイル
            ChangeOpcode( temporary );

            sprintf( temporary
                , "tempType.SetBaseType(Search(\"%s\",\"%s\"))"
                , ""                                // 名前空間 (TODO: 実装)
                , objClass.GetSuperClass().GetName().c_str()    // 基底クラス名
                );

            // コンパイル
            ChangeOpcode( temporary );
        }
    }



    ////////////////////////////////////////////////////////////////////
    // 継承関係登録
    ////////////////////////////////////////////////////////////////////
    // TODO: 未完成
    /*

    // イテレータをリセット
    Iterator_Reset();

    while( Iterator_HasNext() ){
        CClass *pClass = Iterator_GetNext();

        sprintf( genBuffer + length
            , "obj.Search( \"%s\" ).SetBaseType( Search( \"%s\" ) ):"
            , ""                // クラス名
            , pClass->name      // クラス名
            );
        length += lstrlen( genBuffer + length );

        while( length + 8192 > max ){
            max += 8192;
            genBuffer = (char *)realloc( genBuffer, max );
        }
    }*/
}

const CClass *Classes::Find( const NamespaceScopes &namespaceScopes, const string &name ) const
{
    if( namespaceScopes.size() == 0 && name == "Object" ){
        return GetObjectClassPtr();
    }
    else if( namespaceScopes.size() == 0 && name == "String" ){
        return GetStringClassPtr();
    }

    const CClass *pClass = GetHashArrayElement( name.c_str() );
    while( pClass )
    {
        if( pClass->IsEqualSymbol( namespaceScopes, name ) ){
            //名前空間とクラス名が一致した
            return pClass;
        }
        pClass = pClass->GetChainNext();
    }

    // TypeDefも見る
    int index = compiler.GetObjectModule().meta.GetTypeDefs().GetIndex( namespaceScopes, name );
    if( index != -1 ){
        Type type = compiler.GetObjectModule().meta.GetTypeDefs()[index].GetBaseType();
        if( type.IsObject() ){
            return &type.GetClass();
        }
    }

    return NULL;
}
const CClass *Classes::Find( const string &fullName ) const
{
    char AreaName[VN_SIZE] = "";        //オブジェクト変数
    char NestName[VN_SIZE] = "";        //入れ子メンバ
    bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );

    return Find( NamespaceScopes( AreaName ), NestName );
}
void Classes::StartCompile( const UserProc *pUserProc ){
    const CClass *pParentClass = pUserProc->GetParentClassPtr();
    if( pParentClass ){
        pParentClass->Using();

        // 仮想関数になるメソッドに使用チェックをつける
        BOOST_FOREACH( const CMethod *pMethod, pParentClass->GetDynamicMethods() )
        {
            if( pMethod->IsVirtual() )
            {
                pMethod->GetUserProc().Using();
            }
        }

        pCompilingMethod = pParentClass->GetDynamicMethodOrInterfaceMethod( pUserProc );
        if( !pCompilingMethod ){
            pCompilingMethod = pParentClass->GetStaticMethods().GetMethodPtr( pUserProc );
            if( !pCompilingMethod ){
                SmoothieException::Throw(300);
            }
        }
    }
    else{
        pCompilingMethod = NULL;
    }
}

const CClass *Classes::GetStringClassPtr() const
{
    if( !pStringClass ){
        // キャッシュしておく
        pStringClass = this->Find( NamespaceScopes( "System" ), "String" );

        if( !pStringClass )
        {
            SetError(400, "System.String", cp);
            static CClass dummy;
            return &dummy;
        }
        return pStringClass;
    }
    return pStringClass;
}
const CClass *Classes::GetObjectClassPtr() const
{
    if( !pObjectClass ){
        // キャッシュしておく
        pObjectClass = this->Find( NamespaceScopes( "System" ), "Object" );

        if( !pObjectClass )
        {
            SetError(400, "System.Object", cp);
            static CClass dummy;
            return &dummy;
        }
        return pObjectClass;
    }
    return pObjectClass;
}
const CClass *Classes::GetInterfaceInfoClassPtr() const
{
    if( !pInterfaceInfo ){
        // キャッシュしておく
        pInterfaceInfo = this->Find( "ActiveBasic.Core.InterfaceInfo" );

        if( !pInterfaceInfo )
        {
            SetError(400, "ActiveBasic.Core.InterfaceInfo", cp);
            static CClass dummy;
            return &dummy;
        }
        return pInterfaceInfo;
    }
    return pInterfaceInfo;
}