Changeset 355 in dev


Ignore:
Timestamp:
Nov 2, 2007, 2:53:56 AM (17 years ago)
Author:
dai_9181
Message:

静的領域に初期オブジェクトを配置可能にした

Location:
trunk/abdev
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/abdev/BasicCompiler32/Compile_Calc.cpp

    r331 r355  
    573573    }
    574574
    575 
    576575    //NumOpe...（スタックに答えが格納される）
    577576    BOOL bCalcUseHeap;

  • trunk/abdev/BasicCompiler32/Compile_Object.cpp

    r354 r355  
    5757    {
    5858        // 動的型情報をセットする
    59         // obj._System_SetType( _System_TypeBase.Search( strNamespace, name ) )
     59        // obj._System_SetType( _System_TypeBase_Search( fullName ) )
    6060        subs.clear();
    6161        pobj_c->GetDynamicMethods().Enum( "_System_SetType", subs );
    6262        if( subs.size() == 1 ){
    6363            char temporary[VN_SIZE];
    64             sprintf( temporary, "_System_TypeBase_Search(\"\",\"%s\"))", pobj_c->GetName().c_str() );
     64            sprintf( temporary, "_System_TypeBase_Search(\"%s\"))", pobj_c->GetFullName().c_str() );
    6565
    6666            Opcode_CallProc(temporary,

  • trunk/abdev/BasicCompiler32/Compile_ProcOp.cpp

    r350 r355  
    219219
    220220            compiler.GetObjectModule().meta.GetClasses().Compile_System_InitializeUserTypes();
     221    }
     222    else if( userProc.GetName() == "InitializeUserTypesForBaseType"
     223        && userProc.HasParentClass()
     224        && userProc.GetParentClass().GetName() == "_System_TypeBase" )
     225    {
     226        compiler.GetObjectModule().meta.GetClasses().Compile_System_InitializeUserTypesForBaseType();
    221227    }
    222228    else if( userProc.GetName() == "RegisterGlobalRoots"

  • trunk/abdev/BasicCompiler32/MakePeHdr.cpp

    r342 r355  
    4242    *pSub_System_GC_free_for_SweepingDelete,
    4343    *pSubStaticMethod_System_TypeBase_InitializeUserTypes,
     44    *pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType,
    4445
    4546    *pSub_allrem,
    … …  
    282283        pSubStaticMethod_System_TypeBase_InitializeUserTypes->Using();
    283284        pSubStaticMethod_System_TypeBase_InitializeUserTypes->ThisIsAutoGenerationProc();
     285    }
     286   
     287    if( pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType = GetSubHash( "ActiveBasic.Core._System_TypeBase.InitializeUserTypesForBaseType",1 ) ){
     288        pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType->Using();
     289        pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType->ThisIsAutoGenerationProc();
    284290    }
    285291
    … …  
    10691075    }
    10701076
     1077    compiler.linker.SetDataTable( compiler.GetObjectModule().dataTable );
    10711078
    10721079    compiler.linker.SetImageBase( ImageBase );
    … …  
    10761083    compiler.linker.ResolveGlobalVarSchedules( MemPos_RWSection );
    10771084    compiler.linker.ResolveVtblSchedule( MemPos_DataSection );
     1085    compiler.linker.ResolveTypeInfoSchedule( MemPos_DataSection );
    10781086
    10791087
    … …  
    15431551    if(bUse_DataSection){
    15441552        //データ テーブル
    1545         WriteFile(hFile,compiler.GetObjectModule().dataTable.GetPtr(),compiler.GetObjectModule().dataTable.GetSize(),(DWORD *)&i2,NULL);
     1553        WriteFile(
     1554            hFile,
     1555            compiler.linker.GetDataTable().GetPtr(),
     1556            compiler.linker.GetDataTable().GetSize(),
     1557            (DWORD *)&i2,
     1558            NULL
     1559        );
    15461560        i+=i2;
    15471561    }

  • trunk/abdev/BasicCompiler32/NumOpe.cpp

    r350 r355  
    604604        // リテラル配列の場合
    605605
    606         if( !baseType.IsPointer() ){
    607             SetError(1,NULL,cp);
     606        int dataTableOffset;
     607        if( !compiler.GetObjectModule().dataTable.MakeLiteralArrayBuffer( expression, baseType, dataTableOffset ) )
     608        {
    608609            return false;
    609610        }
    610         Type tempBaseType( baseType );
    611         tempBaseType.PtrLevelDown();
    612 
    613         char *buffer = (char *)malloc( lstrlen( expression ) + 1 );
    614         lstrcpy( buffer, expression );
    615         RemoveStringBracket( buffer );
    616 
    617         void *binary = malloc( 1 );
    618         int num = 0;
    619 
    620         i = 0;
    621         while( buffer[i] ){
    622             i = GetOneParameter( buffer, i, temporary );
    623             if( buffer[i] == ',' ){
    624                 i++;
    625             }
    626 
    627             Type resultType;
    628             _int64 i64data;
    629             if( !StaticCalculation( true, temporary, tempBaseType.GetBasicType(), &i64data, resultType ) ){
    630                 return false;
    631             }
    632             if( !resultType.IsWhole() ){
    633                 // TODO: 実数に未対応
    634                 SetError();
    635                 return false;
    636             }
    637 
    638             binary = realloc( binary, ( num + 1 ) * tempBaseType.GetSize() );
    639             memcpy( (char *)binary + (num * tempBaseType.GetSize()), &i64data, tempBaseType.GetSize() );
    640             num++;
    641         }
    642 
    643         i2 = compiler.GetObjectModule().dataTable.AddBinary( binary, num * tempBaseType.GetSize() );
    644611
    645612        //mov eax,i2
    646         compiler.codeGenerator.op_mov_RV(REG_EAX,i2, Schedule::DataTable );
    647 
    648         free( buffer );
     613        compiler.codeGenerator.op_mov_RV(REG_EAX,dataTableOffset, Schedule::DataTable );
    649614
    650615        resultType = baseType;
    … …  
    657622
    658623    bool isLiteralCalculation;
    659     if( !NumOpe_GetType( expression, baseType, resultType, &isLiteralCalculation ) )
     624    if( NumOpe_GetType( expression, baseType, resultType, &isLiteralCalculation ) )
    660625    {
    661         return false;
    662     }
    663     if( isLiteralCalculation )
     626        if( isLiteralCalculation )
     627        {
     628            //右辺値が数値の定数式の場合
     629            _int64 i64data;
     630            StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
     631
     632            if( resultType.GetBasicSize() == sizeof(_int64) ){
     633                //64ビット（符号有り整数/実数）
     634
     635                //push HILONG(i64data)
     636                compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4));
     637
     638                //push LOLONG(i64data)
     639                compiler.codeGenerator.op_push_V(*(long *)(&i64data));
     640            }
     641            else if( resultType.IsSingle() ){
     642                //single実数
     643
     644                double dbl;
     645                memcpy(&dbl,&i64data,sizeof(_int64));
     646
     647                float flt;
     648                flt=(float)dbl;
     649                long l;
     650                memcpy(&l,&flt,sizeof(long));
     651
     652                //push flt
     653                compiler.codeGenerator.op_push_V(l);
     654            }
     655            else{
     656                //整数（符号有り/無し）
     657
     658                long l = (long)i64data;
     659
     660                if(resultType.GetBasicSize()==sizeof(char)) l = l & 0x000000FF;
     661                if(resultType.GetBasicSize()==sizeof(short)) l = l & 0x0000FFFF;
     662
     663                //push term
     664                compiler.codeGenerator.op_push_V(l);
     665            }
     666            return true;
     667        }
     668    }
     669
     670    if(expression[0]==1 )
    664671    {
    665         //右辺値が数値の定数式の場合
    666         _int64 i64data;
    667         StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
    668 
    669         if( resultType.GetBasicSize() == sizeof(_int64) ){
    670             //64ビット（符号有り整数/実数）
    671 
    672             //push HILONG(i64data)
    673             compiler.codeGenerator.op_push_V((long)*(long *)(((char *)(&i64data))+4));
    674 
    675             //push LOLONG(i64data)
    676             compiler.codeGenerator.op_push_V(*(long *)(&i64data));
    677         }
    678         else if( resultType.IsSingle() ){
    679             //single実数
    680 
    681             double dbl;
    682             memcpy(&dbl,&i64data,sizeof(_int64));
    683 
    684             float flt;
    685             flt=(float)dbl;
    686             long l;
    687             memcpy(&l,&flt,sizeof(long));
    688 
    689             //push flt
    690             compiler.codeGenerator.op_push_V(l);
    691         }
    692         else{
    693             //整数（符号有り/無し）
    694 
    695             long l = (long)i64data;
    696 
    697             if(resultType.GetBasicSize()==sizeof(char)) l = l & 0x000000FF;
    698             if(resultType.GetBasicSize()==sizeof(short)) l = l & 0x0000FFFF;
    699 
    700             //push term
    701             compiler.codeGenerator.op_push_V(l);
    702         }
    703         return true;
    704     }
    705 
    706     if(expression[0]==1&& expression[1]==ESC_NEW ){
    707         //New演算子（オブジェクト生成）
    708 
    709         if( !Operator_New( expression+2, baseType, resultType ) ){
    710             return false;
    711         }
    712 
    713         return true;
     672        if( expression[1]==ESC_NEW ){
     673            //New演算子（オブジェクト生成）
     674
     675            if( !Operator_New( expression+2, baseType, resultType ) ){
     676                return false;
     677            }
     678
     679            return true;
     680        }
     681        else if( expression[1] == ESC_SYSTEM_STATIC_NEW )
     682        {
     683            // 静的領域にオブジェクトを作る
     684
     685            // 静的領域にオブジェクトを生成
     686            int dataTableOffset;
     687            if( !compiler.GetObjectModule().dataTable.MakeConstObjectToProcessStaticBuffer( expression + 2, resultType, dataTableOffset ) )
     688            {
     689                return false;
     690            }
     691
     692            // push value
     693            compiler.codeGenerator.op_push_V( dataTableOffset, Schedule::DataTable );
     694
     695            return true;
     696        }
    714697    }
    715698
    … …  
    736719    //リテラル値のみの計算かどうかを判別するためのフラグ
    737720    BOOL bLiteralCalculation=1;
    738 
    739     //リテラル演算の場合を考慮した演算前の再配置スケジュール
    740     CReloc *pobj_BackReloc;
    741     pobj_BackReloc=new CReloc();
    742     pobj_BackReloc->copy(pobj_Reloc);
    743721
    744722    double dbl;
    … …  
    819797                    || term[0] == '\"' )
    820798                {
    821                     if( !baseType.IsPointer() )
    822                     {
    823                         //要求タイプがオブジェクト、または未定のとき
    824 
    825                         //String型オブジェクトを生成
    826                         NewStringObject(term);
    827 
    828                         type_stack[sp]=DEF_OBJECT;
    829                         index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
    830                         bLiteralCalculation=0;
    831 
    832                         sp++;
    833                         break;
    834                     }
    835 
    836799                    bool isEx = true;
    837800                    if( term[0] == '\"' )
    … …  
    858821                        }
    859822                        i3=lstrlen(term);
     823                    }
     824
     825                    if( !baseType.IsPointer() )
     826                    {
     827                        //要求タイプがオブジェクト、または未定のとき
     828
     829                        //String型オブジェクトを生成
     830                        i2 = compiler.GetObjectModule().dataTable.MakeConstStringObjectToProcessStaticBuffer( term );
     831                       
     832                        // push value
     833                        compiler.codeGenerator.op_push_V( i2, Schedule::DataTable );
     834
     835                        type_stack[sp]=DEF_OBJECT;
     836                        index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
     837                        bLiteralCalculation=0;
     838
     839                        sp++;
     840                        break;
    860841                    }
    861842StrLiteral:
    … …  
    12001181    }
    12011182
    1202     //再配置スケジュールバックアップ情報を解放
    1203     delete pobj_BackReloc;
    1204 
    12051183    return isSuccessful;
    12061184}

  • trunk/abdev/BasicCompiler64/Compile_Object.cpp

    r354 r355  
    5555    {
    5656        // 動的型情報をセットする
    57         // obj._System_SetType( _System_TypeBase.Search( strNamespace, name ) )
     57        // obj._System_SetType( _System_TypeBase_Search( fullName ) )
    5858        subs.clear();
    5959        pobj_c->GetDynamicMethods().Enum( "_System_SetType", subs );
    6060        if( subs.size() == 1 ){
    6161            char temporary[VN_SIZE];
    62             sprintf( temporary, "_System_TypeBase_Search(\"\",\"%s\"))", pobj_c->GetName().c_str() );
     62            sprintf( temporary, "_System_TypeBase_Search(\"%s\"))", pobj_c->GetFullName().c_str() );
    6363
    6464            Opcode_CallProc(temporary,

  • trunk/abdev/BasicCompiler64/Compile_ProcOp.cpp

    r353 r355  
    141141    {
    142142        compiler.GetObjectModule().meta.GetClasses().Compile_System_InitializeUserTypes();
     143    }
     144    else if( userProc.GetName() == "InitializeUserTypesForBaseType"
     145        && userProc.HasParentClass()
     146        && userProc.GetParentClass().GetName() == "_System_TypeBase" )
     147    {
     148        compiler.GetObjectModule().meta.GetClasses().Compile_System_InitializeUserTypesForBaseType();
    143149    }
    144150    else if( userProc.GetName() == "RegisterGlobalRoots"

  • trunk/abdev/BasicCompiler64/MakePeHdr.cpp

    r345 r355  
    4141    *pSub_System_GC_malloc_ForObjectPtr,
    4242    *pSub_System_GC_free_for_SweepingDelete,
    43     *pSubStaticMethod_System_TypeBase_InitializeUserTypes;
     43    *pSubStaticMethod_System_TypeBase_InitializeUserTypes,
     44    *pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType;
    4445
    4546// 動的メソッド
    … …  
    275276        pSubStaticMethod_System_TypeBase_InitializeUserTypes->Using();
    276277        pSubStaticMethod_System_TypeBase_InitializeUserTypes->ThisIsAutoGenerationProc();
     278    }
     279
     280    if( pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType = GetSubHash( "ActiveBasic.Core._System_TypeBase.InitializeUserTypesForBaseType",1 ) ){
     281        pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType->Using();
     282        pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType->ThisIsAutoGenerationProc();
    277283    }
    278284
    … …  
    10671073    }
    10681074
     1075    compiler.linker.SetDataTable( compiler.GetObjectModule().dataTable );
    10691076
    10701077    compiler.linker.SetImageBase( ImageBase );
    … …  
    10741081    compiler.linker.ResolveGlobalVarSchedules( MemPos_RWSection );
    10751082    compiler.linker.ResolveVtblSchedule( MemPos_DataSection );
     1083    compiler.linker.ResolveTypeInfoSchedule( MemPos_DataSection );
    10761084
    10771085
    … …  
    15401548    if(bUse_DataSection){
    15411549        //データ テーブル
    1542         WriteFile(hFile,compiler.GetObjectModule().dataTable.GetPtr(),compiler.GetObjectModule().dataTable.GetSize(),(DWORD *)&i2,NULL);
     1550        WriteFile(
     1551            hFile,
     1552            compiler.linker.GetDataTable().GetPtr(),
     1553            compiler.linker.GetDataTable().GetSize(),
     1554            (DWORD *)&i2,
     1555            NULL
     1556        );
    15431557        i+=i2;
    15441558    }

  • trunk/abdev/BasicCompiler64/NumOpe.cpp

    r350 r355  
    590590            BOOL *pbUseHeap )
    591591{
    592 
    593592    int i,i2,i3;
    594593    char temporary[1024],temp2[1024];
     594
     595    if( (string)expression == "typeInfo=t2" )
     596    {
     597        int test=0;
     598    }
    595599
    596600    if(expression[0]=='\0'){
    … …  
    602606        // リテラル配列の場合
    603607
    604         if( !baseType.IsPointer() ){
    605             SetError(1,NULL,cp);
     608        int dataTableOffset;
     609        if( !compiler.GetObjectModule().dataTable.MakeLiteralArrayBuffer( expression, baseType, dataTableOffset ) )
     610        {
    606611            return false;
    607612        }
    608         Type tempBaseType( baseType );
    609         tempBaseType.PtrLevelDown();
    610 
    611         char *buffer = (char *)malloc( lstrlen( expression ) + 1 );
    612         lstrcpy( buffer, expression );
    613         RemoveStringBracket( buffer );
    614 
    615         void *binary = malloc( 1 );
    616         int num = 0;
    617 
    618         i = 0;
    619         while( buffer[i] ){
    620             i = GetOneParameter( buffer, i, temporary );
    621             if( buffer[i] == ',' ){
    622                 i++;
    623             }
    624 
    625             Type resultType;
     613
     614        //mov reg,i2
     615        compiler.codeGenerator.op_mov_RV( sizeof(_int64), *pReg, dataTableOffset, Schedule::DataTable );
     616
     617        resultType = baseType;
     618
     619        return true;
     620    }
     621
     622    bool isLiteralCalculation;
     623    if( NumOpe_GetType( expression, baseType, resultType, &isLiteralCalculation ) )
     624    {
     625        if( isLiteralCalculation )
     626        {
     627            //右辺値が数値の定数式の場合
    626628            _int64 i64data;
    627             if( !StaticCalculation( true, temporary, tempBaseType.GetBasicType(), &i64data, resultType ) ){
     629            StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
     630
     631            if(resultType.IsReal()){
     632                if(baseType.IsReal()) resultType=baseType;
     633
     634                int xmmReg = pobj_reg->GetNextXmmReg();
     635                *pReg = xmmReg;
     636
     637                if(resultType.IsDouble()){
     638                    i3 = compiler.GetObjectModule().dataTable.Add( i64data );
     639
     640                    //movlpd xmm_reg,qword ptr[data table offset]
     641                    compiler.codeGenerator.op_movlpd_RM( xmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
     642                }
     643                if(resultType.IsSingle()){
     644                    double dbl;
     645                    memcpy(&dbl,&i64data,sizeof(_int64));
     646
     647                    float flt;
     648                    int i32data;
     649                    flt=(float)dbl;
     650                    memcpy(&i32data,&flt,sizeof(long));
     651
     652                    i3 = compiler.GetObjectModule().dataTable.Add( i32data );
     653
     654                    //movss xmm_reg,dword ptr[data table offset]
     655                    compiler.codeGenerator.op_movss_RM( xmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
     656                }
     657            }
     658            else{
     659                if(!resultType.Is64()){
     660                    //整数（符号有り/無し）
     661
     662                    i3=(long)i64data;
     663
     664                    if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
     665                    if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
     666
     667                    i64data=(_int64)i3;
     668                }
     669
     670                //mov reg,i64data
     671                compiler.codeGenerator.op_mov_RV64(*pReg,i64data);
     672            }
     673            return true;
     674        }
     675    }
     676
     677    if( expression[0] == 1 )
     678    {
     679        if( expression[1]==ESC_NEW )
     680        {
     681            //New演算子（オブジェクト生成）
     682
     683            if( pobj_BlockReg->check(REG_RAX) ){
     684                SetError();
     685            }
     686
     687            //////////////////////////////////////////////////////
     688            /////    レジスタ資源のバックアップ
     689            {   BACKUP_REGISTER_RESOURCE
     690            //////////////////////////////////////////////////////
     691
     692                if( !Operator_New( expression+2, baseType, resultType ) ){
     693                    return false;
     694                }
     695
     696            /////////////////////////////////////////////
     697            //////   レジスタ資源を復元
     698                RESTORE_REGISTER_RESOURCE
     699            }////////////////////////////////////////////
     700
     701            //mov reg,rax
     702            compiler.codeGenerator.op_mov_RR( *pReg, REG_RAX );
     703
     704            return true;
     705        }
     706        else if( expression[1] == ESC_SYSTEM_STATIC_NEW )
     707        {
     708            // 静的領域にオブジェクトを作る
     709
     710            // 静的領域にオブジェクトを生成
     711            int dataTableOffset;
     712            if( !compiler.GetObjectModule().dataTable.MakeConstObjectToProcessStaticBuffer( expression + 2, resultType, dataTableOffset ) )
     713            {
    628714                return false;
    629715            }
    630             if( !resultType.IsWhole() ){
    631                 // TODO: 実数に未対応
    632                 SetError();
    633                 return false;
    634             }
    635 
    636             binary = realloc( binary, ( num + 1 ) * tempBaseType.GetSize() );
    637             memcpy( (char *)binary + (num * tempBaseType.GetSize()), &i64data, tempBaseType.GetSize() );
    638             num++;
    639         }
    640 
    641         i2 = compiler.GetObjectModule().dataTable.AddBinary( binary, num * tempBaseType.GetSize() );
    642 
    643         //mov reg,i2
    644         compiler.codeGenerator.op_mov_RV(sizeof(_int64),*pReg,i2, Schedule::DataTable );
    645 
    646         free( buffer );
    647 
    648         resultType = baseType;
    649 
    650         return true;
    651     }
    652 
    653     bool isLiteralCalculation;
    654     if( !NumOpe_GetType( expression, baseType, resultType, &isLiteralCalculation ) )
    655     {
    656         return false;
    657     }
    658     if( isLiteralCalculation )
    659     {
    660         //右辺値が数値の定数式の場合
    661         _int64 i64data;
    662         StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
    663 
    664         if(resultType.IsReal()){
    665             if(baseType.IsReal()) resultType=baseType;
    666 
    667             int xmmReg = pobj_reg->GetNextXmmReg();
    668             *pReg = xmmReg;
    669 
    670             if(resultType.IsDouble()){
    671                 i3 = compiler.GetObjectModule().dataTable.Add( i64data );
    672 
    673                 //movlpd xmm_reg,qword ptr[data table offset]
    674                 compiler.codeGenerator.op_movlpd_RM( xmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
    675             }
    676             if(resultType.IsSingle()){
    677                 double dbl;
    678                 memcpy(&dbl,&i64data,sizeof(_int64));
    679 
    680                 float flt;
    681                 int i32data;
    682                 flt=(float)dbl;
    683                 memcpy(&i32data,&flt,sizeof(long));
    684 
    685                 i3 = compiler.GetObjectModule().dataTable.Add( i32data );
    686 
    687                 //movss xmm_reg,dword ptr[data table offset]
    688                 compiler.codeGenerator.op_movss_RM( xmmReg, 0, i3, MOD_DISP32, Schedule::DataTable );
    689             }
    690         }
    691         else{
    692             if(!resultType.Is64()){
    693                 //整数（符号有り/無し）
    694 
    695                 i3=(long)i64data;
    696 
    697                 if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
    698                 if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
    699 
    700                 i64data=(_int64)i3;
    701             }
    702 
    703             //mov reg,i64data
    704             compiler.codeGenerator.op_mov_RV64(*pReg,i64data);
    705         }
    706         return true;
    707     }
    708 
    709     if(expression[0]==1&& expression[1]==ESC_NEW ){
    710         //New演算子（オブジェクト生成）
    711 
    712         if( pobj_BlockReg->check(REG_RAX) ){
    713             SetError();
    714         }
    715 
    716         //////////////////////////////////////////////////////
    717         /////    レジスタ資源のバックアップ
    718         {   BACKUP_REGISTER_RESOURCE
    719         //////////////////////////////////////////////////////
    720 
    721             if( !Operator_New( expression+2, baseType, resultType ) ){
    722                 return false;
    723             }
    724 
    725         /////////////////////////////////////////////
    726         //////   レジスタ資源を復元
    727             RESTORE_REGISTER_RESOURCE
    728         }////////////////////////////////////////////
    729 
    730         //mov reg,rax
    731         compiler.codeGenerator.op_mov_RR( *pReg, REG_RAX );
    732 
    733         return true;
     716
     717            //mov reg,i2
     718            compiler.codeGenerator.op_mov_RV( sizeof(_int64), *pReg, dataTableOffset, Schedule::DataTable);
     719
     720            return true;
     721        }
    734722    }
    735723
    … …  
    850838                    || term[0] == '\"' )
    851839                {
    852                     if( !baseType.IsPointer() )
    853                     {
    854                         //要求タイプがオブジェクト、または未定のとき
    855 
    856                         //String型オブジェクトを生成
    857                         NewStringObject(UseReg,term);
    858 
    859                         type_stack[sp]=DEF_OBJECT;
    860                         index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
    861                         bLiteralCalculation=0;
    862 
    863                         if(bXmm) pobj_reg->LockXmmReg();
    864                         else pobj_reg->LockReg();
    865 
    866                         sp++;
    867                         break;
    868                     }
    869 
    870840                    bool isEx = true;
    871841                    if( term[0] == '\"' )
    … …  
    893863                        i3=lstrlen(term);
    894864                    }
     865
     866                    if( !baseType.IsPointer() )
     867                    {
     868                        //要求タイプがオブジェクト、または未定のとき
     869
     870                        //String型オブジェクトを生成
     871                        i2 = compiler.GetObjectModule().dataTable.MakeConstStringObjectToProcessStaticBuffer( term );
     872
     873                        //mov reg,i2
     874                        compiler.codeGenerator.op_mov_RV(sizeof(_int64),UseReg,i2, Schedule::DataTable);
     875
     876                        type_stack[sp]=DEF_OBJECT;
     877                        index_stack[sp]=(LONG_PTR)compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
     878                        bLiteralCalculation=0;
     879
     880                        if(bXmm) pobj_reg->LockXmmReg();
     881                        else pobj_reg->LockReg();
     882
     883                        sp++;
     884                        break;
     885                    }
     886
    895887StrLiteral:
    896888

  • trunk/abdev/BasicCompiler_Common/Intermediate_Step1.cpp

    r340 r355  
    529529                        temporary[i2]=ESC_CLEARNAMESPACEIMPORTED;
    530530                    }
     531                    if(lstrcmpi(temporary+i3,"_System_Static_New")==0){
     532                        i2=i3;
     533                        temporary[i2++]=1;
     534                        temporary[i2]=ESC_SYSTEM_STATIC_NEW;
     535                    }
    531536                    break;
    532537                case 'a':

  • trunk/abdev/BasicCompiler_Common/NumOpe_GetType.cpp

    r350 r355  
    254254
    255255bool Operator_New_GetType(const char *Parameter,const Type &baseType, Type &resultType ){
    256     char TypeName[VN_SIZE],CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
     256    char TypeName[VN_SIZE],objectSizeStr[VN_SIZE];
    257257    int i,i2;
    258258
    … …  
    268268
    269269    for(i2=0;;i++,i2++){
    270         if(Parameter[i]=='('){
     270        if(Parameter[i]=='(' || Parameter[i]=='['){
    271271            TypeName[i2]=0;
    272 
    273             //コンストラクタに渡すパラメータを取得
    274             i2=GetStringInPare(CreateParameter,Parameter+i);
    275             RemoveStringPare(CreateParameter);
    276             i+=i2;
    277             if(Parameter[i]!='\0'){
    278                 SetError(42,NULL,cp);
    279                 return false;
    280             }
    281272            break;
    282273        }
    283274        TypeName[i2]=Parameter[i];
    284275        if(Parameter[i]=='\0'){
    285             CreateParameter[0]=0;
    286276            break;
    287277        }
    … …  
    589579    }
    590580
    591     if(expression[0]==1&& expression[1]==ESC_NEW ){
     581    if(expression[0]==1&& ( expression[1]==ESC_NEW || expression[1] == ESC_SYSTEM_STATIC_NEW ) ){
    592582        //New演算子（オブジェクト生成）
    593583        *pIsLiteralCalculation = false;

  • trunk/abdev/BasicCompiler_Common/Subroutine.cpp

    r353 r355  
    513513    pSubStaticMethod_System_TypeBase_InitializeUserTypes->CompleteCompile();
    514514
     515    //_System_TypeBase_InitializeUserTypesForBaseTypeは一番最後にコンパイル
     516    extern const UserProc *pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType;
     517    pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType->CompleteCompile();
     518
    515519    //_System_InitStaticLocalVariablesは一番最後にコンパイル
    516520    //※一般関数内の静的変数オブジェクトをすべて収集しなければならない
    … …  
    544548        pSubStaticMethod_System_TypeBase_InitializeUserTypes->KillCompileStatus();
    545549        CompileBufferInProcedure( *pSubStaticMethod_System_TypeBase_InitializeUserTypes );
     550
     551        //_System_TypeBase_InitializeUserTypesForBaseTypeは最後のほうでコンパイル
     552        pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType->KillCompileStatus();
     553        CompileBufferInProcedure( *pSubStaticMethod_System_TypeBase_InitializeUserTypesForBaseType );
    546554
    547555        if( IsNeedProcCompile() ){

  • trunk/abdev/BasicCompiler_Common/include/Class.h

    r353 r355  
    422422        return staticMembers;
    423423    }
     424   
     425    const CMember *FindDynamicMember( const char *memberName ) const
     426    {
     427        BOOST_FOREACH( CMember *pMember, GetDynamicMembers() )
     428        {
     429            if( pMember->GetName() == memberName )
     430            {
     431                return pMember;
     432            }
     433        }
     434        return NULL;
     435    }
    424436
    425437    void EnumDynamicMethodsOrInterfaceMethods( const char *methodName, std::vector<const UserProc *> &subs ) const;
    … …  
    516528
    517529
     530    // TypeInfo用
     531    mutable int typeInfoDataTableOffset;
     532    void SetTypeInfoDataTableOffset( int typeInfoDataTableOffset ) const
     533    {
     534        this->typeInfoDataTableOffset = typeInfoDataTableOffset;
     535    }
     536    int GetTypeInfoDataTableOffset() const
     537    {
     538        return typeInfoDataTableOffset;
     539    }
     540
     541
    518542    //線形リスト用
    519543    CClass *pobj_NextClass;
    … …  
    554578    virtual void GetAllClassInfo();
    555579    virtual void Compile_System_InitializeUserTypes();
     580    virtual void Compile_System_InitializeUserTypesForBaseType();
    556581
    557582    const CClass *Find( const NamespaceScopes &namespaceScopes, const string &name ) const;

  • trunk/abdev/BasicCompiler_Common/include/DataTable.h

    r279 r355  
    44
    55//DataTable.cpp
    6 class DataTable{
     6class DataTable
     7{
    78    char *buffer;
    89    int size;
    910
    10     void Realloc( int size )
    11     {
    12         this->buffer = (char *)realloc( this->buffer, size + 100 );
    13         this->size = size;
    14     }
     11public:
     12    // リンカで解決しなければならないスケジュール
     13    Schedules schedules;
    1514
    1615    // XMLシリアライズ用
    … …  
    2322        ar & BOOST_SERIALIZATION_NVP( _buffer );
    2423        ar & BOOST_SERIALIZATION_NVP( size );
     24        ar & BOOST_SERIALIZATION_NVP( schedules );
    2525
    2626        // 読み込み後の処理
    … …  
    5252        ar & BOOST_SERIALIZATION_NVP( _buffer );
    5353        ar & BOOST_SERIALIZATION_NVP( size );
     54        ar & BOOST_SERIALIZATION_NVP( schedules );
     55    }
     56
     57
     58    void Realloc( int size )
     59    {
     60        this->buffer = (char *)realloc( this->buffer, size + 100 );
     61        this->size = size;
    5462    }
    5563
    … …  
    92100    void Add( const DataTable &dataTable )
    93101    {
     102        long baseOffset = GetSize();
     103
    94104        AddBinary( dataTable.GetPtr(), dataTable.GetSize() );
     105
     106        // スケジュールを追加
     107        BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
     108        {
     109            this->schedules.push_back(
     110                Schedule(
     111                    schedule.GetType(),
     112                    baseOffset + schedule.GetOffset(),
     113                    schedule.GetLongPtrValue()
     114                )
     115            );
     116        }
    95117    }
    96118
    97     const void *GetPtr() const;
    98     int GetSize() const;
     119    const void *GetPtr() const
     120    {
     121        return buffer;
     122    }
     123    int GetSize() const
     124    {
     125        return size;
     126    }
     127
     128    long GetLong( int pos ) const
     129    {
     130        return *(long *)( buffer + pos );
     131    }
     132    _int64 GetInt64( int pos ) const
     133    {
     134        return *(_int64 *)( buffer + pos );
     135    }
     136    void Overwrite( int pos, long newLongValue )
     137    {
     138        *(long *)( buffer + pos ) = newLongValue;
     139    }
     140    void OverwriteInt64( int pos, _int64 new64Value )
     141    {
     142        *(_int64 *)( buffer + pos ) = new64Value;
     143    }
     144
     145    bool MakeConstObjectToProcessStaticBuffer( const CClass &objClass, const Jenga::Common::Strings &initMemberValues, int &dataTableOffset );
     146    bool MakeConstObjectToProcessStaticBuffer( const char *expression, Type &resultType, int &dataTableOffset );
     147    int MakeConstStringObjectToProcessStaticBuffer( const char *str );
     148    bool MakeLiteralArrayBuffer( const char *expression, const Type &baseType, int &dataTableOffset );
     149
     150private:
     151    int lastMadeConstObjectDataTableOffset;
     152public:
     153    int GetLastMadeConstObjectDataTableOffset()
     154    {
     155        return lastMadeConstObjectDataTableOffset;
     156    }
     157
     158    void ResetDataSectionBaseOffset( long dataSectionBaseOffset );
    99159};

  • trunk/abdev/BasicCompiler_Common/include/Linker.h

    r282 r355  
    44{
    55    NativeCode nativeCode;
     6    DataTable dataTable;
    67    DWORD imageBase;
    78
    … …  
    1516    {
    1617        return nativeCode;
     18    }
     19
     20    const DataTable &GetDataTable() const
     21    {
     22        return dataTable;
    1723    }
    1824
    … …  
    3743    void ResolveVtblSchedule( long dataSectionBaseOffset );
    3844
     45    // TypeInfoスケジュール
     46    void ResolveTypeInfoSchedule( long dataSectionBaseOffset );
     47
    3948    // リンク
    4049    void Link( ObjectModule &masterObjectModule );
     50
     51    // データテーブルをセット
     52    void SetDataTable( DataTable &dataTable );
    4153};

  • trunk/abdev/BasicCompiler_Common/include/NamespaceSupporter.h

    r215 r355  
    5353
    5454        while( tempLivingNamespaceScopes.size() ){
    55             NamespaceScopes tempNamespaceScopes = tempLivingNamespaceScopes;
    56 
    57             string tempStr = tempNamespaceScopes.ToString() + "." + entryName;
     55            string tempStr = tempLivingNamespaceScopes.ToString() + "." + entryName;
    5856            if( thisStr == tempStr ){
    5957                return true;

  • trunk/abdev/BasicCompiler_Common/include/NativeCode.h

    r287 r355  
    2424        DllProc,        // DLL関数位置スケジュール
    2525        Vtbl,           // vtblスケジュール
     26        TypeInfo,       // TypeInfoスケジュール
    2627    };
    2728
    … …  
    5758            break;
    5859        case Vtbl:
     60        case TypeInfo:
    5961            ar & boost::serialization::make_nvp("pClass", const_cast<::CClass *&>(pClass));
    6062            break;
    … …  
    9395    {
    9496    }
     97    Schedule( Type type, const ::CClass *pClass, long offset )
     98        : type( type )
     99        , pClass( pClass )
     100        , offset( offset )
     101    {
     102    }
    95103    ~Schedule()
    96104    {
    … …  
    127135    const ::CClass &GetClass() const
    128136    {
    129         if( type != Schedule::Vtbl )
     137        if( !( type == Schedule::Vtbl || type == Schedule::TypeInfo ) )
    130138        {
    131139            SetError();

  • trunk/abdev/BasicCompiler_Common/include/ver.h

    r354 r355  
    66// バージョン付加文字列
    77#ifdef _AMD64_
    8 #define VER_INFO        "(x64) (rev.361)"
     8#define VER_INFO        "(x64) (rev.367)"
    99#else
    10 #define VER_INFO        "(rev.361)"
     10#define VER_INFO        "(rev.367)"
    1111#endif

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

    r353 r355  
    12941294        compiler.GetNamespaceSupporter().GetLivingNamespaceScopes() = objClass.GetNamespaceScopes();
    12951295
     1296        DWORD dwFlags = 0;
     1297        if( objClass.GetName() == "_System_TypeBase" )
     1298        {
     1299            // _System_TypeBaseクラスはグローバル、スタティック領域を初期化するためのクラスなのでここでの初期化は除外する
     1300            dwFlags |= DIMFLAG_NONCALL_CONSTRACTOR;
     1301        }
     1302
    12961303        int i=0;
    12971304        BOOST_FOREACH( CMember *member, objClass.GetStaticMembers() ){
    … …  
    13041311                member->GetInitializeExpression().c_str(),
    13051312                member->GetConstructParameter().c_str(),
    1306                 0);
     1313                dwFlags);
    13071314
    13081315            i++;
    … …  
    18921899            // 未使用のクラスは無視する
    18931900            continue;
    1894         }
     1901        }   
    18951902
    18961903        char referenceOffsetsBuffer[1024] = "";
    … …  
    19111918
    19121919        sprintf( temporary
    1913             , "Add(%c%c_System_TypeForClass(\"%s\",\"%s\",[%s],%d))"
     1920            , "Add(%c%c_System_TypeForClass[strNamespace=\"%s\",name=\"%s\",fullName=\"%s\",referenceOffsets=[%s],numOfReference=%d])"
    19141921            , 1
    1915             , ESC_NEW
    1916             , ""                            // 名前空間 (TODO: 実装)
    1917             , objClass.GetName().c_str()    // クラス名
    1918             , referenceOffsetsBuffer        // 参照メンバオフセット配列
    1919             , numOfReference                // 参照メンバの個数
     1922            , ESC_SYSTEM_STATIC_NEW
     1923            , objClass.GetNamespaceScopes().ToString().c_str()      // 名前空間
     1924            , objClass.GetName().c_str()                            // クラス名
     1925            , objClass.GetFullName().c_str()                        // フルネーム
     1926            , referenceOffsetsBuffer                                // 参照メンバオフセット配列
     1927            , numOfReference                                        // 参照メンバの個数
    19201928            );
    19211929
    19221930        // コンパイル
    19231931        ChangeOpcode( temporary );
    1924     }
    1925 
    1926 
     1932
     1933        objClass.SetTypeInfoDataTableOffset(
     1934            compiler.GetObjectModule().dataTable.GetLastMadeConstObjectDataTableOffset()
     1935        );
     1936    }
     1937}
     1938void Classes::Compile_System_InitializeUserTypesForBaseType()
     1939{
     1940    extern int cp;
     1941    cp = -1;
    19271942    ////////////////////////////////////////////////////////////////////
    19281943    // 基底クラスを登録
    19291944    ////////////////////////////////////////////////////////////////////
    19301945
     1946    char temporary[VN_SIZE];
    19311947    sprintf(temporary, "%c%ctempType=Nothing%c%cTypeBaseImpl"
    19321948        , HIBYTE( COM_DIM )
    … …  
    19501966        if( objClass.HasSuperClass() ){
    19511967            sprintf( temporary
    1952                 , "tempType=Search(\"%s\",\"%s\")"
    1953                 , ""                            // 名前空間 (TODO: 実装)
    1954                 , objClass.GetName().c_str()    // クラス名
     1968                , "tempType=Search(\"%s\")"
     1969                , objClass.GetFullName().c_str()
    19551970                );
    19561971
    … …  
    19591974
    19601975            sprintf( temporary
    1961                 , "tempType.SetBaseType(Search(\"%s\",\"%s\"))"
    1962                 , ""                                // 名前空間 (TODO: 実装)
    1963                 , objClass.GetSuperClass().GetName().c_str()    // 基底クラス名
     1976                , "tempType.SetBaseType(Search(\"%s\"))"
     1977                , objClass.GetSuperClass().GetFullName().c_str()
    19641978                );
    19651979

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

    r273 r355  
    7171}
    7272
    73 const void *DataTable::GetPtr() const
    74 {
    75     return buffer;
    76 }
    77 int DataTable::GetSize() const
    78 {
    79     return size;
    80 }
     73bool DataTable::MakeConstObjectToProcessStaticBuffer( const CClass &objClass, const Jenga::Common::Strings &initMemberValues, int &dataTableOffset )
     74{
     75    // クラスに必要なバッファサイズを取得
     76    int size = objClass.GetSize();
     77
     78    // クラスのバッファイメージを作成
     79    BYTE *buffer = (BYTE *)calloc( size, 1 );
     80
     81    // クラスのバッファイメージをデータ領域へ追加
     82    dataTableOffset = this->AddBinary( buffer, size );
     83
     84    this->lastMadeConstObjectDataTableOffset = dataTableOffset;
     85
     86    // vtblスケジュール
     87    this->schedules.push_back( Schedule( &objClass, dataTableOffset ) );
     88
     89    // TypeInfoスケジュール
     90    int offsetForTypeInfo = objClass.GetMemberOffset( "typeInfo" );
     91    //this->schedules.push_back( Schedule( Schedule::TypeInfo, &objClass, dataTableOffset + offsetForTypeInfo ) );
     92
     93    BOOST_FOREACH( const std::string &initMemberValue, initMemberValues )
     94    {
     95        int i = 0;
     96
     97        // メンバ名
     98        char memberName[VN_SIZE];
     99        for( i=0; ; i++ )
     100        {
     101            if( initMemberValue[i] == '\0' )
     102            {
     103                // エラー
     104                SetError();
     105                return false;
     106            }
     107            if( initMemberValue[i] == '=' )
     108            {
     109                memberName[i] = 0;
     110                break;
     111            }
     112            memberName[i] = initMemberValue[i];
     113        }
     114
     115        // 初期値
     116        const char *initValue = initMemberValue.c_str() + i + 1;
     117
     118        // メンバを取得
     119        const CMember *member = objClass.FindDynamicMember( memberName );
     120
     121        // メンバオフセットを取得
     122        int memberOffset = objClass.GetMemberOffset( member->GetName().c_str() );
     123
     124        if( member->GetType().IsPointer() && initValue[0] == '[' )
     125        {
     126            // ポインタ型でバッファ指定のとき
     127            int memberDataTableOffset;
     128            if( !this->MakeLiteralArrayBuffer( initValue, member->GetType(),memberDataTableOffset ) )
     129            {
     130                return false;
     131            }
     132
     133            this->Overwrite( dataTableOffset + memberOffset, memberDataTableOffset );
     134            this->schedules.push_back( Schedule( Schedule::DataTable, dataTableOffset + memberOffset ) );
     135        }
     136        else if( member->GetType().IsWhole() )
     137        {
     138            // 整数
     139            Type resultType;
     140            _int64 i64data;
     141            if( !StaticCalculation( true, initValue, member->GetType().GetBasicType(), &i64data, resultType ) ){
     142                return false;
     143            }
     144
     145            this->Overwrite( dataTableOffset + memberOffset, static_cast<long>(i64data) );
     146        }
     147        else if( member->GetType().IsStringClass() )
     148        {
     149            // 文字列型
     150            char temporary[VN_SIZE];
     151            lstrcpy( temporary, initValue );
     152            RemoveStringQuotes( temporary );
     153            int memberDataTableOffset = MakeConstStringObjectToProcessStaticBuffer( temporary );
     154            this->Overwrite( dataTableOffset + memberOffset, memberDataTableOffset );
     155            this->schedules.push_back( Schedule( Schedule::DataTable, dataTableOffset + memberOffset ) );
     156        }
     157    }
     158
     159    return true;
     160}
     161bool DataTable::MakeConstObjectToProcessStaticBuffer( const char *expression, Type &resultType, int &dataTableOffset )
     162{
     163    char CreateParameter[VN_SIZE];
     164    int i,i2;
     165
     166    i=0;
     167
     168    // クラス名を取得
     169    char typeName[VN_SIZE];
     170    for(i2=0;;i++,i2++){
     171        if(expression[i]=='['){
     172            typeName[i2]=0;
     173
     174            // メンバの初期値を取得
     175            i2=GetStringInBracket(CreateParameter,expression+i);
     176            RemoveStringBracket(CreateParameter);
     177            i+=i2;
     178            if(expression[i]!='\0'){
     179                SetError(42,NULL,cp);
     180                return false;
     181            }
     182            break;
     183        }
     184        typeName[i2]=expression[i];
     185        if(expression[i]=='\0'){
     186            CreateParameter[0]=0;
     187            break;
     188        }
     189    }
     190
     191    // パラメータを取得
     192    Jenga::Common::Strings initMemberValues;
     193    SplitParameter( CreateParameter, initMemberValues );
     194
     195    if( !compiler.StringToType( typeName, resultType ) ){
     196        SetError(3,typeName,cp);
     197        return false;
     198    }
     199
     200    if( !resultType.IsObject() ){
     201        ////////////////////////
     202        // 通常のデータ型の場合
     203        ////////////////////////
     204
     205        SetError(121,NULL,cp);
     206        return false;
     207    }
     208
     209    return MakeConstObjectToProcessStaticBuffer( resultType.GetClass(), initMemberValues, dataTableOffset );
     210}
     211
     212int DataTable::MakeConstStringObjectToProcessStaticBuffer( const char *str )
     213{
     214    const CClass &strClass = *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
     215    const CClass &objClass = strClass.GetSuperClass();
     216
     217    // クラスに必要なバッファサイズを取得
     218    int size = strClass.GetSize();
     219
     220    // メンバ位置を取得
     221    int offsetForTypeInfo = strClass.GetMemberOffset( "typeInfo" );
     222    int offsetForLength = strClass.GetMemberOffset( "m_Length" );
     223    int offsetForChars = strClass.GetMemberOffset( "Chars" );
     224
     225    // 現在のデータ領域のヘッダ位置を取得
     226    int headOffset = this->GetSize();
     227
     228    // クラスのバッファイメージを作成
     229    BYTE *buffer = (BYTE *)calloc( size, 1 );
     230    *(long *)(buffer + offsetForLength) = lstrlen( str );
     231    *(LONG_PTR *)(buffer + offsetForChars) = headOffset + size;
     232
     233    // クラスのバッファイメージをデータ領域へ追加
     234    int dataTableOffset = this->AddBinary( buffer, size );
     235
     236    // スケジューリング
     237    this->schedules.push_back( Schedule( &strClass, headOffset ) );
     238    this->schedules.push_back( Schedule( Schedule::TypeInfo, &strClass, headOffset + offsetForTypeInfo ) );
     239    this->schedules.push_back( Schedule( Schedule::DataTable, headOffset + offsetForChars ) );
     240
     241    // 文字列バッファをデータ領域へ追加
     242    this->AddString( str );
     243
     244    return dataTableOffset;
     245}
     246
     247bool DataTable::MakeLiteralArrayBuffer( const char *expression, const Type &baseType, int &dataTableOffset )
     248{
     249    if( !baseType.IsPointer() ){
     250        SetError(1,NULL,cp);
     251        return false;
     252    }
     253    Type tempBaseType( baseType );
     254    tempBaseType.PtrLevelDown();
     255
     256    char *buffer = (char *)malloc( lstrlen( expression ) + 1 );
     257    lstrcpy( buffer, expression );
     258    RemoveStringBracket( buffer );
     259
     260    void *binary = malloc( 1 );
     261    int num = 0;
     262
     263    int i = 0;
     264    bool isSuccessful = true;
     265    while( buffer[i] ){
     266        char temporary[1024];
     267
     268        i = GetOneParameter( buffer, i, temporary );
     269        if( buffer[i] == ',' ){
     270            i++;
     271        }
     272
     273        Type resultType;
     274        _int64 i64data;
     275        if( !StaticCalculation( true, temporary, tempBaseType.GetBasicType(), &i64data, resultType ) ){
     276            isSuccessful = false;
     277            break;
     278        }
     279        if( !resultType.IsWhole() ){
     280            // TODO: 実数に未対応
     281            SetError();
     282            isSuccessful = false;
     283            break;
     284        }
     285
     286        binary = realloc( binary, ( num + 1 ) * tempBaseType.GetSize() );
     287        memcpy( (char *)binary + (num * tempBaseType.GetSize()), &i64data, tempBaseType.GetSize() );
     288        num++;
     289    }
     290
     291    free( buffer );
     292
     293    dataTableOffset = this->AddBinary( binary, num * tempBaseType.GetSize() );
     294
     295    free( binary );
     296
     297    return isSuccessful;
     298}
     299
     300void DataTable::ResetDataSectionBaseOffset( long dataSectionBaseOffset )
     301{
     302    BOOST_FOREACH( const Schedule &schedule, schedules )
     303    {
     304        if( schedule.GetType() == Schedule::DataTable )
     305        {
     306#ifdef _WIN64
     307            OverwriteInt64(
     308                schedule.GetOffset(),
     309                GetInt64( schedule.GetOffset() ) + dataSectionBaseOffset
     310            );
     311#else
     312            Overwrite(
     313                schedule.GetOffset(),
     314                GetLong( schedule.GetOffset() ) + dataSectionBaseOffset
     315            );
     316#endif
     317        }
     318    }
     319}

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

    r342 r355  
    1717        }
    1818    }
     19
     20    BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
     21    {
     22        if( schedule.GetType() == Schedule::DataTable )
     23        {
     24#ifdef _WIN64
     25            dataTable.OverwriteInt64(
     26                schedule.GetOffset(),
     27                dataTable.GetInt64( schedule.GetOffset() ) + imageBase + dataSectionBaseOffset
     28            );
     29#else
     30            dataTable.Overwrite(
     31                schedule.GetOffset(),
     32                dataTable.GetLong( schedule.GetOffset() ) + imageBase + dataSectionBaseOffset
     33            );
     34#endif
     35        }
     36    }
    1937}
    2038
    … …  
    116134        }
    117135    }
     136
     137    BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
     138    {
     139        if( schedule.GetType() == Schedule::Vtbl )
     140        {
     141            LONG_PTR vtblMasterListOffset = schedule.GetClass().GetVtblMasterListOffset();
     142
     143#ifdef _WIN64
     144            dataTable.OverwriteInt64(
     145                schedule.GetOffset(),
     146                vtblMasterListOffset + imageBase + dataSectionBaseOffset
     147            );
     148#else
     149            dataTable.Overwrite(
     150                schedule.GetOffset(),
     151                vtblMasterListOffset + imageBase + dataSectionBaseOffset
     152            );
     153#endif
     154        }
     155    }
     156}
     157
     158void Linker::ResolveTypeInfoSchedule( long dataSectionBaseOffset )
     159{
     160    BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
     161    {
     162        if( schedule.GetType() == Schedule::TypeInfo )
     163        {
     164            LONG_PTR typeInfoDataTableOffset = schedule.GetClass().GetTypeInfoDataTableOffset();
     165
     166#ifdef _WIN64
     167            dataTable.OverwriteInt64(
     168                schedule.GetOffset(),
     169                typeInfoDataTableOffset + imageBase + dataSectionBaseOffset
     170            );
     171#else
     172            dataTable.Overwrite(
     173                schedule.GetOffset(),
     174                typeInfoDataTableOffset + imageBase + dataSectionBaseOffset
     175            );
     176#endif
     177        }
     178    }
    118179}
    119180
    … …  
    143204    }
    144205}
     206
     207void Linker::SetDataTable( DataTable &dataTable )
     208{
     209    this->dataTable.Add( dataTable );
     210}

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

    r322 r355  
    2626
    2727    // データテーブルを結合
     28    objectModule.dataTable.ResetDataSectionBaseOffset( dataSectionBaseOffset );
    2829    dataTable.Add( objectModule.dataTable );
    2930
Note: See TracChangeset for help on using the changeset viewer.