Changeset 355 in dev for trunk/abdev/BasicCompiler_Common/src

Timestamp:

Nov 2, 2007, 2:53:56 AM (17 years ago)

Author:

dai_9181

Message:

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

Location:

trunk/abdev/BasicCompiler_Common/src

Files:

• Class.cpp (modified) (6 diffs)
• DataTable.cpp (modified) (1 diff)
• Linker.cpp (modified) (3 diffs)
• ObjectModule.cpp (modified) (1 diff)

trunk/abdev/BasicCompiler_Common/src/Class.cpp

@@ -1294 +1294 @@
         compiler.GetNamespaceSupporter().GetLivingNamespaceScopes() = objClass.GetNamespaceScopes();
 
+        DWORD dwFlags = 0;
+        if( objClass.GetName() == "_System_TypeBase" )
+        {
+            // _System_TypeBaseクラスはグローバル、スタティック領域を初期化するためのクラスなのでここでの初期化は除外する
+            dwFlags |= DIMFLAG_NONCALL_CONSTRACTOR;
+        }
+
         int i=0;
         BOOST_FOREACH( CMember *member, objClass.GetStaticMembers() ){
@@ -1304 +1311 @@
                 member->GetInitializeExpression().c_str(),
                 member->GetConstructParameter().c_str(),
-                0);
+                dwFlags);
 
             i++;
@@ -1892 +1899 @@
             // 未使用のクラスは無視する
             continue;
-        }
+        }   
 
         char referenceOffsetsBuffer[1024] = "";
@@ -1911 +1918 @@
 
         sprintf( temporary
-            , "Add(%c%c_System_TypeForClass(\"%s\",\"%s\",[%s],%d))"
+            , "Add(%c%c_System_TypeForClass[strNamespace=\"%s\",name=\"%s\",fullName=\"%s\",referenceOffsets=[%s],numOfReference=%d])"
             , 1
-            , ESC_NEW
-            , ""                            // 名前空間 (TODO: 実装)
-            , objClass.GetName().c_str()    // クラス名
-            , referenceOffsetsBuffer        // 参照メンバオフセット配列
-            , numOfReference                // 参照メンバの個数
+            , ESC_SYSTEM_STATIC_NEW
+            , objClass.GetNamespaceScopes().ToString().c_str()      // 名前空間
+            , objClass.GetName().c_str()                            // クラス名
+            , objClass.GetFullName().c_str()                        // フルネーム
+            , referenceOffsetsBuffer                                // 参照メンバオフセット配列
+            , numOfReference                                        // 参照メンバの個数
             );
 
         // コンパイル
         ChangeOpcode( temporary );
-    }
-
-
+
+        objClass.SetTypeInfoDataTableOffset(
+            compiler.GetObjectModule().dataTable.GetLastMadeConstObjectDataTableOffset()
+        );
+    }
+}
+void Classes::Compile_System_InitializeUserTypesForBaseType()
+{
+    extern int cp;
+    cp = -1;
     ////////////////////////////////////////////////////////////////////
     // 基底クラスを登録
     ////////////////////////////////////////////////////////////////////
 
+    char temporary[VN_SIZE];
     sprintf(temporary, "%c%ctempType=Nothing%c%cTypeBaseImpl"
         , HIBYTE( COM_DIM )
@@ -1950 +1966 @@
         if( objClass.HasSuperClass() ){
             sprintf( temporary
-                , "tempType=Search(\"%s\",\"%s\")"
-                , ""                            // 名前空間 (TODO: 実装)
-                , objClass.GetName().c_str()    // クラス名
+                , "tempType=Search(\"%s\")"
+                , objClass.GetFullName().c_str()
                 );
 
@@ -1959 +1974 @@
 
             sprintf( temporary
-                , "tempType.SetBaseType(Search(\"%s\",\"%s\"))"
-                , ""                                // 名前空間 (TODO: 実装)
-                , objClass.GetSuperClass().GetName().c_str()    // 基底クラス名
+                , "tempType.SetBaseType(Search(\"%s\"))"
+                , objClass.GetSuperClass().GetFullName().c_str()
                 );
 

trunk/abdev/BasicCompiler_Common/src/DataTable.cpp

@@ -71 +71 @@
 }
 
-const void *DataTable::GetPtr() const
-{
-    return buffer;
-}
-int DataTable::GetSize() const
-{
-    return size;
-}
+bool DataTable::MakeConstObjectToProcessStaticBuffer( const CClass &objClass, const Jenga::Common::Strings &initMemberValues, int &dataTableOffset )
+{
+    // クラスに必要なバッファサイズを取得
+    int size = objClass.GetSize();
+
+    // クラスのバッファイメージを作成
+    BYTE *buffer = (BYTE *)calloc( size, 1 );
+
+    // クラスのバッファイメージをデータ領域へ追加
+    dataTableOffset = this->AddBinary( buffer, size );
+
+    this->lastMadeConstObjectDataTableOffset = dataTableOffset;
+
+    // vtblスケジュール
+    this->schedules.push_back( Schedule( &objClass, dataTableOffset ) );
+
+    // TypeInfoスケジュール
+    int offsetForTypeInfo = objClass.GetMemberOffset( "typeInfo" );
+    //this->schedules.push_back( Schedule( Schedule::TypeInfo, &objClass, dataTableOffset + offsetForTypeInfo ) );
+
+    BOOST_FOREACH( const std::string &initMemberValue, initMemberValues )
+    {
+        int i = 0;
+
+        // メンバ名
+        char memberName[VN_SIZE];
+        for( i=0; ; i++ )
+        {
+            if( initMemberValue[i] == '\0' )
+            {
+                // エラー
+                SetError();
+                return false;
+            }
+            if( initMemberValue[i] == '=' )
+            {
+                memberName[i] = 0;
+                break;
+            }
+            memberName[i] = initMemberValue[i];
+        }
+
+        // 初期値
+        const char *initValue = initMemberValue.c_str() + i + 1;
+
+        // メンバを取得
+        const CMember *member = objClass.FindDynamicMember( memberName );
+
+        // メンバオフセットを取得
+        int memberOffset = objClass.GetMemberOffset( member->GetName().c_str() );
+
+        if( member->GetType().IsPointer() && initValue[0] == '[' )
+        {
+            // ポインタ型でバッファ指定のとき
+            int memberDataTableOffset;
+            if( !this->MakeLiteralArrayBuffer( initValue, member->GetType(),memberDataTableOffset ) )
+            {
+                return false;
+            }
+
+            this->Overwrite( dataTableOffset + memberOffset, memberDataTableOffset );
+            this->schedules.push_back( Schedule( Schedule::DataTable, dataTableOffset + memberOffset ) );
+        }
+        else if( member->GetType().IsWhole() )
+        {
+            // 整数
+            Type resultType;
+            _int64 i64data;
+            if( !StaticCalculation( true, initValue, member->GetType().GetBasicType(), &i64data, resultType ) ){
+                return false;
+            }
+
+            this->Overwrite( dataTableOffset + memberOffset, static_cast<long>(i64data) );
+        }
+        else if( member->GetType().IsStringClass() )
+        {
+            // 文字列型
+            char temporary[VN_SIZE];
+            lstrcpy( temporary, initValue );
+            RemoveStringQuotes( temporary );
+            int memberDataTableOffset = MakeConstStringObjectToProcessStaticBuffer( temporary );
+            this->Overwrite( dataTableOffset + memberOffset, memberDataTableOffset );
+            this->schedules.push_back( Schedule( Schedule::DataTable, dataTableOffset + memberOffset ) );
+        }
+    }
+
+    return true;
+}
+bool DataTable::MakeConstObjectToProcessStaticBuffer( const char *expression, Type &resultType, int &dataTableOffset )
+{
+    char CreateParameter[VN_SIZE];
+    int i,i2;
+
+    i=0;
+
+    // クラス名を取得
+    char typeName[VN_SIZE];
+    for(i2=0;;i++,i2++){
+        if(expression[i]=='['){
+            typeName[i2]=0;
+
+            // メンバの初期値を取得
+            i2=GetStringInBracket(CreateParameter,expression+i);
+            RemoveStringBracket(CreateParameter);
+            i+=i2;
+            if(expression[i]!='\0'){
+                SetError(42,NULL,cp);
+                return false;
+            }
+            break;
+        }
+        typeName[i2]=expression[i];
+        if(expression[i]=='\0'){
+            CreateParameter[0]=0;
+            break;
+        }
+    }
+
+    // パラメータを取得
+    Jenga::Common::Strings initMemberValues;
+    SplitParameter( CreateParameter, initMemberValues );
+
+    if( !compiler.StringToType( typeName, resultType ) ){
+        SetError(3,typeName,cp);
+        return false;
+    }
+
+    if( !resultType.IsObject() ){
+        ////////////////////////
+        // 通常のデータ型の場合
+        ////////////////////////
+
+        SetError(121,NULL,cp);
+        return false;
+    }
+
+    return MakeConstObjectToProcessStaticBuffer( resultType.GetClass(), initMemberValues, dataTableOffset );
+}
+
+int DataTable::MakeConstStringObjectToProcessStaticBuffer( const char *str )
+{
+    const CClass &strClass = *compiler.GetObjectModule().meta.GetClasses().GetStringClassPtr();
+    const CClass &objClass = strClass.GetSuperClass();
+
+    // クラスに必要なバッファサイズを取得
+    int size = strClass.GetSize();
+
+    // メンバ位置を取得
+    int offsetForTypeInfo = strClass.GetMemberOffset( "typeInfo" );
+    int offsetForLength = strClass.GetMemberOffset( "m_Length" );
+    int offsetForChars = strClass.GetMemberOffset( "Chars" );
+
+    // 現在のデータ領域のヘッダ位置を取得
+    int headOffset = this->GetSize();
+
+    // クラスのバッファイメージを作成
+    BYTE *buffer = (BYTE *)calloc( size, 1 );
+    *(long *)(buffer + offsetForLength) = lstrlen( str );
+    *(LONG_PTR *)(buffer + offsetForChars) = headOffset + size;
+
+    // クラスのバッファイメージをデータ領域へ追加
+    int dataTableOffset = this->AddBinary( buffer, size );
+
+    // スケジューリング
+    this->schedules.push_back( Schedule( &strClass, headOffset ) );
+    this->schedules.push_back( Schedule( Schedule::TypeInfo, &strClass, headOffset + offsetForTypeInfo ) );
+    this->schedules.push_back( Schedule( Schedule::DataTable, headOffset + offsetForChars ) );
+
+    // 文字列バッファをデータ領域へ追加
+    this->AddString( str );
+
+    return dataTableOffset;
+}
+
+bool DataTable::MakeLiteralArrayBuffer( const char *expression, const Type &baseType, int &dataTableOffset )
+{
+    if( !baseType.IsPointer() ){
+        SetError(1,NULL,cp);
+        return false;
+    }
+    Type tempBaseType( baseType );
+    tempBaseType.PtrLevelDown();
+
+    char *buffer = (char *)malloc( lstrlen( expression ) + 1 );
+    lstrcpy( buffer, expression );
+    RemoveStringBracket( buffer );
+
+    void *binary = malloc( 1 );
+    int num = 0;
+
+    int i = 0;
+    bool isSuccessful = true;
+    while( buffer[i] ){
+        char temporary[1024];
+
+        i = GetOneParameter( buffer, i, temporary );
+        if( buffer[i] == ',' ){
+            i++;
+        }
+
+        Type resultType;
+        _int64 i64data;
+        if( !StaticCalculation( true, temporary, tempBaseType.GetBasicType(), &i64data, resultType ) ){
+            isSuccessful = false;
+            break;
+        }
+        if( !resultType.IsWhole() ){
+            // TODO: 実数に未対応
+            SetError();
+            isSuccessful = false;
+            break;
+        }
+
+        binary = realloc( binary, ( num + 1 ) * tempBaseType.GetSize() );
+        memcpy( (char *)binary + (num * tempBaseType.GetSize()), &i64data, tempBaseType.GetSize() );
+        num++;
+    }
+
+    free( buffer );
+
+    dataTableOffset = this->AddBinary( binary, num * tempBaseType.GetSize() );
+
+    free( binary );
+
+    return isSuccessful;
+}
+
+void DataTable::ResetDataSectionBaseOffset( long dataSectionBaseOffset )
+{
+    BOOST_FOREACH( const Schedule &schedule, schedules )
+    {
+        if( schedule.GetType() == Schedule::DataTable )
+        {
+#ifdef _WIN64
+            OverwriteInt64(
+                schedule.GetOffset(),
+                GetInt64( schedule.GetOffset() ) + dataSectionBaseOffset
+            );
+#else
+            Overwrite(
+                schedule.GetOffset(),
+                GetLong( schedule.GetOffset() ) + dataSectionBaseOffset
+            );
+#endif
+        }
+    }
+}

trunk/abdev/BasicCompiler_Common/src/Linker.cpp

@@ -17 +17 @@
         }
     }
+
+    BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
+    {
+        if( schedule.GetType() == Schedule::DataTable )
+        {
+#ifdef _WIN64
+            dataTable.OverwriteInt64(
+                schedule.GetOffset(),
+                dataTable.GetInt64( schedule.GetOffset() ) + imageBase + dataSectionBaseOffset
+            );
+#else
+            dataTable.Overwrite(
+                schedule.GetOffset(),
+                dataTable.GetLong( schedule.GetOffset() ) + imageBase + dataSectionBaseOffset
+            );
+#endif
+        }
+    }
 }
 
@@ -116 +134 @@
         }
     }
+
+    BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
+    {
+        if( schedule.GetType() == Schedule::Vtbl )
+        {
+            LONG_PTR vtblMasterListOffset = schedule.GetClass().GetVtblMasterListOffset();
+
+#ifdef _WIN64
+            dataTable.OverwriteInt64(
+                schedule.GetOffset(),
+                vtblMasterListOffset + imageBase + dataSectionBaseOffset
+            );
+#else
+            dataTable.Overwrite(
+                schedule.GetOffset(),
+                vtblMasterListOffset + imageBase + dataSectionBaseOffset
+            );
+#endif
+        }
+    }
+}
+
+void Linker::ResolveTypeInfoSchedule( long dataSectionBaseOffset )
+{
+    BOOST_FOREACH( const Schedule &schedule, dataTable.schedules )
+    {
+        if( schedule.GetType() == Schedule::TypeInfo )
+        {
+            LONG_PTR typeInfoDataTableOffset = schedule.GetClass().GetTypeInfoDataTableOffset();
+
+#ifdef _WIN64
+            dataTable.OverwriteInt64(
+                schedule.GetOffset(),
+                typeInfoDataTableOffset + imageBase + dataSectionBaseOffset
+            );
+#else
+            dataTable.Overwrite(
+                schedule.GetOffset(),
+                typeInfoDataTableOffset + imageBase + dataSectionBaseOffset
+            );
+#endif
+        }
+    }
 }
 
@@ -143 +204 @@
     }
 }
+
+void Linker::SetDataTable( DataTable &dataTable )
+{
+    this->dataTable.Add( dataTable );
+}

trunk/abdev/BasicCompiler_Common/src/ObjectModule.cpp

@@ -26 +26 @@
 
     // データテーブルを結合
+    objectModule.dataTable.ResetDataSectionBaseOffset( dataSectionBaseOffset );
     dataTable.Add( objectModule.dataTable );