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

Timestamp:

Jul 12, 2007, 2:58:26 AM (17 years ago)

Author:

dai_9181

Message:

コード全体のリファクタリングを実施

Location:

trunk/abdev/BasicCompiler_Common/src

Files:

• Class.cpp (moved) (moved from trunk/abdev/BasicCompiler_Common/src/ClassImpl.cpp ) (26 diffs)
• CodeGenerator.cpp (modified) (1 diff)
• Compiler.cpp (modified) (1 diff)
• Const.cpp (moved) (moved from trunk/abdev/BasicCompiler_Common/Const.cpp ) (10 diffs)
• DataTable.cpp (modified) (1 diff)
• Exception.cpp (modified) (1 diff)
• LexicalScopingImpl.cpp (modified) (7 diffs)
• Method.cpp (added)
• NamespaceSupporter.cpp (modified) (1 diff)
• Procedure.cpp (moved) (moved from trunk/abdev/BasicCompiler_Common/src/ProcedureImpl.cpp ) (19 diffs)
• Program.cpp (modified) (1 diff)
• SmoothieImpl.cpp (modified) (1 diff)
• Symbol.cpp (added)
• Type.cpp (added)
• TypeDef.cpp (modified) (7 diffs)
• Variable.cpp (added)
• VariableImpl.cpp (deleted)

trunk/abdev/BasicCompiler_Common/src/Class.cpp

@@ +1 @@
+#include "stdafx.h"
+
 #include <jenga/include/smoothie/Smoothie.h>
-#include <jenga/include/smoothie/Class.h>
 #include <jenga/include/smoothie/Source.h>
 #include <jenga/include/smoothie/SmoothieException.h>
 #include <jenga/include/smoothie/LexicalAnalysis.h>
 
-#include <ClassImpl.h>
+#include <Class.h>
 #include <Compiler.h>
 #include <NamespaceSupporter.h>
@@ -15 +16 @@
 #include "../../BasicCompiler32/opcode.h"
 #endif
-
-
 
 
@@ -77 +76 @@
 
 
-bool ClassImpl::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const
-{
-    if( GetName() != name ){
+bool CClass::IsClass() const
+{
+    return classType == CClass::Class;
+}
+bool CClass::IsInterface() const
+{
+    return classType == CClass::Interface;
+}
+bool CClass::IsEnum() const
+{
+    return classType == CClass::Enum;
+}
+bool CClass::IsDelegate() const
+{
+    return classType == CClass::Delegate;
+}
+bool CClass::IsStructure() const
+{
+    return classType == CClass::Structure;
+}
+
+
+// コンストラクタのコンパイルを開始
+void CClass::NotifyStartConstructorCompile() const
+{
+    isCompilingConstructor = true;
+}
+
+//コンストラクタのコンパイルを終了
+void CClass::NotifyFinishConstructorCompile() const
+{
+    isCompilingConstructor = false;
+}
+
+//コンストラクタをコンパイル中かどうかを判別
+bool CClass::IsCompilingConstructor() const
+{
+    return isCompilingConstructor;
+}
+
+//デストラクタのコンパイルを開始
+void CClass::NotifyStartDestructorCompile() const{
+    isCompilingDestructor = true;
+}
+
+//デストラクタのコンパイルを終了
+void CClass::NotifyFinishDestructorCompile() const{
+    isCompilingDestructor = false;
+}
+
+//デストラクタをコンパイル中かどうかを判別
+bool CClass::IsCompilingDestructor() const
+{
+    return isCompilingDestructor;
+}
+
+//自身の派生クラスかどうかを確認
+bool CClass::IsSubClass( const CClass *pClass ) const
+{
+    if( !pClass->HasSuperClass() )
+    {
         return false;
     }
 
-    return compiler.GetNamespaceSupporter().IsSameAreaNamespace( GetNamespaceScopes(), namespaceScopes );
-}
-
-bool ClassImpl::Inherits( const char *inheritNames, int nowLine ){
+    const CClass *pTempClass = &pClass->GetSuperClass();
+    while( pTempClass ){
+        if( this == pTempClass ) return true;
+        pTempClass = &pTempClass->GetSuperClass();
+    }
+    return false;
+}
+
+//自身と等しいまたは派生クラスかどうかを確認
+bool CClass::IsEqualsOrSubClass( const CClass *pClass ) const
+{
+    if( IsEquals( pClass ) ) return true;
+    return IsSubClass( pClass );
+}
+
+// 自身と等しいまたは派生クラス、基底クラスかどうかを確認
+bool CClass::IsEqualsOrSubClassOrSuperClass( const CClass &objClass ) const
+{
+    if( IsEquals( &objClass ) ) return true;
+    if( IsSubClass( &objClass ) ) return true;
+    if( objClass.IsSubClass( this ) ) return true;
+    return false;
+}
+
+bool CClass::IsInheritsInterface( const CClass *pInterfaceClass ) const
+{
+    BOOST_FOREACH( const InheritedInterface &objInterface, interfaces ){
+        if( pInterfaceClass == &objInterface.GetInterfaceClass() ){
+            return true;
+        }
+    }
+    return false;
+}
+
+bool CClass::Inherits( const char *inheritNames, int nowLine ){
     int i = 0;
     bool isInheritsClass = false;
@@ -183 +271 @@
     return true;
 }
-bool ClassImpl::InheritsClass( const CClass &inheritsClass, int nowLine ){
+bool CClass::InheritsClass( const CClass &inheritsClass, int nowLine ){
 
     //ループ継承でないかをチェック
@@ -245 +333 @@
     return true;
 }
-bool ClassImpl::InheritsInterface( const CClass &inheritsInterface, int nowLine ){
+bool CClass::InheritsInterface( const CClass &inheritsInterface, int nowLine ){
 
     //ループ継承でないかをチェック
@@ -291 +379 @@
     return true;
 }
-CMember *ClassImpl::CreateMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine )
+CMember *CClass::CreateMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine )
 {
     extern int cp;
@@ -299 +387 @@
     char initBuffer[VN_SIZE];
     char lpszConstructParameter[VN_SIZE];
-    int SubScripts[MAX_ARRAYDIM];
+    Subscripts subscripts;
     Type type;
-    GetDimentionFormat(buffer,VarName,SubScripts,type,initBuffer,lpszConstructParameter);
+    GetDimentionFormat(buffer,VarName,subscripts,type,initBuffer,lpszConstructParameter);
 
     //重複チェック
@@ -308 +396 @@
     }
 
-    CMember *pMember = new CMember( accessibility, VarName, type, isConst, initBuffer, lpszConstructParameter );
+    CMember *pMember = new CMember( accessibility, VarName, type, isConst, subscripts, initBuffer, lpszConstructParameter );
     pMember->source_code_address = nowLine;
-    memcpy( pMember->SubScripts, SubScripts, MAX_ARRAYDIM * sizeof(int) );
     return pMember;
 }
-void ClassImpl::AddMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine ){
+void CClass::AddMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine ){
     dynamicMembers.push_back(
         CreateMember( accessibility, isConst, isRef, buffer, nowLine )
     );
 }
-void ClassImpl::AddStaticMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine ){
+void CClass::AddStaticMember( Prototype::Accessibility accessibility, bool isConst, bool isRef, char *buffer, int nowLine ){
     staticMembers.push_back(
         CreateMember( accessibility, isConst, isRef, buffer, nowLine )
@@ -324 +411 @@
 }
 
-void ClassImpl::AddMethod(CClass *pobj_c, Prototype::Accessibility accessibility, BOOL bStatic, bool isConst, bool isAbstract,
+void CClass::AddMethod(CClass *pobj_c, Prototype::Accessibility accessibility, BOOL bStatic, bool isConst, bool isAbstract,
                          bool isVirtual, bool isOverride, char *buffer, int nowLine){
     int i,i2;
@@ -340 +427 @@
 
     //関数ハッシュへ登録
-    GlobalProc *pUserProc;
-    pUserProc=AddSubData( NamespaceScopes(), NamespaceScopesCollection(), buffer,nowLine,isVirtual,pobj_c, (bStatic!=0) );
+    UserProc *pUserProc = compiler.GetMeta().GetUserProcs().Add( NamespaceScopes(), NamespaceScopesCollection(), buffer,nowLine,isVirtual,pobj_c, (bStatic!=0) );
     if(!pUserProc) return;
 
@@ -394 +480 @@
         if( pMethod->GetInheritsClassPtr() ) continue;
 
-        if( pMethod->pUserProc->GetName() == temporary ){
-            if( pMethod->pUserProc->Params().Equals( pUserProc->Params() ) ){
+        if( pMethod->GetUserProc().GetName() == temporary ){
+            if( pMethod->GetUserProc().Params().Equals( pUserProc->Params() ) ){
                 //関数名、パラメータ属性が合致したとき
                 SetError(15,pUserProc->GetName().c_str(),nowLine);
@@ -408 +494 @@
     //メソッドのオーバーライド
     BOOST_FOREACH( CMethod *pMethod, pobj_c->GetMethods() ){
-        if( pMethod->pUserProc->GetName() == temporary ){
-            if( pMethod->pUserProc->Params().Equals( pUserProc->Params() ) ){
+        if( pMethod->GetUserProc().GetName() == temporary ){
+            if( pMethod->GetUserProc().Params().Equals( pUserProc->Params() ) ){
 
                 if(pMethod->IsVirtual()){
                     //メンバ関数を上書き
-                    pMethod->pUserProc=pUserProc;
+                    pMethod->SetUserProcPtr( pUserProc );
                     pMethod->Override();
 
@@ -446 +532 @@
 }
 
-LONG_PTR ClassImpl::GetVtblGlobalOffset(void) const
+bool CClass::DupliCheckAll(const char *name){
+    //重複チェック
+
+    //メンバ
+    if(DupliCheckMember(name)) return 1;
+
+    //メソッド
+    BOOST_FOREACH( const CMethod *pMethod, methods ){
+        if( lstrcmp( name, pMethod->GetUserProc().GetName().c_str() ) == 0 ){
+            return 1;
+        }
+    }
+
+    return 0;
+}
+bool CClass::DupliCheckMember(const char *name){
+    //重複チェック
+
+    // 動的メンバ
+    BOOST_FOREACH( CMember *pMember, dynamicMembers ){
+        if( GetName() == pMember->GetName() ){
+            return 1;
+        }
+    }
+
+    // 静的メンバ
+    BOOST_FOREACH( CMember *pMember, staticMembers ){
+        if( GetName() == pMember->GetName() ){
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+//サイズを取得
+int CClass::GetSize() const
+{
+    return GetMemberOffset( NULL, NULL );
+}
+
+//メンバのオフセットを取得
+int CClass::GetMemberOffset( const char *memberName, int *pMemberNum ) const
+{
+    int i2;
+
+    //仮想関数が存在する場合は関数リストへのポインタのサイズを追加
+    int offset = IsExistVirtualFunctions() ? PTR_SIZE : 0;
+
+    int alignment;
+    if(iAlign) alignment=iAlign;
+    else alignment=1;
+
+    int iMaxAlign=0;
+    int i = -1;
+    BOOST_FOREACH( CMember *pMember, dynamicMembers ){
+        i++;
+
+        i2 = pMember->GetType().GetSize();
+
+        //アラインメントを算出
+        int member_size;
+        if( pMember->GetType().IsStruct() ){
+            //メンバクラスのアラインメントを取得
+            member_size=pMember->GetType().GetClass().GetAlignment();
+        }
+        else{
+            //メンバサイズを取得
+            member_size=i2;
+        }
+        if(iMaxAlign<member_size) iMaxAlign=member_size;
+
+        //アラインメントを考慮
+        if(iAlign&&iAlign<member_size){
+            if(offset%alignment) offset+=alignment-(offset%alignment);
+        }
+        else{
+            if(alignment<member_size) alignment=member_size;
+
+            if(member_size==0){
+                //メンバを持たないクラス
+                //※何もしない（オフセットの計算をしない）
+            }
+            else{
+                if(offset%member_size) offset+=member_size-(offset%member_size);
+            }
+        }
+
+        if(memberName){
+            //メンバ指定がある場合は、オフセットを返す
+            if( pMember->GetName() == memberName ){
+                if(pMemberNum) *pMemberNum=i;
+                return offset;
+            }
+        }
+
+        //配列を考慮したメンバサイズを取得
+        member_size = i2 * Variable::GetSubScriptCounts( pMember->GetSubscripts() );
+
+        //メンバサイズを加算
+        offset+= member_size;
+    }
+
+    if(iMaxAlign<alignment) alignment=iMaxAlign;
+
+    //アラインメントを考慮
+    if(alignment){
+        if(offset%alignment) offset+=alignment-(offset%alignment);
+    }
+
+    if(pMemberNum) *pMemberNum=i;
+    return offset;
+}
+int CClass::GetAlignment() const
+{
+    //仮想関数が存在する場合は関数リストへのポインタのサイズを追加
+    int alignment = IsExistVirtualFunctions() ? PTR_SIZE : 0;
+
+    BOOST_FOREACH( CMember *pMember, dynamicMembers ){
+        int member_size;
+        if(pMember->GetType().IsStruct()){
+            //メンバクラスのアラインメントを取得
+            member_size=pMember->GetType().GetClass().GetAlignment();
+        }
+        else{
+            //メンバサイズを取得
+            member_size = pMember->GetType().GetSize();
+        }
+
+        //アラインメントをセット
+        if(alignment<member_size) alignment=member_size;
+    }
+
+    if(alignment==0) return 0;
+
+    if(iAlign) alignment=iAlign;
+
+    return alignment;
+}
+int CClass::GetFuncNumInVtbl( const UserProc *pUserProc ) const
+{
+    int n = 0;
+    BOOST_FOREACH( const CMethod *pMethod, methods ){
+        if( &pMethod->GetUserProc() == pUserProc ) break;
+        if( pMethod->IsVirtual() ) n++;
+    }
+    return n;
+}
+LONG_PTR CClass::GetVtblGlobalOffset(void) const
 {
 
@@ -458 +692 @@
     //////////////////////////////////////
 
-    UserProc **ppsi;
-    ppsi=(UserProc **)malloc(GetVtblNum()*sizeof(UserProc *));
+    const UserProc **ppsi;
+    ppsi=(const UserProc **)malloc(GetVtblNum()*sizeof(UserProc *));
 
     //関数テーブルに値をセット
@@ -465 +699 @@
     BOOST_FOREACH( const CMethod *pMethod, methods ){
         if(pMethod->IsVirtual()){
-            pMethod->pUserProc->Using();
+            pMethod->GetUserProc().Using();
 
             if(pMethod->IsAbstract()){
@@ -474 +708 @@
             }
             else{
-                ppsi[i2]=pMethod->pUserProc;
+                ppsi[i2]=&pMethod->GetUserProc();
             }
             i2++;
@@ -490 +724 @@
     return vtbl_offset;
 }
-void ClassImpl::ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection){
+void CClass::ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection){
     if(vtbl_offset==-1) return;
 
@@ -501 +735 @@
         pUserProc=(UserProc *)pVtbl[i];
         if(!pUserProc) continue;
-        pVtbl[i]=pUserProc->beginOpAddress+ImageBase+MemPos_CodeSection;
-    }
-}
-
-CClass *ClassesImpl::Create( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name){
-    return new ClassImpl(namespaceScopes, importedNamespaces, name);
-}
-
-void ClassesImpl::CollectClassesForNameOnly( const BasicSource &source )
+        pVtbl[i]=pUserProc->GetBeginOpAddress()+ImageBase+MemPos_CodeSection;
+    }
+}
+bool CClass::IsAbstract() const
+{
+    // 未実装(abstract)の仮想関数を持つ場合はtrueを返す
+
+    BOOST_FOREACH( const CMethod *pMethod, methods ){
+        if(pMethod->IsVirtual()){
+            if(pMethod->IsAbstract()){
+                return true;
+            }
+        }
+    }
+
+    return false;
+}
+
+
+int Classes::GetHashCode(const char *name) const
+{
+    int key;
+
+    for(key=0;*name!='\0';name++){
+        key=((key<<8)+ *name )%MAX_CLASS_HASH;
+    }
+
+    return key;
+}
+
+CClass *Classes::Create( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name){
+    return new CClass(namespaceScopes, importedNamespaces, name);
+}
+bool Classes::Insert( CClass *pClass )
+{
+    // キャッシュしておくクラス
+    if( pClass->GetName() == "String" )
+    {
+        pStringClass=pClass;
+    }
+    else if( pClass->GetName() == "Object" )
+    {
+        pObjectClass = pClass;
+    }
+
+    /////////////////////////////////
+    // ハッシュデータに追加
+    /////////////////////////////////
+
+    int key;
+    key=GetHashCode( pClass->GetName().c_str() );
+
+    if(pobj_ClassHash[key]){
+        CClass *pobj_c2;
+        pobj_c2=pobj_ClassHash[key];
+        while(1){
+            if( ((const Prototype *)pobj_c2)->IsEqualSymbol( *(const Prototype *)pClass ) ){
+                //名前空間及びクラス名が重複した場合
+                SmoothieException::Throw(15,pClass->GetName());
+                return false;
+            }
+
+            if(pobj_c2->pobj_NextClass==0) break;
+            pobj_c2=pobj_c2->pobj_NextClass;
+        }
+        pobj_c2->pobj_NextClass=pClass;
+    }
+    else{
+        pobj_ClassHash[key]=pClass;
+    }
+    return true;
+}
+CClass *Classes::Add( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, const char *name,int nowLine){
+    //////////////////////////////////////////////////////////////////////////
+    // クラスを追加
+    // ※名前のみを登録。その他の情報はSetClassメソッドで！
+    //////////////////////////////////////////////////////////////////////////
+
+    CClass *pClass = Create(namespaceScopes, importedNamespaces, name);
+
+    if( !Insert( pClass ) )
+    {
+        return NULL;
+    }
+
+    return pClass;  
+}
+
+void Classes::CollectClassesForNameOnly( const BasicSource &source )
 {
     int i, i2;
@@ -641 +955 @@
 }
 
-void ClassesImpl::InitStaticMember(){
+void Classes::ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection){
+    int i;
+    for(i=0;i<MAX_CLASS_HASH;i++){
+        if(pobj_ClassHash[i]){
+            CClass *pobj_c;
+            pobj_c=pobj_ClassHash[i];
+            while(1){
+                pobj_c->ActionVtblSchedule(ImageBase,MemPos_CodeSection);
+
+                if(pobj_c->pobj_NextClass==0) break;
+                pobj_c=pobj_c->pobj_NextClass;
+            }
+        }
+    }
+}
+
+
+void Classes::InitStaticMember(){
     //静的メンバをグローバル領域に作成
 
@@ -662 +993 @@
             dim(
                 temporary,
-                member->SubScripts,
+                member->GetSubscripts(),
                 member->GetType(),
                 member->GetInitializeExpression().c_str(),
@@ -679 +1010 @@
     cp=back_cp;
 }
-bool ClassesImpl::MemberVar_LoopRefCheck(const CClass &objClass){
+bool Classes::MemberVar_LoopRefCheck(const CClass &objClass){
     bool result = true;
     BOOST_FOREACH( CMember *pMember, objClass.GetDynamicMembers() ){
@@ -704 +1035 @@
     return result;
 }
-void ClassesImpl::GetClass_recur(const char *lpszInheritsClass){
+void Classes::GetClass_recur(const char *lpszInheritsClass){
     extern char *basbuf;
     int i,i2,i3,sub_address,top_pos;
@@ -1156 +1487 @@
     compiler.GetNamespaceSupporter().GetLivingNamespaceScopes() = backupNamespaceScopes;
 }
-void ClassesImpl::GetAllClassInfo(void){
+void Classes::GetAllClassInfo(void){
     //ループ継承チェック用のクラス
     pobj_LoopRefCheck=new CLoopRefCheck();
@@ -1169 +1500 @@
     this->Iterator_Init();
 }
-void ClassesImpl::Compile_System_InitializeUserTypes(){
+void Classes::Compile_System_InitializeUserTypes(){
     char temporary[VN_SIZE];
 
@@ -1296 +1627 @@
 }
 
-const CClass *ClassesImpl::Find( const NamespaceScopes &namespaceScopes, const string &name ) const
+const CClass *Classes::Find( const NamespaceScopes &namespaceScopes, const string &name ) const
 {
     int key;
@@ -1333 +1664 @@
     return NULL;
 }
+const CClass *Classes::Find( const string &fullName ) const
+{
+    char AreaName[VN_SIZE] = "";        //オブジェクト変数
+    char NestName[VN_SIZE] = "";        //入れ子メンバ
+    bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );
+
+    return Find( NamespaceScopes( AreaName ), NestName );
+}
+void Classes::StartCompile( const UserProc *pUserProc ){
+    const CClass *pParentClass = pUserProc->GetParentClassPtr();
+    if( pParentClass ){
+        pParentClass->Using();
+
+        pCompilingMethod = pParentClass->GetMethods().GetMethodPtr( pUserProc );
+        if( !pCompilingMethod ){
+            pCompilingMethod = pParentClass->GetStaticMethods().GetMethodPtr( pUserProc );
+            if( !pCompilingMethod ){
+                SmoothieException::Throw(300);
+            }
+        }
+    }
+    else{
+        pCompilingMethod = NULL;
+    }
+}
+
+CClass *Classes::GetStringClassPtr() const
+{
+    if( !pStringClass ){
+        SmoothieException::Throw();
+        return NULL;
+    }
+    return pStringClass;
+}
+CClass *Classes::GetObjectClassPtr() const
+{
+    if( !pObjectClass ){
+        SmoothieException::Throw();
+        return NULL;
+    }
+    return pObjectClass;
+}
+
+
+//////////////////////
+// イテレータ
+//////////////////////
+
+void Classes::Iterator_Init() const
+{
+    if(ppobj_IteClass) free(ppobj_IteClass);
+
+    iIteMaxNum=0;
+    iIteNextNum=0;
+    ppobj_IteClass=(CClass **)malloc(1);
+
+    int i;
+    for(i=0;i<MAX_CLASS_HASH;i++){
+        if(pobj_ClassHash[i]){
+            CClass *pobj_c;
+            pobj_c=pobj_ClassHash[i];
+            while(1){
+                ppobj_IteClass=(CClass **)realloc(ppobj_IteClass,(iIteMaxNum+1)*sizeof(CClass *));
+                ppobj_IteClass[iIteMaxNum]=pobj_c;
+                iIteMaxNum++;
+
+                if(pobj_c->pobj_NextClass==0) break;
+                pobj_c=pobj_c->pobj_NextClass;
+            }
+        }
+    }
+}
+void Classes::Iterator_Reset() const
+{
+    iIteNextNum = 0;
+}
+BOOL Classes::Iterator_HasNext() const
+{
+    if(iIteNextNum<iIteMaxNum) return 1;
+    return 0;
+}
+CClass *Classes::Iterator_GetNext() const
+{
+    CClass *pobj_c = ppobj_IteClass[iIteNextNum];
+    iIteNextNum++;
+    return pobj_c;
+}
+int Classes::Iterator_GetMaxCount() const
+{
+    return iIteMaxNum;
+}

trunk/abdev/BasicCompiler_Common/src/CodeGenerator.cpp

@@ +1 @@
+#include "stdafx.h"
+
 #include <windows.h>
 #include <stdlib.h>

trunk/abdev/BasicCompiler_Common/src/Compiler.cpp

@@ -1 @@
-#include <jenga/include/smoothie/Type.h>
+#include "stdafx.h"
+
 #include <jenga/include/smoothie/SmoothieException.h>
 
 #include <Compiler.h>
+#include <Type.h>
 
 Compiler compiler;

trunk/abdev/BasicCompiler_Common/src/Const.cpp

@@ +1 @@
+#include "stdafx.h"
+
 #include <Compiler.h>
-#include <NamespaceSupporter.h>
-
-#include "common.h"
-#include OPCODE_H_PATH  //opcode.h
-
-
-//シングルトンオブジェクト
-CDBConst CDBConst::obj;
-
-
-bool ConstBase::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const
-{
-    if( GetName() != name ){
-        return false;
-    }
-    return compiler.GetNamespaceSupporter().IsSameAreaNamespace( this->namespaceScopes, namespaceScopes );
-}
-bool ConstBase::IsEqualSymbol( const string &fullName ) const
-{
-    char AreaName[VN_SIZE] = "";        //オブジェクト変数
-    char NestName[VN_SIZE] = "";        //入れ子メンバ
-    bool isNest = CClass::SplitName( fullName.c_str(), AreaName, NestName );
-
-    return IsEqualSymbol( NamespaceScopes( AreaName ), NestName );
-}
-
-
-
-
-CConst::CConst( const NamespaceScopes &namespaceScopes, const string &name, const Type &newType, _int64 i64data)
-    : ConstBase( namespaceScopes, name )
-    , type( newType )
-    , i64data( i64data )
-    , pNext( NULL )
-{
-}
-CConst::CConst( const NamespaceScopes &namespaceScopes, const string &name, int value)
-    : ConstBase( namespaceScopes, name )
-    , type( Type(DEF_LONG) )
-    , i64data( value )
-    , pNext( NULL )
-{
-}
-CConst::~CConst(){
-    //連結先のオブジェクトを破棄
-    if(pNext){
-        delete pNext;
-        pNext = 0;
-    }
-}
-
-Type CConst::GetType(){
-    return type;
-}
-_int64 CConst::GetWholeData(){
-    return i64data;
-}
+
+
 double CConst::GetDoubleData(){
     double dbl;
@@ -63 +10 @@
 }
 
-
-
-CConstMacro::CConstMacro( const NamespaceScopes &namespaceScopes, const string &name, char *Expression)
-    : ConstBase( namespaceScopes, name )
-{
-}
-CConstMacro::~CConstMacro(){
-}
-
-
-
-
-
-CDBConst::CDBConst(){
-    memset(this,0,sizeof(CDBConst));
-
-    ppHash = (CConst **)calloc(MAX_HASH*sizeof(CConst *),1);
-    Init();
-}
-CDBConst::~CDBConst(){
-    Free();
-
-    free(ppHash);
-}
-
-//解放
-void CDBConst::Free(){
+void AddConst( const NamespaceScopes &namespaceScopes, char *buffer ){
     int i;
-    for(i=0; i<MAX_HASH; i++){
-        if(ppHash[i]){
-            delete ppHash[i];
-            ppHash[i] = 0;
-        }
-    }
-}
-
-//初期化
-void CDBConst::Init(){
-    Free();
-}
-
-void AddConstData(char *Command);
-void CDBConst::Add( const NamespaceScopes &namespaceScopes, char *buffer ){
-    int i;
 
     //名前を取得
-    char Name[VN_SIZE];
+    char name[VN_SIZE];
     for(i=0;;i++){
         if(buffer[i]=='\0'){
@@ -116 +21 @@
         }
         if(buffer[i]=='='||buffer[i]=='('){
-            Name[i]=0;
+            name[i]=0;
             break;
         }
-        Name[i]=buffer[i];
+        name[i]=buffer[i];
     }
 
     //重複チェック
-    if(GetBasicType(Name)){
-        SetError(15,Name,cp);
+    if( compiler.GetMeta().GetGlobalConstMacros().IsExist( name )
+        || compiler.GetMeta().GetGlobalConsts().IsExist( name ) )
+    {
+        SetError(15,name,cp);
         return;
     }
@@ -131 +38 @@
         //定数マクロ
 
-        //未完成
-        AddConstData(buffer);
+        compiler.GetMeta().GetGlobalConstMacros().Add( namespaceScopes, name, buffer + i );
     }
     else{
         //一般の定数
-        char *Expression = buffer + i + 1;
-
-        AddConst( namespaceScopes, Name,Expression);
-    }
-}
-
-void CDBConst::AddConst( const string &name, CConst *newconst){
-    int key = hash_default(name.c_str());
-
-    //ハッシュリストに追加
-    if(ppHash[key]){
-        CConst *pConst = ppHash[key];
-        while(pConst->pNext){
-            pConst = pConst->pNext;
-        }
-
-        pConst->pNext = newconst;
-    }
-    else{
-        ppHash[key] = newconst;
-    }
-}
-void CDBConst::AddConst( const NamespaceScopes &namespaceScopes, const string &name , char *Expression){
+        char *expression = buffer + i + 1;
+
+        compiler.GetMeta().GetGlobalConsts().Add( namespaceScopes, name, expression );
+    }
+}
+
+void Consts::Add( const NamespaceScopes &namespaceScopes, const string &name , char *Expression)
+{
     _int64 i64data;
     Type resultType;
@@ -172 +63 @@
     CConst *newconst = new CConst(namespaceScopes, name, resultType, i64data);
 
-    AddConst( name, newconst);
-}
-void CDBConst::AddConst(const NamespaceScopes &namespaceScopes, const string &name, int value){
+    //ハッシュリストに追加
+    Put( newconst );
+}
+void Consts::Add(const NamespaceScopes &namespaceScopes, const string &name, int value){
     CConst *newconst = new CConst( namespaceScopes, name, value);
 
-    AddConst(name, newconst);
-}
-
-CConst *CDBConst::GetObjectPtr( const string &name ){
+    //ハッシュリストに追加
+    Put( newconst );
+}
+
+CConst *Consts::GetObjectPtr( const string &name ){
     char ObjName[VN_SIZE];      //オブジェクト変数
     char NestMember[VN_SIZE];   //入れ子メンバ
-    bool isObjectMember = CClass::SplitName( name.c_str(), ObjName, NestMember );
-
-    //ハッシュ値を取得
-    int key;
-    key=hash_default( NestMember );
-
-    //格納位置を取得
-    CConst *pConst;
-    pConst=ppHash[key];
-    while(pConst){
-        if( pConst->IsEqualSymbol( name ) ) break;
-
-        pConst=pConst->pNext;
+    bool isObjectMember = SplitMemberName( name.c_str(), ObjName, NestMember );
+
+    CConst *pConst = GetHashArrayElement( NestMember );
+    while( pConst )
+    {
+        if( pConst->IsEqualSymbol( name ) )
+        {
+            break;
+        }
+        pConst = pConst->GetChainNext();
     }
 
@@ -202 +92 @@
 
 
-int CDBConst::GetBasicType(char *Name){
+int Consts::GetBasicType(char *Name){
     CConst *pConst = GetObjectPtr(Name);
 
@@ -209 +99 @@
     return pConst->GetType().GetBasicType();
 }
-_int64 CDBConst::GetWholeData(char *Name){
+_int64 Consts::GetWholeData(char *Name){
     CConst *pConst = GetObjectPtr(Name);
 
@@ -216 +106 @@
     return pConst->GetWholeData();
 }
-double CDBConst::GetDoubleData(char *Name){
+double Consts::GetDoubleData(char *Name){
     CConst *pConst = GetObjectPtr(Name);
 
@@ -223 +113 @@
     return pConst->GetDoubleData();
 }
-bool CDBConst::IsStringPtr( char *Name ){
+bool Consts::IsStringPtr( char *Name ){
     CConst *pConst = GetObjectPtr(Name);
 
@@ -232 +122 @@
     return ( type.GetBasicType() == typeOfPtrChar && type.GetIndex() == LITERAL_STRING );
 }
+
+
+bool ConstMacro::GetCalcBuffer( const char *parameterStr, char *dest ) const
+{
+    extern HANDLE hHeap;
+    int i2,i3,i4,num;
+    char temporary[VN_SIZE];
+    char *pParms[MAX_PARMS];
+    num=0;
+    i2=0;
+    while(1){
+        i2=GetOneParameter(parameterStr,i2,temporary);
+
+        pParms[num]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
+        lstrcpy(pParms[num],temporary);
+
+        num++;
+        if(parameterStr[i2]=='\0') break;
+    }
+    if( num != this->GetParameters().size() ){
+        extern int cp;
+        for(i2=0;i2<num;i2++) HeapDefaultFree(pParms[i2]);
+        SetError(10,GetName().c_str(),cp);
+        lstrcpy(dest,"0");
+        return 1;
+    }
+
+    i2=0;
+    i4=0;
+    while(1){
+
+        //数式内の項を取得
+        for(i3=0;;i2++,i3++){
+            if(!IsVariableChar( this->GetExpression()[i2] )){
+                temporary[i3]=0;
+                break;
+            }
+            temporary[i3] = this->GetExpression()[i2];
+        }
+
+        //パラメータと照合する
+        for( i3=0; i3<(int)this->GetParameters().size(); i3++ ){
+            if( this->GetParameters()[i3] == temporary ) break;
+        }
+
+        if( i3 == (int)this->GetParameters().size() ){
+            //パラメータでないとき
+            lstrcpy(dest+i4,temporary);
+            i4+=lstrlen(temporary);
+        }
+        else{
+            //パラメータのとき
+            lstrcpy(dest+i4,pParms[i3]);
+            i4+=lstrlen(pParms[i3]);
+        }
+
+        //演算子をコピー
+        for(;;i2++,i4++){
+            if( this->GetExpression()[i2] == 1 ){
+                dest[i4++] = this->GetExpression()[i2++];
+                dest[i4] = this->GetExpression()[i2];
+                continue;
+            }
+            if(IsVariableTopChar( this->GetExpression()[i2] )) break;
+            dest[i4] = this->GetExpression()[i2];
+            if( this->GetExpression()[i2] == '\0' ) break;
+        }
+
+        if( this->GetExpression()[i2] == '\0' ) break;
+    }
+
+    for(i2=0;i2<num;i2++) HeapDefaultFree(pParms[i2]);
+
+    return 1;
+}
+
+// マクロ定数を追加するための関数
+void ConstMacros::Add( const NamespaceScopes &namespaceScopes, const std::string &name, const char *parameterStr )
+{
+    std::vector<std::string> parameters;
+
+    int i = 0;
+    if(parameterStr[i]!='(')
+    {
+        SetError();
+        return;
+    }
+
+    char temporary[VN_SIZE];
+    int i2;
+    for(i++,i2=0;;i++,i2++){
+        if(parameterStr[i]=='\0'){
+            SetError(1,NULL,cp);
+            return;
+        }
+        if(parameterStr[i]==','||parameterStr[i]==')'){
+            temporary[i2]=0;
+
+            parameters.push_back( temporary );
+
+            if(parameterStr[i]==')'){
+                i++;
+                if(parameterStr[i]!='='){
+                    extern int cp;
+                    SetError(1,NULL,cp);
+                    return;
+                }
+                break;
+            }
+
+            i2=-1;
+            continue;
+        }
+        temporary[i2]=parameterStr[i];
+    }
+
+    //データ
+    lstrcpy(temporary,parameterStr+i+1);
+
+    Put( new ConstMacro( namespaceScopes, name, parameters, temporary ) );
+}
+ConstMacro *ConstMacros::Find( const std::string &name ){
+    char ObjName[VN_SIZE];      //オブジェクト変数
+    char NestMember[VN_SIZE];   //入れ子メンバ
+    bool isObjectMember = SplitMemberName( name.c_str(), ObjName, NestMember );
+
+    ConstMacro *pConstMacro = GetHashArrayElement( NestMember );
+    while( pConstMacro )
+    {
+        if( pConstMacro->IsEqualSymbol( name ) )
+        {
+            break;
+        }
+        pConstMacro = pConstMacro->GetChainNext();
+    }
+
+    return pConstMacro;
+}

trunk/abdev/BasicCompiler_Common/src/DataTable.cpp

@@ +1 @@
+#include "stdafx.h"
+
 #include <jenga/include/smoothie/Smoothie.h>
 

trunk/abdev/BasicCompiler_Common/src/Exception.cpp

@@ +1 @@
+#include "stdafx.h"
+
 #include <Exception.h>
 

trunk/abdev/BasicCompiler_Common/src/LexicalScopingImpl.cpp

@@ +1 @@
+#include "stdafx.h"
+
 #include <LexicalScopingImpl.h>
+#include <Compiler.h>
 
 #include "../common.h"
@@ -29 +32 @@
 }
 
+void LexicalScopesImpl::End(){
+    if( level <= 0 ){
+        SetError();
+        return;
+    }
+
+    //デストラクタを呼ぶ
+    CallDestructorsOfScopeEnd();
+
+    Variables &vars = UserProc::IsGlobalAreaCompiling() ?
+        compiler.GetMeta().GetGlobalVars() :
+        UserProc::CompilingUserProc().GetLocalVars();
+
+    //使用済みローカル変数の生存チェックを外す
+    BOOST_FOREACH( Variable *pVar, vars ){
+        if(pVar->bLiving&&pVar->GetScopeLevel()==level){
+            pVar->bLiving=0;
+            extern int obp;
+            pVar->SetScopeEndAddress( obp );
+        }
+    }
+
+
+    //スコープ抜け出しスケジュール
+    ppScopes[level]->RunScheduleOfBreak();
+
+
+    //スコープレベルを下げる
+    delete ppScopes[level];
+    level--;
+}
+
 // スコープ終了時のデストラクタ呼び出し
 void LexicalScopesImpl::CallDestructorsOfScopeEnd(){
 
-    Variables &vars = UserProc::IsGlobalAreaCompiling()?
-        globalVars :
-        UserProc::CompilingUserProc().localVars;
+    Variables &vars = UserProc::IsGlobalAreaCompiling() ?
+        compiler.GetMeta().GetGlobalVars() :
+        UserProc::CompilingUserProc().GetLocalVars();
 
 
@@ -52 +87 @@
         //同一レベルのレキシカルスコープのみを検知
         if(!pVar->bLiving) continue;
-        if( pVar->ScopeLevel != GetNowLevel() ) continue;
+        if( pVar->GetScopeLevel() != GetNowLevel() ) continue;
 
-        if( pVar->IsStruct() && pVar->IsParameter() ){
+        if( pVar->GetType().IsStruct() && pVar->IsParameter() ){
             //構造体パラメータを持つとき
 
@@ -64 +99 @@
             //mov rcx,qword ptr[rsp+offset]
             op_mov_RM(sizeof(_int64),REG_RCX,REG_RSP,
-                -pVar->offset,
+                -pVar->GetOffsetAddress(),
                 MOD_BASE_DISP32);
             obp-=sizeof(long);
@@ -73 +108 @@
 
             //mov ecx,dword ptr[ebp+offset]
-            op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar->offset,MOD_BASE_DISP32);
+            op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar->GetOffsetAddress(),MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -83 +118 @@
 
             //call free
-            extern UserProc *pSub_free;
+            extern const UserProc *pSub_free;
             op_call(pSub_free);
 
@@ -96 +131 @@
     if(indexSystemGC!=-1){
         //_System_GCオブジェクトのデストラクタの呼び出し処理
-        const CMethod *method = vars[indexSystemGC]->GetClass().GetDestructorMethod();
+        const CMethod *method = vars[indexSystemGC]->GetType().GetClass().GetDestructorMethod();
         if( method ){
-            Opcode_CallProc("",method->pUserProc,0,vars[indexSystemGC]->GetName().c_str(),DEF_OBJECT);
+            Opcode_CallProc("",&method->GetUserProc(),0,vars[indexSystemGC]->GetName().c_str(),DEF_OBJECT);
         }
     }

trunk/abdev/BasicCompiler_Common/src/NamespaceSupporter.cpp

@@ +1 @@
+#include "stdafx.h"
+
 #include <jenga/include/smoothie/SmoothieException.h>
+#include <jenga/include/smoothie/LexicalAnalysis.h>
 
 #include <Compiler.h>

trunk/abdev/BasicCompiler_Common/src/Procedure.cpp

@@ +1 @@
+#include "stdafx.h"
+
+#include <jenga/include/smoothie/Smoothie.h>
 #include <jenga/include/smoothie/SmoothieException.h>
 #include <jenga/include/smoothie/LexicalAnalysis.h>
 
 #include <Compiler.h>
-#include <ProcedureImpl.h>
+#include <Procedure.h>
 #include <NamespaceSupporter.h>
 
@@ -13 +16 @@
 #endif
 
-bool UserProcImpl::SetParamsAndReturnType( const char *sourceOfParams, int nowLine, bool isStatic ){
+
+std::string UserProc::GetFullName() const
+{
+    if( HasParentClass() ){
+        return GetParentClass().GetName() + "." + GetName();
+    }
+
+    return GetName();
+}
+const NamespaceScopes &UserProc::GetNamespaceScopes() const
+{
+    if( HasParentClass() ){
+        return GetParentClassPtr()->GetNamespaceScopes();
+    }
+    return namespaceScopes;
+}
+const NamespaceScopesCollection &UserProc::GetImportedNamespaces() const
+{
+    return importedNamespaces;
+}
+bool UserProc::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const
+{
+    if( GetName() != name ){
+        return false;
+    }
+
+    return compiler.GetNamespaceSupporter().IsSameAreaNamespace( GetNamespaceScopes(), namespaceScopes );
+}
+bool UserProc::IsEqualSymbol( const UserProc &globalProc ) const
+{
+    return IsEqualSymbol( globalProc.GetNamespaceScopes(), globalProc.GetName() );
+}
+bool UserProc::IsEqualSymbol( const string &fullName ) const
+{
+    char AreaName[VN_SIZE] = "";        //オブジェクト変数
+    char NestName[VN_SIZE] = "";        //入れ子メンバ
+    bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );
+
+    return IsEqualSymbol( NamespaceScopes( AreaName ), NestName );
+}
+bool UserProc::IsVirtual() const
+{
+    if( pMethod == NULL ){
+        return false;
+    }
+    return ( pMethod->IsVirtual() != 0 );
+}
+
+bool UserProc::SetParamsAndReturnType( const char *sourceOfParams, int nowLine, bool isStatic ){
     int i = 0;
     int i2,i3,sw;
@@ -51 +102 @@
         //パラメータ名
         bool isArray = false;
-        int subScripts[MAX_ARRAYDIM];
+        Subscripts subscripts;
         char name[VN_SIZE];
         sw=0;
@@ -83 +134 @@
 
             if((name[i2-2]=='('&&name[i2-1]==')')||
-                (name[i2-2]=='['&&name[i2-1]==']')){
-                subScripts[0]=LONG_MAX;
-                subScripts[1]=-1;
+                (name[i2-2]=='['&&name[i2-1]==']'))
+            {
+                subscripts.push_back( LONG_MAX );
 
                 name[i2-2]=0;
             }
             else{
-                GetArrange(name,temp2,subScripts);
+                GetArrange(name,temp2,subscripts);
                 lstrcpy(name,temp2);
             }
@@ -152 +203 @@
         Parameter *pParam = new Parameter( name, type, isRef, initValue );
         if( isArray ){
-            pParam->SetArray( subScripts );
+            pParam->SetArray( subscripts );
         }
 
@@ -189 +240 @@
             //パラメータ名
             bool isArray = false;
-            int subScripts[MAX_ARRAYDIM];
+            Subscripts subscripts;
             char name[VN_SIZE];
             sw=0;
@@ -221 +272 @@
 
                 if((name[i2-2]=='('&&name[i2-1]==')')||
-                    (name[i2-2]=='['&&name[i2-1]==']')){
-                    subScripts[0]=LONG_MAX;
-                    subScripts[1]=-1;
+                    (name[i2-2]=='['&&name[i2-1]==']'))
+                {
+                    subscripts.push_back( LONG_MAX );
 
                     name[i2-2]=0;
                 }
                 else{
-                    GetArrange(name,temp2,subScripts);
+                    GetArrange(name,temp2,subscripts);
                     lstrcpy(name,temp2);
                 }
@@ -273 +324 @@
             Parameter *pParam = new Parameter( name, type, isRef );
             if( isArray ){
-                pParam->SetArray( subScripts );
+                pParam->SetArray( subscripts );
             }
 
@@ -376 +427 @@
 }
 
-const NamespaceScopes &GlobalProc::GetNamespaceScopes() const
-{
-    if( HasParentClass() ){
-        return GetParentClassPtr()->GetNamespaceScopes();
-    }
-    return namespaceScopes;
-}
-bool GlobalProc::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const
+const UserProc *UserProc::pCompilingUserProc = NULL;
+
+
+bool UserProcs::Insert( UserProc *pUserProc, int nowLine )
+{
+    /////////////////////////////////
+    // ハッシュデータに追加
+    /////////////////////////////////
+
+    if( !Put( pUserProc ) )
+    {
+        // 重複しているため、失敗
+        SetError(15,pUserProc->GetName().c_str(),nowLine);
+        return false;
+    }
+
+    return true;
+}
+UserProc *UserProcs::Add( const NamespaceScopes &namespaceScopes, const NamespaceScopesCollection &importedNamespaces, char *buffer,int nowLine,bool isVirtual,CClass *pobj_c, bool isStatic)
+{
+    int i2,i3;
+    char temporary[8192];
+
+    int i=1;
+
+    Procedure::Kind kind = Procedure::Sub;
+    bool isMacro = false;
+    if(buffer[i]==ESC_FUNCTION) kind = Procedure::Function;
+    if(buffer[i]==ESC_MACRO){
+        isMacro = true;
+    }
+
+    i++;
+
+    bool isCdecl = false;
+    bool isExport = false;
+    while(1){
+        if(buffer[i]==1&&buffer[i+1]==ESC_CDECL&& isCdecl == false ){
+            isCdecl = true;
+
+            i+=2;
+        }
+        else if(buffer[i]==1&&buffer[i+1]==ESC_EXPORT&& isExport == false ){
+            isExport = true;
+
+            i+=2;
+        }
+        else break;
+    }
+
+    i2=0;
+    if(buffer[i]==1&&buffer[i+1]==ESC_OPERATOR){
+        if(!pobj_c){
+            SetError(126,NULL,nowLine);
+            return 0;
+        }
+
+        //オペレータの場合
+        temporary[i2++]=buffer[i++];
+        temporary[i2++]=buffer[i++];
+
+        int iCalcId;
+        if(buffer[i]=='='&&buffer[i+1]=='='){
+            iCalcId=CALC_EQUAL;
+            i3=2;
+        }
+        else if(buffer[i]=='='){
+            iCalcId=CALC_SUBSITUATION;
+            i3=1;
+        }
+        else if(buffer[i]=='('){
+            iCalcId=CALC_AS;
+            i3=0;
+        }
+        else if(buffer[i]=='['&&buffer[i+1]==']'&&buffer[i+2]=='='){
+            iCalcId=CALC_ARRAY_SET;
+            i3=3;
+        }
+        else if(buffer[i]=='['&&buffer[i+1]==']'){
+            iCalcId=CALC_ARRAY_GET;
+            i3=2;
+        }
+        else{
+            iCalcId=GetCalcId(buffer+i,&i3);
+            i3++;
+        }
+        if(!iCalcId){
+            SetError(1,NULL,nowLine);
+            return 0;
+        }
+        temporary[i2++]=iCalcId;
+        temporary[i2]=0;
+
+        i+=i3;
+    }
+    else{
+        if(pobj_c){
+            //クラスメンバの場合、デストラクタには~が付くことを考慮
+            if(buffer[i]=='~'){
+                temporary[i2]='~';
+                i++;
+                i2++;
+            }
+        }
+
+        for(;;i++,i2++){
+            if(!IsVariableChar(buffer[i])){
+                temporary[i2]=0;
+                break;
+            }
+            temporary[i2]=buffer[i];
+        }
+    }
+
+    if( isMacro ){
+        //大文字に変換
+        CharUpper(temporary);
+
+        //マクロ関数の場合は名前リストに追加
+        macroNames.push_back( temporary );
+    }
+
+    if(!pobj_c){
+        //クラスメンバ以外の場合のみ
+        //重複チェック
+
+        if(GetDeclareHash(temporary)){
+            SetError(15,temporary,nowLine);
+            return 0;
+        }
+    }
+
+    // 識別ID
+    static int id_base=0;
+
+    UserProc *pUserProc = new UserProc( namespaceScopes, importedNamespaces, temporary, kind, isMacro, isCdecl, isExport, (id_base++) );
+    pUserProc->SetParentClass( pobj_c );
+    if( Smoothie::isFullCompile ){
+        // すべての関数・メソッドをコンパイルする
+        pUserProc->Using();
+    }
+
+    if(isExport){
+        pUserProc->Using();
+    }
+
+    // パラメータを解析
+    // ※第1パラメータにに指定するデータの例："( s As String ) As String"
+    pUserProc->SetParamsAndReturnType( buffer + i, nowLine, isStatic );
+
+    pUserProc->_paramStr = buffer + i;
+
+    // ハッシュに追加
+    if( !Insert( pUserProc, nowLine ) )
+    {
+        return NULL;
+    }
+
+    return pUserProc;
+}
+void UserProcs::EnumGlobalProcs( const char *simpleName, const char *localName, std::vector<const UserProc *> &subs )
+{
+    ///////////////////////////
+    // グローバル関数を検索
+    ///////////////////////////
+
+    // ハッシュ値を取得
+    UserProc *pUserProc = GetHashArrayElement( simpleName );
+    while(pUserProc){
+        if(!pUserProc->GetParentClassPtr()){
+            if( pUserProc->IsEqualSymbol( localName ) ){
+                subs.push_back( pUserProc );
+            }
+        }
+
+        pUserProc=pUserProc->GetChainNext();
+    }
+}
+
+
+bool DllProc::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const
 {
     if( GetName() != name ){
         return false;
     }
-
-    return compiler.GetNamespaceSupporter().IsSameAreaNamespace( GetNamespaceScopes(), namespaceScopes );
-}
-bool GlobalProc::IsEqualSymbol( const GlobalProc &globalProc ) const
-{
-    return IsEqualSymbol( globalProc.GetNamespaceScopes(), globalProc.GetName() );
-}
-bool GlobalProc::IsEqualSymbol( const string &fullName ) const
+    return compiler.GetNamespaceSupporter().IsSameAreaNamespace( this->GetNamespaceScopes(), namespaceScopes );
+}
+bool DllProc::IsEqualSymbol( const string &fullName ) const
 {
     char AreaName[VN_SIZE] = "";        //オブジェクト変数
     char NestName[VN_SIZE] = "";        //入れ子メンバ
-    bool isNest = CClass::SplitName( fullName.c_str(), AreaName, NestName );
-
-    return IsEqualSymbol( NamespaceScopes( AreaName ), NestName );
-}
-
-bool DllProcImpl::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const
-{
-    if( GetName() != name ){
-        return false;
-    }
-    return compiler.GetNamespaceSupporter().IsSameAreaNamespace( this->GetNamespaceScopes(), namespaceScopes );
-}
-bool DllProcImpl::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
+    bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );
+
+    if( IsEqualSymbol( NamespaceScopes( AreaName ), NestName ) ){
+        return true;
+    }
+
+    if( isNest ){
+        // 静的メンバを考慮
+
+        char AreaName2[VN_SIZE] = "";       //オブジェクト変数
+        char NestName2[VN_SIZE] = "";       //入れ子メンバ
+        bool isNest = SplitMemberName( AreaName, AreaName2, NestName2 );
+        lstrcat( NestName2, "." );
+        lstrcat( NestName2, NestName );
+
+        return IsEqualSymbol( NamespaceScopes( AreaName2 ), NestName2 );
+    }
+
+    return false;
+}
+bool DllProc::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
     int i = 0;
     int i2,i3,sw;
@@ -443 +670 @@
         //パラメータ名
         bool isArray = false;
-        int subScripts[MAX_ARRAYDIM];
+        Subscripts subscripts;
         char name[VN_SIZE];
         sw=0;
@@ -475 +702 @@
 
             if((name[i2-2]=='('&&name[i2-1]==')')||
-                (name[i2-2]=='['&&name[i2-1]==']')){
-                subScripts[0]=LONG_MAX;
-                subScripts[1]=-1;
+                (name[i2-2]=='['&&name[i2-1]==']'))
+            {
+                subscripts.push_back( LONG_MAX );
 
                 name[i2-2]=0;
             }
             else{
-                GetArrange(name,temp2,subScripts);
+                GetArrange(name,temp2,subscripts);
                 lstrcpy(name,temp2);
             }
@@ -528 +755 @@
         Parameter *pParam = new Parameter( name, type, isRef );
         if( isArray ){
-            pParam->SetArray( subScripts );
+            pParam->SetArray( subscripts );
         }
 
@@ -584 +811 @@
 }
 
-bool ProcPointerImpl::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
+bool ProcPointer::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
     int i = 0;
     int i2,i3,sw;
@@ -615 +842 @@
         //パラメータ名
         bool isArray = false;
-        int subScripts[MAX_ARRAYDIM];
+        Subscripts subscripts;
         char name[VN_SIZE];
         sw=0;
@@ -647 +874 @@
 
             if((name[i2-2]=='('&&name[i2-1]==')')||
-                (name[i2-2]=='['&&name[i2-1]==']')){
-                subScripts[0]=LONG_MAX;
-                subScripts[1]=-1;
+                (name[i2-2]=='['&&name[i2-1]==']'))
+            {
+                subscripts.push_back( LONG_MAX );
 
                 name[i2-2]=0;
             }
             else{
-                GetArrange(name,temp2,subScripts);
+                GetArrange(name,temp2,subscripts);
                 lstrcpy(name,temp2);
             }
@@ -699 +926 @@
         Parameter *pParam = new Parameter( name, type, isRef );
         if( isArray ){
-            pParam->SetArray( subScripts );
+            pParam->SetArray( subscripts );
         }
 
@@ -771 +998 @@
 }
 
-int ProcPointersImpl::Add( const string &typeExpression )
+int ProcPointers::Add( const string &typeExpression )
 {
     DWORD dwProcType = (DWORD)typeExpression[2];
@@ -781 +1008 @@
     }
 
-    ProcPointer *pProcPointer = new ProcPointerImpl( kind );
+    ProcPointer *pProcPointer = new ProcPointer( kind );
 
     //buffer[0]は'('となっている
@@ -792 +1019 @@
 }
 
-void ProcPointersImpl::Clear()
-{
-    ProcPointersImpl &procPointers = *this;
+void ProcPointers::Clear()
+{
+    ProcPointers &procPointers = *this;
     BOOST_FOREACH( ProcPointer *pProcPointer, procPointers ){
         delete pProcPointer;

trunk/abdev/BasicCompiler_Common/src/Program.cpp

@@ +1 @@
+#include "stdafx.h"
+
 #include <jenga/include/common/Environment.h>
 
 #include <Program.h>
 
-Jenga::Common::Logger Program::logger( Jenga::Common::Environment::GetAppDir() + "\\logger.log" );
+Jenga::Common::Logger Program::logger( Jenga::Common::Environment::GetAppDir() + "\\logger.log", true );

trunk/abdev/BasicCompiler_Common/src/SmoothieImpl.cpp

@@ +1 @@
+#include "stdafx.h"
+
 #include <jenga/include/smoothie/Smoothie.h>
 
 #include <SmoothieImpl.h>
-#include <ClassImpl.h>
-#include <ProcedureImpl.h>
+#include <Class.h>
+#include <Procedure.h>
 #include <LexicalScopingImpl.h>
 

trunk/abdev/BasicCompiler_Common/src/TypeDef.cpp

@@ +1 @@
+#include "stdafx.h"
+
 #include <jenga/include/smoothie/Smoothie.h>
-#include <jenga/include/smoothie/Class.h>
 #include <jenga/include/smoothie/SmoothieException.h>
+#include <jenga/include/smoothie/LexicalAnalysis.h>
 
 #include <TypeDef.h>
@@ -8 +10 @@
 
 TypeDef::TypeDef( const NamespaceScopes &namespaceScopes, const string &name, const string &baseName, int nowLine )
-    : namespaceScopes( namespaceScopes )
-    , name( name )
+    : Symbol( namespaceScopes, name )
     , baseName( baseName )
 {
@@ -17 +18 @@
     }
 }
-TypeDef::~TypeDef(){
-}
-
+/*
 bool TypeDef::IsEqualSymbol( const NamespaceScopes &namespaceScopes, const string &name ) const
 {
@@ -31 +30 @@
     char AreaName[VN_SIZE] = "";        //オブジェクト変数
     char NestName[VN_SIZE] = "";        //入れ子メンバ
-    bool isNest = CClass::SplitName( fullName.c_str(), AreaName, NestName );
+    bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );
 
     if( IsEqualSymbol( NamespaceScopes( AreaName ), NestName ) ){
@@ -42 +41 @@
         char AreaName2[VN_SIZE] = "";       //オブジェクト変数
         char NestName2[VN_SIZE] = "";       //入れ子メンバ
-        bool isNest = CClass::SplitName( AreaName, AreaName2, NestName2 );
+        bool isNest = SplitMemberName( AreaName, AreaName2, NestName2 );
         lstrcat( NestName2, "." );
         lstrcat( NestName2, NestName );
@@ -50 +49 @@
 
     return false;
-}
+}*/
 
 
@@ -74 +73 @@
     char AreaName[VN_SIZE] = "";        //オブジェクト変数
     char NestName[VN_SIZE] = "";        //入れ子メンバ
-    bool isNest = CClass::SplitName( fullName.c_str(), AreaName, NestName );
+    bool isNest = SplitMemberName( fullName.c_str(), AreaName, NestName );
 
     return GetIndex( NamespaceScopes( AreaName ), NestName );