Changeset 248 in dev for trunk/abdev/BasicCompiler_Common

Timestamp:

Jul 29, 2007, 12:33:04 PM (17 years ago)

Author:

dai_9181

Message:

BreakPertialScheduleをリファクタリング

Location:

trunk/abdev/BasicCompiler_Common

Files:

• Compile.cpp (modified) (4 diffs)
• VariableOpe.cpp (modified) (2 diffs)
• include/CodeGenerator.h (modified) (4 diffs)
• include/LexicalScope.h (moved) (moved from trunk/abdev/BasicCompiler_Common/include/LexicalScopingImpl.h ) (1 diff)
• src/CommonCodeGenerator.cpp (modified) (3 diffs)
• src/LexicalScope.cpp (moved) (moved from trunk/abdev/BasicCompiler_Common/src/LexicalScopingImpl.cpp ) (5 diffs)
• src/SmoothieImpl.cpp (modified) (1 diff)
• src/Variable.cpp (modified) (2 diffs)

trunk/abdev/BasicCompiler_Common/Compile.cpp

@@ -5 +5 @@
 #include <jenga/include/smoothie/SmoothieException.h>
 
-#include <LexicalScopingImpl.h>
+#include <LexicalScope.h>
 #include <CodeGenerator.h>
 #include <Compiler.h>
@@ -173 +173 @@
             case ESC_EXITWHILE:
                 {
-                    CScope *pScope = GetLexicalScopes().SearchScope( SCOPE_TYPE_WHILE );
+                    LexicalScope *pScope = compiler.codeGenerator.lexicalScopes.SearchScope( LexicalScope::SCOPE_TYPE_WHILE );
                     if( !pScope ){
                         SetError(12,"Exit While",cp);
@@ -183 +183 @@
             case ESC_EXITFOR:
                 {
-                    CScope *pScope = GetLexicalScopes().SearchScope( SCOPE_TYPE_FOR );
+                    LexicalScope *pScope = compiler.codeGenerator.lexicalScopes.SearchScope( LexicalScope::SCOPE_TYPE_FOR );
                     if( !pScope ){
                         SetError(12,"Exit For",cp);
@@ -193 +193 @@
             case ESC_EXITDO:
                 {
-                    CScope *pScope = GetLexicalScopes().SearchScope( SCOPE_TYPE_DO );
+                    LexicalScope *pScope = compiler.codeGenerator.lexicalScopes.SearchScope( LexicalScope::SCOPE_TYPE_DO );
                     if( !pScope ){
                         SetError(12,"Exit Do",cp);

trunk/abdev/BasicCompiler_Common/VariableOpe.cpp

@@ -5 +5 @@
 
 #include <Compiler.h>
-#include <LexicalScopingImpl.h>
+#include <LexicalScope.h>
 #include <Variable.h>
 #include <NamespaceSupporter.h>
@@ -989 +989 @@
 
     //レキシカルスコープ
-    pVar->SetScopeLevel( GetLexicalScopes().GetNowLevel() );
-    pVar->SetScopeStartAddress( GetLexicalScopes().GetStartAddress() );
+    pVar->SetScopeLevel( compiler.codeGenerator.lexicalScopes.GetNowLevel() );
+    pVar->SetScopeStartAddress( compiler.codeGenerator.lexicalScopes.GetStartAddress() );
     pVar->bLiving=TRUE;
 

trunk/abdev/BasicCompiler_Common/include/CodeGenerator.h

@@ -2 +2 @@
 
 #include <NativeCode.h>
+#include <LexicalScope.h>
 
 #ifdef _AMD64_
@@ -8 +9 @@
 #include "../../BasicCompiler32/MachineFixed.h"
 #endif
-
 
 void ReallocNativeCodeBuffer();
@@ -51 +51 @@
 };
 
+// コード生成時の部分的なスケジューリング
+class PertialSchedule
+{
+    int codePos;    // バッファ位置
+    int typeSize;   // 対象サイズ（一般的には8bit/32bit）
+
+    int _obpOld;    // 未完成
+public:
+    PertialSchedule( int codePos, int typeSize )
+        : codePos( codePos )
+        , typeSize( typeSize )
+    {
+        extern int obp;
+        _obpOld = obp;
+    }
+    ~PertialSchedule()
+    {
+    }
+
+    int GetCodePos() const
+    {
+        return codePos;
+    }
+    int GetTypeSize() const
+    {
+        return typeSize;
+    }
+    int GetObpOld() const
+    {
+        return _obpOld;
+    }
+};
+typedef std::vector<const PertialSchedule *> PertialSchedules;
+
+class LexicalScope
+{
+public:
+    enum SCOPE_TYPE{
+        //ベース
+        SCOPE_TYPE_BASE,
+
+        //分岐
+        SCOPE_TYPE_IF,
+
+        //ループ
+        SCOPE_TYPE_DO,
+        SCOPE_TYPE_FOR,
+        SCOPE_TYPE_WHILE,
+
+        //ケース分け
+        SCOPE_TYPE_SELECT,
+    };
+
+private:
+    int level;
+    int StartAddress;
+    SCOPE_TYPE TypeOfStatement;
+
+    PertialSchedules breakPertialSchedules;
+
+public:
+    LexicalScope( int level, int addr, SCOPE_TYPE TypeOfStatement )
+        : level( level )
+        , StartAddress( addr )
+        , TypeOfStatement( TypeOfStatement )
+    {
+    }
+    ~LexicalScope()
+    {
+    }
+
+    int GetStartAddress()
+    {
+        return StartAddress;
+    }
+    SCOPE_TYPE GetTypeOfStatement()
+    {
+        return TypeOfStatement;
+    }
+
+    void Break();
+    void RunScheduleOfBreak();
+};
+
+class LexicalScopes
+{
+    LexicalScope **ppScopes;
+    int level;
+
+public:
+
+    LexicalScopes(){
+        ppScopes = (LexicalScope **)malloc( 1 );
+        level=0;
+    }
+    ~LexicalScopes(){
+        free( ppScopes );
+    }
+
+    //初期化（関数コンパイルの開始時に呼び出される）
+    void Init(int addr);
+
+    // スコープを開始
+    void Start( int addr, LexicalScope::SCOPE_TYPE TypeOfStatement );
+
+    // スコープを検索
+    LexicalScope *SearchScope( LexicalScope::SCOPE_TYPE TypeOfStatement );
+
+    int GetNowLevel(void);
+    void SetNowLevel( int level );
+    int GetStartAddress(void);
+
+    void End();
+
+    //スコープ終了時のデストラクタ呼び出し
+    void CallDestructorsOfScopeEnd();
+
+    //Returnステートメント用のデストラクタ呼び出し
+    void CallDestructorsOfReturn( int BaseLevel = 0 );
+};
+
 class CodeGenerator
 {
     NativeCode *pNativeCode;
 
-public:
-
-    // コード生成時の部分的なスケジューリング
-    class PertialSchedule
-    {
-        int codePos;    // バッファ位置
-        int typeSize;   // 対象サイズ（一般的には8bit/32bit）
-
-        int _obpOld;    // 未完成
-    public:
-        PertialSchedule( int codePos, int typeSize )
-            : codePos( codePos )
-            , typeSize( typeSize )
-        {
-            extern int obp;
-            _obpOld = obp;
-        }
-        ~PertialSchedule()
-        {
-        }
-
-        int GetCodePos() const
-        {
-            return codePos;
-        }
-        int GetTypeSize() const
-        {
-            return typeSize;
-        }
-        int GetObpOld() const
-        {
-            return _obpOld;
-        }
-    };
-
 private:
     // 部分スケジュールの管理
-    typedef std::vector<const PertialSchedule *> PertialSchedules;
     PertialSchedules pertialSchedules;
 
@@ -107 +192 @@
     // Gotoスケジュールの管理
     std::vector<GotoLabelSchedule> gotoLabelSchedules;
+
+    // レキシカルスコープの管理
+    LexicalScopes lexicalScopes;
 
     CodeGenerator()

trunk/abdev/BasicCompiler_Common/include/LexicalScope.h

@@ -2 +2 @@
 
 #include <jenga/include/smoothie/Smoothie.h>
-#include <jenga/include/smoothie/LexicalScoping.h>
 
-class ScopeImpl : public CScope
-{
-public:
-    ScopeImpl( int level, int addr, SCOPE_TYPE TypeOfStatement )
-        : CScope( level, addr, TypeOfStatement )
-    {
-    }
-    ~ScopeImpl();
+#include <CodeGenerator.h>
 
-    virtual void Break();
-    virtual void RunScheduleOfBreak();
-};
-
-class LexicalScopesImpl : public CLexicalScopes
-{
-    virtual CScope *CreateScope( int level, int addr, SCOPE_TYPE TypeOfStatement )
-    {
-        return new ScopeImpl( level, addr, TypeOfStatement );
-    }
-
-public:
-
-    virtual void End();
-
-    //スコープ終了時のデストラクタ呼び出し
-    virtual void CallDestructorsOfScopeEnd();
-
-    //Returnステートメント用のデストラクタ呼び出し
-    virtual void CallDestructorsOfReturn( int BaseLevel = 0 );
-};
-
-LexicalScopesImpl &GetLexicalScopes();

trunk/abdev/BasicCompiler_Common/src/CommonCodeGenerator.cpp

@@ -33 +33 @@
     bool isSuccessful = false;
 
-    CodeGenerator::PertialSchedules::iterator it = pertialSchedules.begin();
+    PertialSchedules::iterator it = pertialSchedules.begin();
     while( it != pertialSchedules.end() )
     {
@@ -84 +84 @@
     }
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::__jmp_op_format( char opcode, long offset, int op_size, bool isPertialSchedule, bool isSelfOpcodeOffset )
+const PertialSchedule *CodeGenerator::__jmp_op_format( char opcode, long offset, int op_size, bool isPertialSchedule, bool isSelfOpcodeOffset )
 {
     long beginCodePos = pNativeCode->GetSize();
@@ -158 +158 @@
     return pPertialSchedule;
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_jle( long offset, int op_size, bool isPertialSchedule )
+const PertialSchedule *CodeGenerator::op_jle( long offset, int op_size, bool isPertialSchedule )
 {
     return __jmp_op_format( (char)0x0E, offset, op_size, isPertialSchedule );
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_jbe( long offset, int op_size, bool isPertialSchedule )
+const PertialSchedule *CodeGenerator::op_jbe( long offset, int op_size, bool isPertialSchedule )
 {
     return __jmp_op_format( (char)0x06, offset, op_size, isPertialSchedule );
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_jge( long offset, int op_size, bool isPertialSchedule )
+const PertialSchedule *CodeGenerator::op_jge( long offset, int op_size, bool isPertialSchedule )
 {
     return __jmp_op_format( (char)0x0D, offset, op_size, isPertialSchedule );
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_jae( long offset, int op_size, bool isPertialSchedule )
+const PertialSchedule *CodeGenerator::op_jae( long offset, int op_size, bool isPertialSchedule )
 {
     return __jmp_op_format( (char)0x03, offset, op_size, isPertialSchedule );
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_jl( long offset, int op_size, bool isPertialSchedule )
+const PertialSchedule *CodeGenerator::op_jl( long offset, int op_size, bool isPertialSchedule )
 {
     return __jmp_op_format( (char)0x0C, offset, op_size, isPertialSchedule );
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_jb( long offset, int op_size, bool isPertialSchedule )
+const PertialSchedule *CodeGenerator::op_jb( long offset, int op_size, bool isPertialSchedule )
 {
     return __jmp_op_format( (char)0x02, offset, op_size, isPertialSchedule );
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_jg( long offset, int op_size, bool isPertialSchedule )
+const PertialSchedule *CodeGenerator::op_jg( long offset, int op_size, bool isPertialSchedule )
 {
     return __jmp_op_format( (char)0x0F, offset, op_size, isPertialSchedule );
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_ja( long offset, int op_size, bool isPertialSchedule )
+const PertialSchedule *CodeGenerator::op_ja( long offset, int op_size, bool isPertialSchedule )
 {
     return __jmp_op_format( (char)0x07, offset, op_size, isPertialSchedule );
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_jne( long offset, int op_size, bool isPertialSchedule )
+const PertialSchedule *CodeGenerator::op_jne( long offset, int op_size, bool isPertialSchedule )
 {
     return __jmp_op_format( (char)0x05, offset, op_size, isPertialSchedule );
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_je( long offset, int op_size, bool isPertialSchedule )
+const PertialSchedule *CodeGenerator::op_je( long offset, int op_size, bool isPertialSchedule )
 {
     return __jmp_op_format( (char)0x04, offset, op_size, isPertialSchedule );
 }
-const CodeGenerator::PertialSchedule *CodeGenerator::op_jmp( long offset, int op_size, bool isPertialSchedule, bool isSelfOpcodeOffset )
+const PertialSchedule *CodeGenerator::op_jmp( long offset, int op_size, bool isPertialSchedule, bool isSelfOpcodeOffset )
 {
     return __jmp_op_format( (char)0xEB, offset, op_size, isPertialSchedule, isSelfOpcodeOffset );

trunk/abdev/BasicCompiler_Common/src/LexicalScope.cpp

@@ -1 +1 @@
 #include "stdafx.h"
 
-#include <LexicalScopingImpl.h>
+#include <LexicalScope.h>
 #include <Compiler.h>
 
@@ -13 +13 @@
 
 
-void ScopeImpl::Break(){
+void LexicalScope::Break(){
     //未解放のローカルオブジェクトを解放する
-    GetLexicalScopes().CallDestructorsOfReturn( level );
+    compiler.codeGenerator.lexicalScopes.CallDestructorsOfReturn( level );
 
     //jmp ...(Next addr)
-    OpBuffer[obp++]=(char)0xE9;
-
-    pBreakSchedule=(DWORD *)realloc( pBreakSchedule, ( nBreakSchedule + 1 ) * sizeof(DWORD) );
-    pBreakSchedule[nBreakSchedule]=obp;
-    nBreakSchedule++;
-
-    obp+=sizeof(long);
+    breakPertialSchedules.push_back(
+        compiler.codeGenerator.op_jmp( 0, sizeof(long), true )
+    );
 }
-void ScopeImpl::RunScheduleOfBreak(){
-    for(int i=0;i<nBreakSchedule;i++){
-        *((long *)(OpBuffer+pBreakSchedule[i]))=obp-(pBreakSchedule[i]+sizeof(long));
+void LexicalScope::RunScheduleOfBreak(){
+    BOOST_FOREACH( const PertialSchedule *pBreakPertialSchedule, breakPertialSchedules )
+    {
+        compiler.codeGenerator.opfix_JmpPertialSchedule( pBreakPertialSchedule );
     }
 }
 
-void LexicalScopesImpl::End(){
+
+
+LexicalScope *LexicalScopes::SearchScope( LexicalScope::SCOPE_TYPE TypeOfStatement ){
+    for( int i = level; i>=0; i-- ){
+        if( ppScopes[i]->GetTypeOfStatement() == TypeOfStatement ){
+            return ppScopes[i];
+        }
+    }
+    return NULL;
+}
+
+void LexicalScopes::Init(int addr){
+    // TODO: エラーチェック
+
+    level = -1;
+    Start( addr, LexicalScope::SCOPE_TYPE_BASE );
+}
+void LexicalScopes::Start( int addr, LexicalScope::SCOPE_TYPE TypeOfStatement ){
+    level++;
+    ppScopes = (LexicalScope **)realloc( ppScopes, ( level + 1 ) * sizeof( LexicalScope * ) );
+    ppScopes[level] = new LexicalScope( level, addr, TypeOfStatement );
+}
+
+int LexicalScopes::GetNowLevel(){
+    return level;
+}
+void LexicalScopes::SetNowLevel( int level ){
+    this->level = level;
+}
+int LexicalScopes::GetStartAddress(){
+    return ppScopes[level]->GetStartAddress();
+}
+
+void LexicalScopes::End(){
     if( level <= 0 ){
         SetError();
@@ -65 +95 @@
 
 // スコープ終了時のデストラクタ呼び出し
-void LexicalScopesImpl::CallDestructorsOfScopeEnd(){
+void LexicalScopes::CallDestructorsOfScopeEnd(){
 
     Variables &vars = UserProc::IsGlobalAreaCompiling() ?
@@ -134 +164 @@
 
 // Returnステートメントで発行されるデストラクタを生成
-void LexicalScopesImpl::CallDestructorsOfReturn( int BaseLevel ){
+void LexicalScopes::CallDestructorsOfReturn( int BaseLevel ){
     //現在のスコープレベルを退避
     int backupScopeLevel = GetNowLevel();
@@ -147 +177 @@
     SetNowLevel( backupScopeLevel );
 }
-
-LexicalScopesImpl &GetLexicalScopes()
-{
-    static LexicalScopesImpl *pTemp = NULL;
-    if( !pTemp )
-    {
-        pTemp = (LexicalScopesImpl *)Smoothie::Temp::pLexicalScopes;
-    }
-    return *pTemp;
-}

trunk/abdev/BasicCompiler_Common/src/SmoothieImpl.cpp

@@ -6 +6 @@
 #include <Class.h>
 #include <Procedure.h>
-#include <LexicalScopingImpl.h>
-
-CLexicalScopes *Smoothie::Temp::pLexicalScopes = new LexicalScopesImpl();
+#include <LexicalScope.h>

trunk/abdev/BasicCompiler_Common/src/Variable.cpp

@@ -35 +35 @@
         Variable &var = *(*this)[i];
         if( var.bLiving                                         //現在のスコープで有効なもの
-            && var.GetScopeLevel() == Smoothie::Temp::pLexicalScopes->GetNowLevel() //現在のスコープと同一レベル
-            ){
-                if( var.IsEqualSymbol( symbol ) ){
-                    return true;
-                }
+            && var.GetScopeLevel() == compiler.codeGenerator.lexicalScopes.GetNowLevel()    //現在のスコープと同一レベル
+            )
+        {
+            if( var.IsEqualSymbol( symbol ) ){
+                return true;
+            }
         }
     }
@@ -51 +52 @@
         Variable &var = *(*this)[i];
         if( var.bLiving                                         //現在のスコープで有効なもの
-            && var.GetScopeLevel() <= Smoothie::Temp::pLexicalScopes->GetNowLevel() //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
+            && var.GetScopeLevel() <= compiler.codeGenerator.lexicalScopes.GetNowLevel()    //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
             ){
                 if( var.IsEqualSymbol( symbol ) ){