source: dev/branches/egtra/ab5.0/abdev/compiler_x86/Compile_Object.cpp@ 784

#include "stdafx.h"

#include <Compiler.h>

#include "../BasicCompiler_Common/common.h"
#include "opcode.h"

void _call_constructor( const CClass *pobj_c, const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
    ////////////////////////////
    // コンストラクタの呼び出し
    ////////////////////////////
    
    //この関数を使用する場合は、
    //・ebxにオブジェクトの個数
    //・eaxに先頭ポインタ
    //をセットしておかなければならない


/*  //jnzのジャンプ先番地
    extern int obp;
    int jnz_back = obp;*/

    if(bSomeObjects){
        compiler.errorMessenger.OutputFatalError();

        //push ebx
        //compiler.codeGenerator.op_push(REG_EBX);
    }

    // ※ここでプッシュされた値はコンストラクタのthisポインタとなる
    //push eax
    compiler.codeGenerator.op_push(REG_EAX);



    ////////////////////////
    // オーバーロードを解決
    ////////////////////////

    std::vector<const UserProc *> subs;
    pobj_c->GetDynamicMethods().Enum( pobj_c->GetName().c_str(), subs );

    const UserProc *pUserProc;
    if( subs.size() > 0 ){
        //オーバーロードを解決
        pUserProc=OverloadSolutionWithStrParam(pobj_c->GetName().c_str(),
            subs,CreateParameter,"");

        if(!pUserProc) return;
    }

    {
        // 動的型情報をセットする
        // obj._System_SetType( _System_TypeBase_Search( fullName ) )
        subs.clear();
        pobj_c->GetDynamicMethods().Enum( "_System_SetType", subs );
        if( subs.size() == 1 ){
            char temporary[VN_SIZE];
            sprintf( temporary, "_System_TypeBase_Search(\"%s\"))", pobj_c->GetFullName().c_str() );

            Opcode_CallProc(temporary,
                subs[0],
                PROCFLAG_NEW,"");
        }
        else{
            compiler.errorMessenger.OutputFatalError();
        }

        // インターフェイスを初期化する
        // TODO: 実装
    }

    //コンストラクタを呼び出す
    Opcode_CallProc(CreateParameter,
        pUserProc,
        PROCFLAG_NEW | PROCFLAG_PERMIT_CONSTRUCTOR,"");



    //pop eax
    compiler.codeGenerator.op_pop(REG_EAX);

    if(bSomeObjects){
        /*
        //pop ebx
        compiler.codeGenerator.op_pop(REG_EBX);

        //add eax,TypeSize
        compiler.codeGenerator.op_add_RV( REG_EAX, ObjectSize );

        //sub ebx,1
        compiler.codeGenerator.op_sub_RV8(REG_EBX,1);

        //jne ↑
        compiler.codeGenerator.op_jne( jnz_back-obp, sizeof(long), false, true );
        */
    }
}
void Operator_New( const CClass &objClass, const char *objectSizeStr, const char *parameter, const Type &baseType )
{
    const CClass *pClass = &objClass;

    if( pClass->IsInterface() )
    {
        pClass = compiler.GetObjectModule().meta.GetClasses().GetInterfaceInfoClassPtr();
    }

    int typeSize = pClass->GetSize();

    if(pClass->IsAbstract())
    {
        std::string tempMessage;
        foreach( const CMethod *pMethod, pClass->GetDynamicMethods() ){
            if(pMethod->IsVirtual()){
                if(pMethod->IsAbstract()){
                    if( !tempMessage.empty() )
                    {
                        tempMessage += ", ";
                    }
                    tempMessage += pMethod->GetUserProc().GetName();
                }
            }
        }

        // インターフェイスのvtbl
        foreach( const ::Interface *pInterface, pClass->GetInterfaces() )
        {
            foreach( const CMethod *pMethod, pInterface->GetDynamicMethods() ){
                if(pMethod->IsVirtual()){
                    if(pMethod->IsAbstract()){
                        if( !tempMessage.empty() )
                        {
                            tempMessage += ", ";
                        }
                        tempMessage += pMethod->GetUserProc().GetName();
                    }
                }
            }
        }

        //抽象クラスだったとき
        compiler.errorMessenger.Output(-1,"\"%s\" は抽象クラスです。インスタンス化することはできません（抽象メソッド … " + tempMessage + "）。",cp);
    }

    BOOL bSomeObjects=0;
    if(objectSizeStr[0]){
        bSomeObjects=1;

        Type tempType;
        NumOpe(objectSizeStr,Type(),tempType);
        if( !tempType.IsWhole() ) compiler.errorMessenger.Output(49,NULL,cp);
        ChangeTypeToLong(tempType.GetBasicType());

        //pop eax
        compiler.codeGenerator.op_pop(REG_EAX);

        //※添え字上限値であることを考慮
        //inc eax
        compiler.codeGenerator.op_inc( REG_EAX );

        //オブジェクトの個数をebxに一時保持
        //※ebxは関数が呼ばれても不変
        //mov ebx,eax
        compiler.codeGenerator.op_mov_RR( REG_EBX, REG_EAX );

        //imul eax,size
        compiler.codeGenerator.op_imul_RV( REG_EAX, typeSize );

        //add eax,OBJECT_HEAD_SIZE
        compiler.codeGenerator.op_add_RV8( REG_EAX, (char)OBJECT_HEAD_SIZE );

        //push eax
        compiler.codeGenerator.op_push(REG_EAX);
    }
    else{
        //オブジェクトの個数をebxに一時保持
        //※ebxは関数が呼ばれても不変
        //mov ebx,1
        compiler.codeGenerator.op_mov_RV( REG_EBX, 1 );

        //push size + OBJECT_HEAD_SIZE
        compiler.codeGenerator.op_push_V( typeSize + OBJECT_HEAD_SIZE );
    }

    if( baseType.IsObject() ){
        // オブジェクト インスタンス
        // ※DeleteはGCで処理

        //call _System_GC_malloc_ForObject
        extern const UserProc *pSub_System_GC_malloc_ForObject;
        compiler.codeGenerator.op_call(pSub_System_GC_malloc_ForObject);
    }
    else{
        // オブジェクトポインタ
        // ※明示的なDeleteが必要

        //call _System_GC_malloc_ForObjectPtr
        extern const UserProc *pSub_System_GC_malloc_ForObjectPtr;
        compiler.codeGenerator.op_call(pSub_System_GC_malloc_ForObjectPtr);
    }


    /*
    確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
    pPtr[0]=オブジェクトの個数
    pPtr[1]=オブジェクトのサイズ
    pPtr[2]=デストラクタの関数ポインタ
    pPtr[3]=reserve
    */


    //mov dword ptr[eax],ebx（オブジェクトの個数）
    compiler.codeGenerator.op_mov_MR( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE );

    //add eax,sizeof(long)
    compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );

    //mov ecx,TypeSize
    compiler.codeGenerator.op_mov_RV( REG_ECX, typeSize );

    //mov dword ptr[eax],ecx（オブジェクトのサイズ）
    compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );

    //add eax,sizeof(long)
    compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );


    const CMethod *method = pClass->GetDestructorMethod();
    if( method == NULL ) return;

    //mov ecx,DestructorProcAddr
    compiler.codeGenerator.op_addressof( REG_ECX, &method->GetUserProc() );

    //mov dword ptr[eax],ecx（デストラクタの関数ポインタ）
    compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );

    //add eax,sizeof(long)
    compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );


    // リザーブ領域
    //add eax,sizeof(long)
    compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );


    //仮想関数テーブルを初期化
    if( pClass->IsExistVirtualFunctions()
        && !pClass->IsAbstract() )
    {
        // mov ecx,com_vtbl
        compiler.codeGenerator.op_mov_RV_com_vtbl( REG_ECX, pClass );

        //mov dword ptr[eax],ecx
        compiler.codeGenerator.op_mov_MR( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );

        // mov rcx,vtblAddress
        compiler.codeGenerator.op_mov_RV_vtbl( REG_ECX, pClass );

        //mov qword ptr[rax+sizeof(com_vtbl)],rcx
        compiler.codeGenerator.op_mov_MR(sizeof(long),REG_ECX,REG_EAX,PTR_SIZE,MOD_BASE_DISP8);

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


    // ※ここでプッシュされた値はNew演算子の戻り値となる
    //push eax
    compiler.codeGenerator.op_push(REG_EAX);


    /////////////////////////////////////////////////////////////////////

    ////////////////////////////
    // コンストラクタの呼び出し
    ////////////////////////////

    _call_constructor(pClass,parameter,typeSize,bSomeObjects);
}
void OpcodeDelete(const char *Parameter, bool isSweeping){
    Type tempType;
    if( !NumOpe(Parameter,Type(),tempType) ){
        return;
    }
    if(!( tempType.IsObjectPtr() || tempType.IsVoidPtr() )) compiler.errorMessenger.Output(122,NULL,cp);

    //pop eax
    compiler.codeGenerator.op_pop(REG_EAX);

    //sub eax,sizeof(DWORD)*3
    compiler.codeGenerator.op_sub_RV8( REG_EAX, OBJECT_HEAD_SIZE );

    //push eax
    compiler.codeGenerator.op_push(REG_EAX);


    //mov ebx,dword ptr[eax]（オブジェクトの個数）
    compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EBX, REG_EAX, 0, MOD_BASE );

    //add eax,sizeof(long)
    compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );


    //mov esi,dword ptr[eax]（オブジェクトのサイズ）
    compiler.codeGenerator.op_mov_RM( sizeof(long), REG_ESI, REG_EAX, 0, MOD_BASE );

    //add eax,sizeof(long)
    compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );


    //mov edx,dword ptr[eax]（デストラクタの関数ポインタ）
    compiler.codeGenerator.op_mov_RM( sizeof(long), REG_EDX, REG_EAX, 0, MOD_BASE );

    //add eax,sizeof(long)
    compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );


    // リザーブ領域
    //add eax,sizeof(long)
    compiler.codeGenerator.op_add_RV8( REG_EAX, sizeof(long) );


    //mov ecx,eax
    compiler.codeGenerator.op_mov_RR( REG_ECX, REG_EAX );


    //jnzの番地
    /*extern int obp;
    int jnz_back = obp;*/

    //push ecx
    compiler.codeGenerator.op_push(REG_ECX);

    //push edx
    compiler.codeGenerator.op_push(REG_EDX);

    //push ecx（Thisポインタ   ※隠れた第一パラメータ）
    compiler.codeGenerator.op_push(REG_ECX);

    //call edx
    compiler.codeGenerator.op_call_R( REG_EDX );

    //pop edx
    compiler.codeGenerator.op_pop(REG_EDX);

    //pop ecx
    compiler.codeGenerator.op_pop(REG_ECX);

    //add ecx,esi
    compiler.codeGenerator.op_add_RR( REG_ECX, REG_ESI );

    //sub ebx,1
    compiler.codeGenerator.op_sub_RV8(REG_EBX,1);

    //jne ↑
    //compiler.codeGenerator.op_jne( jnz_back-obp, sizeof(long), false, true );


    //////////////////////////////////////////
    // オブジェクトメンバ変数用のメモリを解放
    //////////////////////////////////////////

    if( isSweeping ){
        //call _System_GC_free_for_SweepingDelete
        extern const UserProc *pSub_System_GC_free_for_SweepingDelete;
        compiler.codeGenerator.op_call(pSub_System_GC_free_for_SweepingDelete);
    }
    else{
        //call free
        extern const UserProc *pSub_free;
        compiler.codeGenerator.op_call(pSub_free);
    }
}