Changeset 75 in dev for BasicCompiler_Common

Timestamp:

Mar 20, 2007, 4:36:16 AM (17 years ago)

Author:

dai_9181

Message:

TYPEINFO→Typeへのリファクタリングを実施。64bitはほぼ完了。32bitが全般的に未完成。

Location:

BasicCompiler_Common

Files:

• BasicCompiler.h (modified) (1 diff)
• Class.cpp (modified) (42 diffs)
• Class.h (modified) (12 diffs)
• CommandFormat.cpp (modified) (20 diffs)
• Const.cpp (modified) (1 diff)
• Debug.cpp (modified) (4 diffs)
• DebugMiddleFile.cpp (modified) (23 diffs)
• DebugSection.h (modified) (1 diff)
• Enum.cpp (modified) (3 diffs)
• Enum.h (modified) (1 diff)
• Intermediate_Step2.cpp (modified) (7 diffs)
• LexicalScoping.cpp (modified) (6 diffs)
• LexicalScoping.h (modified) (1 diff)
• MakeExe.cpp (modified) (4 diffs)
• NumOpe_GetType.cpp (modified) (35 diffs)
• Object.cpp (modified) (4 diffs)
• Overload.cpp (modified) (5 diffs)
• PESchedule.cpp (modified) (5 diffs)
• PESchedule.h (modified) (3 diffs)
• ParamImpl.cpp (modified) (12 diffs)
• Parameter.h (modified) (1 diff)
• Procedure.cpp (modified) (1 diff)
• Procedure.h (modified) (1 diff)
• Resource.cpp (modified) (1 diff)
• Subroutine.cpp (modified) (21 diffs)
• Type.cpp (modified) (5 diffs)
• Type.h (modified) (7 diffs)
• Variable.cpp (modified) (1 diff)
• Variable.h (modified) (1 diff)
• VariableOpe.cpp (added)
• VariableOpe.h (added)
• calculation.cpp (modified) (24 diffs)
• common.h (modified) (13 diffs)
• error.cpp (modified) (5 diffs)
• gc.cpp (modified) (4 diffs)
• hash.cpp (modified) (9 diffs)

BasicCompiler_Common/BasicCompiler.h

@@ -20 +20 @@
 
 //プログラム情報
-BOOL bCompilingGlobal;
 BOOL bStrict;
 DWORD ImageBase;
 INCLUDEFILEINFO IncludeFileInfo;
-SubInfo **ppSubHash;
+UserProc **ppSubHash;
 int SubNum;
 char **ppMacroNames;
 int MacroNum;
-DECLAREINFO **ppDeclareHash;
+DllProc **ppDeclareHash;
 CONSTINFO **ppConstHash;
-PROCPTRINFO *pProcPtrInfo;
+ProcPointer **ppProcPointer;
 int ProcPtrInfoNum;
 

BasicCompiler_Common/Class.cpp

@@ -16 +16 @@
 
 
-CMember::CMember( CClass *pobj_c, DWORD access, bool isConst, bool isRef, char *buffer, int NowLine ){
+CMember::CMember( CClass *pobj_c, DWORD access, bool isConst, bool isRef, char *buffer, int nowLine ){
     extern int cp;
 
@@ -23 +23 @@
     char init_buf[VN_SIZE];
     char constract_parameter[VN_SIZE];
-    GetDimentionFormat(buffer,isRef,VarName,SubScripts,&TypeInfo,init_buf,constract_parameter);
+    GetDimentionFormat(buffer,VarName,SubScripts,*this,init_buf,constract_parameter);
 
     //重複チェック
@@ -30 +30 @@
     }
 
-    if(TypeInfo.type==DEF_OBJECT){
-        if(TypeInfo.u.pobj_Class->IsAbstract()){
+    if( IsObject() ){
+        if( GetClass().IsAbstract() ){
             //抽象クラスだったとき
-            SetError(125,TypeInfo.u.pobj_Class->name,cp);
+            SetError(125,GetClass().name,cp);
         }
     }
@@ -47 +47 @@
     this->isConst = isConst;
 
-    //参照型かどうか
-    this->isRef = isRef;
-
     //初期データ
     InitBuf=(char *)HeapAlloc(hHeap,0,lstrlen(init_buf)+1);
@@ -59 +56 @@
 
     //ソースコードの位置
-    source_code_address=NowLine;
-}
-CMember::CMember(CMember *pobj){
-    //コピーコンストラクタ
-    memset(this,0,sizeof(CMember));
+    source_code_address=nowLine;
+}
+CMember::CMember(CMember &member):
+    Type( member )
+{
 
     //name
-    name=(char *)HeapAlloc(hHeap,0,lstrlen(pobj->name)+1);
-    lstrcpy(name,pobj->name);
+    name=(char *)HeapAlloc(hHeap,0,lstrlen(member.name)+1);
+    lstrcpy(name,member.name);
 
     //定数扱いかどうか
-    isConst = pobj->isConst;
-
-    //参照型かどうか
-    isRef = pobj->isRef;
+    isConst = member.isConst;
 
     //SubScripts
-    memcpy(SubScripts,pobj->SubScripts,MAX_ARRAYDIM*sizeof(int));
-
-    //TypeInfo
-    TypeInfo=pobj->TypeInfo;
+    memcpy(SubScripts,member.SubScripts,MAX_ARRAYDIM*sizeof(int));
 
     //ソースコードの位置
-    source_code_address=pobj->source_code_address;
+    source_code_address=member.source_code_address;
 }
 CMember::CMember(){
@@ -95 +86 @@
 bool CMember::IsConst(){
     return isConst;
-}
-bool CMember::IsRef(){
-    return isRef;
-}
-
-int CMember::GetSize(){
-    //メンバサイズを取得
-    return GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
 }
 
@@ -126 +109 @@
                 temporary,
                 member->SubScripts,
-                member->TypeInfo,
-                GetTypeSize(member->TypeInfo.type,member->TypeInfo.u.lpIndex),
+                *member,
                 member->InitBuf,
                 member->ConstractParameter,
@@ -151 +133 @@
     memset(this,0,sizeof(CMethod));
 
-    psi=pobj->psi;
+    pUserProc=pobj->pUserProc;
 
     bAbstract=pobj->bAbstract;
@@ -224 +206 @@
     iMemberNum=pInheritsClass->iMemberNum;
     for(i3=0;i3<pInheritsClass->iMemberNum;i3++){
-        ppobj_Member[i3]=new CMember(pInheritsClass->ppobj_Member[i3]);
+        ppobj_Member[i3]=new CMember( *pInheritsClass->ppobj_Member[i3] );
 
         //dwAccess
@@ -263 +245 @@
     iMemberNum++;
 }
-void CClass::AddStaticMember( DWORD dwAccess, bool isConst, bool isRef, char *buffer, int NowLine ){
-    CMember *member = new CMember( this, dwAccess, isConst, isRef, buffer, NowLine );
+void CClass::AddStaticMember( DWORD dwAccess, bool isConst, bool isRef, char *buffer, int nowLine ){
+    CMember *member = new CMember( this, dwAccess, isConst, isRef, buffer, nowLine );
     staticMembers.push_back( member );
 }
-void CClass::AddMethod( SubInfo *psi,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual ){
+void CClass::AddMethod( UserProc *pUserProc,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual ){
     CMethod *method = new CMethod();
-    method->psi = psi;
+    method->pUserProc = pUserProc;
     method->dwAccess = dwAccess;
     method->isConst = isConst;
@@ -277 +259 @@
 
     methods.push_back( method );
-}
-void CClass::AddStaticMethod(SubInfo *psi,DWORD dwAccess){
+
+    // プロシージャオブジェクトと関連付け
+    pUserProc->SetMethod( method );
+}
+void CClass::AddStaticMethod(UserProc *pUserProc,DWORD dwAccess){
     CMethod *method = new CMethod();
-    method->psi=psi;
+    method->pUserProc=pUserProc;
     method->dwAccess=dwAccess;
     method->bAbstract=0;
@@ -287 +272 @@
 
     staticMethods.push_back( method );
+
+    // プロシージャオブジェクトと関連付け
+    pUserProc->SetMethod( method );
 }
 BOOL CClass::DupliCheckAll(const char *name){
@@ -296 +284 @@
     //メソッド
     foreach( CMethod *method, methods ){
-        if( lstrcmp( name, method->psi->name ) == 0 ){
+        if( lstrcmp( name, method->pUserProc->GetName().c_str() ) == 0 ){
             return 1;
         }
@@ -322 +310 @@
     return 0;
 }
-CMethod *CClass::GetMethodInfo( SubInfo *psi ){
+CMethod *CClass::GetMethodInfo( UserProc *pUserProc ) const
+{
     for( int i=(int)methods.size()-1; i>=0; i-- ){
-        if( psi == methods[i]->psi ) return methods[i];
+        if( pUserProc == methods[i]->pUserProc ) return methods[i];
     }
     return NULL;
 }
-CMethod *CClass::GetStaticMethodInfo( SubInfo *psi ){
+CMethod *CClass::GetStaticMethodInfo( UserProc *pUserProc ) const
+{
     for( int i=(int)staticMethods.size()-1; i>=0; i-- ){
-        if( psi == staticMethods[i]->psi ) return staticMethods[i];
+        if( pUserProc == staticMethods[i]->pUserProc ) return staticMethods[i];
     }
     return NULL;
 }
-bool CClass::IsExistMethod( const char *name ){
+bool CClass::IsExistMethod( const char *name ) const
+{
     foreach( CMethod *method, methods ){
-        if( lstrcmp( method->psi->name, name ) == 0 ) return true;
+        if( method->pUserProc->GetName() == name ) return true;
     }
     return false;
 }
-bool CClass::IsExistStaticMethod( const char *name ){
+bool CClass::IsExistStaticMethod( const char *name ) const
+{
     foreach( CMethod *method, staticMethods ){
-        if( lstrcmp( method->psi->name, name ) == 0 ) return true;
+        if( method->pUserProc->GetName() == name ) return true;
     }
     return false;
 }
 
-void CClass::EnumStaticMethod( const char *methodName, std::vector<SubInfo *> &subs ) const
+void CClass::EnumStaticMethod( const char *methodName, std::vector<UserProc *> &subs ) const
 {
     foreach( CMethod *method, staticMethods ){
-        if(lstrcmp(methodName,method->psi->name)==0){
-            subs.push_back( method->psi );
-        }
-    }
-}
-
-void CClass::EnumMethod( const char *methodName, std::vector<SubInfo *> &subs ) const
+        if( method->pUserProc->GetName() == methodName ){
+            subs.push_back( method->pUserProc );
+        }
+    }
+}
+
+void CClass::EnumMethod( const char *methodName, std::vector<UserProc *> &subs ) const
 {
     //オブジェクトのメンバ関数の場合
     //※オーバーライドされた関数を先にサーチする必要があるため、バックサーチを行う
     for( int i=(int)methods.size()-1; i>=0; i-- ){
-        if(lstrcmp(methodName,methods[i]->psi->name)==0){
-            subs.push_back( methods[i]->psi );
-        }
-    }
-}
-
-void CClass::EnumMethod( const BYTE idOperatorCalc, std::vector<SubInfo *> &subs ) const
+        if( methods[i]->pUserProc->GetName() == methodName ){
+            subs.push_back( methods[i]->pUserProc );
+        }
+    }
+}
+
+void CClass::EnumMethod( const BYTE idOperatorCalc, std::vector<UserProc *> &subs ) const
 {
     //オブジェクトのメンバ関数の場合
     //※オーバーライドされた関数を先にサーチする必要があるため、バックサーチを行う
     for( int i=(int)methods.size()-1; i>=0; i-- ){
-        SubInfo *psi = methods[i]->psi;
-        char *temp = psi->name;
+        UserProc *pUserProc = methods[i]->pUserProc;
+        const char *temp = pUserProc->GetName().c_str();
         if(temp[0]==1&&temp[1]==ESC_OPERATOR){
             if((BYTE)temp[2]==idOperatorCalc){
-                subs.push_back( psi );
+                subs.push_back( pUserProc );
             }
         }
@@ -423 +415 @@
         //アラインメントを算出
         int member_size;
-        if(pMember->TypeInfo.type==DEF_STRUCT){
+        if( pMember->IsStruct() ){
             //メンバクラスのアラインメントを取得
-            member_size=pMember->TypeInfo.u.pobj_Class->GetAlignment();
+            member_size=pMember->GetClass().GetAlignment();
         }
         else{
@@ -486 +478 @@
         CMember *pMember = ppobj_Member[i];
 
-        if(pMember->TypeInfo.type==DEF_STRUCT){
+        if(pMember->IsStruct()){
             //メンバクラスのアラインメントを取得
-            member_size=pMember->TypeInfo.u.pobj_Class->GetAlignment();
+            member_size=pMember->GetClass().GetAlignment();
         }
         else{
@@ -508 +500 @@
 
 
-int CClass::GetFuncNumInVtbl( const SubInfo *psi ) const
+int CClass::GetFuncNumInVtbl( const UserProc *pUserProc ) const
 {
     int n = 0;
     foreach( CMethod *method, methods ){
-        if( method->psi == psi ) break;
-        if( method->psi->bVirtual ) n++;
+        if( method->pUserProc == pUserProc ) break;
+        if( method->bVirtual ) n++;
     }
     return n;
@@ -527 +519 @@
     //////////////////////////////////////
 
-    SubInfo **ppsi;
-    ppsi=(SubInfo **)HeapAlloc(hHeap,0,vtbl_num*sizeof(SubInfo *));
+    UserProc **ppsi;
+    ppsi=(UserProc **)HeapAlloc(hHeap,0,vtbl_num*sizeof(UserProc *));
 
     //関数テーブルに値をセット
@@ -534 +526 @@
     foreach( CMethod *method, methods ){
         if(method->bVirtual){
-            method->psi->bUse=1;
+            method->pUserProc->Using();
 
             if(method->bAbstract){
@@ -542 +534 @@
                 ppsi[i2]=0;
             }
-            else ppsi[i2]=method->psi;
+            else ppsi[i2]=method->pUserProc;
             i2++;
         }
@@ -565 +557 @@
     int i;
     for(i=0;i<vtbl_num;i++){
-        SubInfo *psi;
-        psi=(SubInfo *)pVtbl[i];
-        if(!psi) continue;
-        pVtbl[i]=psi->CompileAddress+ImageBase+MemPos_CodeSection;
-    }
-}
-bool CClass::IsAbstract(){
+        UserProc *pUserProc;
+        pUserProc=(UserProc *)pVtbl[i];
+        if(!pUserProc) continue;
+        pVtbl[i]=pUserProc->beginOpAddress+ImageBase+MemPos_CodeSection;
+    }
+}
+bool CClass::IsAbstract() const
+{
     //未実装の仮想関数を持つ場合はtrueを返す
 
@@ -584 +577 @@
     //コンポジションの関係にあるメンバも検査する
     for(int i=0;i < iMemberNum;i++){
-        if(ppobj_Member[i]->TypeInfo.type==DEF_OBJECT){
-            if(ppobj_Member[i]->TypeInfo.u.pobj_Class->IsAbstract())
+        if(ppobj_Member[i]->IsObject()){
+            if(ppobj_Member[i]->GetClass().IsAbstract())
                 return true;
         }
@@ -604 +597 @@
 
 //コンストラクタをコンパイル中かどうかを判別
-bool CClass::IsCompilingConstructor(){
+bool CClass::IsCompilingConstructor() const
+{
     return isCompilingConstructor;
 }
@@ -619 +613 @@
 
 //デストラクタをコンパイル中かどうかを判別
-bool CClass::IsCompilingDestructor(){
+bool CClass::IsCompilingDestructor() const
+{
     return isCompilingDestructor;
 }
@@ -625 +620 @@
 
 //自身と等しいクラスかどうかを確認
-bool CClass::IsEquals( CClass *pClass ){
+bool CClass::IsEquals( const CClass *pClass ) const
+{
     if( this == pClass ) return true;
     return false;
@@ -631 +627 @@
 
 //自身の派生クラスかどうかを確認
-bool CClass::IsSubClass( CClass *pClass ){
+bool CClass::IsSubClass( const CClass *pClass ) const
+{
     pClass = pClass->pobj_InheritsClass;
     while( pClass ){
@@ -641 +638 @@
 
 //自身と等しいまたは派生クラスかどうかを確認
-bool CClass::IsEqualsOrSubClass( CClass *pClass ){
+bool CClass::IsEqualsOrSubClass( const CClass *pClass ) const
+{
     if( IsEquals( pClass ) ) return true;
     return IsSubClass( pClass );
@@ -722 +720 @@
 }
 
-CClass *CDBClass::AddClass(const char *name,int NowLine){
+CClass *CDBClass::AddClass(const char *name,int nowLine){
     //////////////////////////////////////////////////////////////////////////
     // クラスを追加
@@ -753 +751 @@
             if(lstrcmp(name,pobj_c2->name)==0){
                 //重複した場合
-                SetError(15,name,NowLine);
+                SetError(15,name,nowLine);
                 return 0;
             }
@@ -781 +779 @@
             basbuf[i+1]==ESC_INTERFACE
             )){
-                int NowLine;
-                NowLine=i;
+                int nowLine;
+                nowLine=i;
 
                 i+=2;
@@ -802 +800 @@
 
                 //クラスを追加
-                CClass *pClass = pobj_DBClass->AddClass(temporary,NowLine);
+                CClass *pClass = pobj_DBClass->AddClass(temporary,nowLine);
                 if( pClass ){
-                    if( basbuf[NowLine+1] == ESC_CLASS ){
+                    if( basbuf[nowLine+1] == ESC_CLASS ){
                         pClass->classType = CClass::Class;
                     }
-                    else if( basbuf[NowLine+1] == ESC_INTERFACE ){
+                    else if( basbuf[nowLine+1] == ESC_INTERFACE ){
                         pClass->classType = CClass::Interface;
                     }
@@ -820 +818 @@
 
 void CDBClass::AddMethod(CClass *pobj_c, DWORD dwAccess, BOOL bStatic, bool isConst, BOOL bAbstract,
-                         BOOL bVirtual, BOOL bOverride, char *buffer, int NowLine){
+                         BOOL bVirtual, BOOL bOverride, char *buffer, int nowLine){
     int i,i2;
     char temporary[VN_SIZE];
@@ -835 +833 @@
 
     //関数ハッシュへ登録
-    SubInfo *psi;
-    psi=AddSubData(buffer,NowLine,bVirtual,pobj_c,bStatic);
-    if(!psi) return;
+    UserProc *pUserProc;
+    pUserProc=AddSubData(buffer,nowLine,bVirtual,pobj_c, (bStatic!=0) );
+    if(!pUserProc) return;
 
 
@@ -849 +847 @@
 
         //標準コンストラクタ（引数なし）
-        if(psi->params.size()==0) fConstructor=1;
+        if(pUserProc->Params().size()==0) fConstructor=1;
 
         //強制的にConst修飾子をつける
@@ -857 +855 @@
         //デストラクタの場合はその名前が正しいかチェックを行う
         if(lstrcmp(temporary+1,pobj_c->name)!=0)
-            SetError(117,NULL,NowLine);
+            SetError(117,NULL,nowLine);
         else
             bDestructor=1;
@@ -864 +862 @@
         // コンストラクタ、デストラクタのアクセシビリティをチェック
         if(dwAccess!=ACCESS_PUBLIC){
-            SetError(116,NULL,NowLine);
+            SetError(116,NULL,nowLine);
             dwAccess=ACCESS_PUBLIC;
         }
@@ -884 +882 @@
 
     if(pobj_c->DupliCheckMember(temporary)){
-        SetError(15,temporary,NowLine);
+        SetError(15,temporary,nowLine);
         return;
     }
@@ -893 +891 @@
         if(method->pobj_InheritsClass) continue;
 
-        if(lstrcmp(temporary,method->psi->name)==0){
-            if( Parameter::Equals( method->psi->params, psi->params ) ){
+        if( method->pUserProc->GetName() == temporary ){
+            if( Parameter::Equals( method->pUserProc->Params(), pUserProc->Params() ) ){
                 //関数名、パラメータ属性が合致したとき
-                SetError(15,psi->name,NowLine);
+                SetError(15,pUserProc->GetName().c_str(),nowLine);
                 return;
             }
@@ -903 +901 @@
 
     //仮想関数の場合
-    if(bAbstract) psi->bCompile=1;
+    if(bAbstract) pUserProc->CompleteCompile();
 
     //メソッドのオーバーライド
     foreach( CMethod *method, pobj_c->methods ){
-        if(lstrcmp(temporary,method->psi->name)==0){
-            if( Parameter::Equals( method->psi->params, psi->params ) ){
-
-                if(method->psi->bVirtual){
+        if( method->pUserProc->GetName() == temporary ){
+            if( Parameter::Equals( method->pUserProc->Params(), pUserProc->Params() ) ){
+
+                if(method->bVirtual){
                     //メンバ関数を上書き
-                    method->psi=psi;
+                    method->pUserProc=pUserProc;
                     method->bAbstract=0;
 
                     if(!bOverride){
-                        SetError(127,NULL,NowLine);
+                        SetError(127,NULL,nowLine);
                     }
                     if(method->dwAccess!=dwAccess){
-                        SetError(128,NULL,NowLine);
+                        SetError(128,NULL,nowLine);
                     }
+
+                    pUserProc->SetMethod( method );
                     return;
                 }
@@ -927 +927 @@
     }
 
-    if(psi->bVirtual){
+    if(bVirtual){
         pobj_c->vtbl_num++;
     }
 
     if(bOverride){
-        SetError(12,"Override",NowLine);
+        SetError(12,"Override",nowLine);
     }
 
     if(bStatic){
-        pobj_c->AddStaticMethod(psi,dwAccess);
+        pobj_c->AddStaticMethod(pUserProc,dwAccess);
     }
     else{
-        pobj_c->AddMethod(psi, dwAccess, isConst, bAbstract, bVirtual);
-    }
-}
-
-BOOL CDBClass::MemberVar_LoopRefCheck(CClass *pobj_c){
+        pobj_c->AddMethod(pUserProc, dwAccess, isConst, bAbstract, bVirtual);
+    }
+}
+
+BOOL CDBClass::MemberVar_LoopRefCheck(const CClass &objClass){
     int i,i2,bRet=1;
-    for(i=0;i<pobj_c->iMemberNum;i++){
-        CMember *pMember = pobj_c->ppobj_Member[i];
-        if(pMember->TypeInfo.type==DEF_OBJECT){
+    for(i=0;i<objClass.iMemberNum;i++){
+        const CMember *pMember = objClass.ppobj_Member[i];
+        if(pMember->IsObject()){
             //循環参照でないかをチェック
-            if(pobj_LoopRefCheck->check(pMember->TypeInfo.u.pobj_Class->name)){
+            if(pobj_LoopRefCheck->check(pMember->GetClass().name)){
                 extern int cp;
-                SetError(124,pMember->TypeInfo.u.pobj_Class->name,cp);
+                SetError(124,pMember->GetClass().name,cp);
                 return 0;
             }
 
-            pobj_LoopRefCheck->add(pobj_c->name);
-
-            i2=MemberVar_LoopRefCheck(pMember->TypeInfo.u.pobj_Class);
+            pobj_LoopRefCheck->add(objClass.name);
+
+            i2=MemberVar_LoopRefCheck(pMember->GetClass());
             if(bRet==1) bRet=i2;
 
-            pobj_LoopRefCheck->del(pobj_c->name);
+            pobj_LoopRefCheck->del(objClass.name);
         }
     }
@@ -1347 +1347 @@
 
 
-                        if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_OBJECT||
-                            pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_STRUCT){
-                            if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.u.pobj_Class->ppobj_Member==0){
+                        if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->IsObject()||
+                            pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->IsStruct()){
+                            if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->GetClass().ppobj_Member==0){
                                 //参照先が読み取られていないとき
-                                GetClass_recur(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.u.pobj_Class->name);
+                                GetClass_recur(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->GetClass().name);
                             }
                         }
 
 
-                        if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_OBJECT){
+                        if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->IsObject()){
                             //循環参照のチェック
                             pobj_LoopRefCheck->add(pobj_c->name);
-                            if(!MemberVar_LoopRefCheck(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.u.pobj_Class)){
+                            if(!MemberVar_LoopRefCheck(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->GetClass())){
                                 //エラー回避
-                                pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type=DEF_PTR_VOID;
+                                pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->SetBasicType( DEF_PTR_VOID );
                             }
                             pobj_LoopRefCheck->del(pobj_c->name);
@@ -1438 +1438 @@
 }
 
-void CDBClass::StartCompile( SubInfo *psi ){
-    pCompilingClass = psi->pobj_ParentClass;
+void CDBClass::StartCompile( UserProc *pUserProc ){
+    pCompilingClass = pUserProc->GetParentClassPtr();
     if( pCompilingClass ){
-        pCompilingMethod = pCompilingClass->GetMethodInfo( psi );
+        pCompilingMethod = pCompilingClass->GetMethodInfo( pUserProc );
         if( !pCompilingMethod ){
-            pCompilingMethod = pCompilingClass->GetStaticMethodInfo( psi );
+            pCompilingMethod = pCompilingClass->GetStaticMethodInfo( pUserProc );
             if( !pCompilingMethod ){
                 SetError(300,NULL,cp);

BasicCompiler_Common/Class.h

@@ -1 +1 @@
 #include <vector>
+#include "Type.h"
 
 class CClass;
-class SubInfo;
-
-//データ型
-struct TYPEINFO{
-    int type;
-    union{
-        LONG_PTR lpIndex;
-        CClass *pobj_Class;
-    }u;
-};
+class UserProc;
 
 #define ACCESS_NON          0
@@ -18 +10 @@
 #define ACCESS_PROTECTED    3
 
-class CMember{
+class CMember : public Type
+{
     bool isConst;
-    bool isRef;
 public:
     char *name;
     int SubScripts[MAX_ARRAYDIM];
-    TYPEINFO TypeInfo;
 
     DWORD dwAccess;
@@ -34 +25 @@
 
 
-    CMember( CClass *pobj_c, DWORD access, bool idConst, bool isRef, char *buffer, int NowLine=-1 );
-    CMember( CMember *pobj );
+    CMember( CClass *pobj_c, DWORD access, bool idConst, bool isRef, char *buffer, int nowLine=-1 );
+    CMember( CMember &member );
     CMember();
     ~CMember();
 
     bool IsConst();
-    bool IsRef();
-    int GetSize();
 
 
@@ -48 +37 @@
 class CMethod{
 public:
-    SubInfo *psi;
+    UserProc *pUserProc;
     DWORD dwAccess;
     BOOL bAbstract;
@@ -115 +104 @@
     //メンバ、メソッドの追加
     void AddMember( DWORD dwAccess, bool idConst, bool isRef, char *buffer );
-    void AddStaticMember( DWORD dwAccess, bool isConst, bool isRef, char *buffer, int NowLine );
-    void AddMethod( SubInfo *psi,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual );
-    void AddStaticMethod(SubInfo *psi,DWORD dwAccess);
+    void AddStaticMember( DWORD dwAccess, bool isConst, bool isRef, char *buffer, int nowLine );
+    void AddMethod( UserProc *pUserProc,DWORD dwAccess, bool isConst, BOOL bAbstract, BOOL bVirtual );
+    void AddStaticMethod(UserProc *pUserProc,DWORD dwAccess);
 
     //重複チェック
@@ -124 +113 @@
 
     //メソッド取得
-    CMethod *GetMethodInfo( SubInfo *psi );
-    CMethod *GetStaticMethodInfo( SubInfo *psi );
+    CMethod *GetMethodInfo( UserProc *pUserProc ) const;
+    CMethod *GetStaticMethodInfo( UserProc *pUserProc ) const;
 
     //メソッドの存在を確認
-    bool IsExistMethod( const char *name );
-    bool IsExistStaticMethod( const char *name );
+    bool IsExistMethod( const char *name ) const;
+    bool IsExistStaticMethod( const char *name ) const;
 
     //メソッドを列挙
-    void EnumStaticMethod( const char *methodName, std::vector<SubInfo *> &subs ) const;
-    void EnumMethod( const char *methodName, std::vector<SubInfo *> &subs ) const;
-    void EnumMethod( const BYTE idOperatorCalc, std::vector<SubInfo *> &subs ) const;
+    void EnumStaticMethod( const char *methodName, std::vector<UserProc *> &subs ) const;
+    void EnumMethod( const char *methodName, std::vector<UserProc *> &subs ) const;
+    void EnumMethod( const BYTE idOperatorCalc, std::vector<UserProc *> &subs ) const;
 
     //デフォルト コンストラクタ メソッドを取得
@@ -157 +146 @@
     long vtbl_offset;
 public:
-    int GetFuncNumInVtbl( const SubInfo *psi ) const;
+    int GetFuncNumInVtbl( const UserProc *pUserProc ) const;
     LONG_PTR GetVtblGlobalOffset(void);
     void ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection);
-    bool IsAbstract();
+    bool IsAbstract() const;
 
 
@@ -169 +158 @@
     void NotifyStartConstructorCompile();
     void NotifyFinishConstructorCompile();
-    bool IsCompilingConstructor();
+    bool IsCompilingConstructor() const;
 
     //デストラクタをコンパイルしているかどうかのチェックフラグ
@@ -177 +166 @@
     void NotifyStartDestructorCompile();
     void NotifyFinishDestructorCompile();
-    bool IsCompilingDestructor();
+    bool IsCompilingDestructor() const;
 
 
     //自身と等しいクラスかどうかを確認
-    bool IsEquals( CClass *pClass );
+    bool IsEquals( const CClass *pClass ) const;
 
     //自身の派生クラスかどうかを確認
-    bool IsSubClass( CClass *pClass );
+    bool IsSubClass( const CClass *pClass ) const;
 
     //自身と等しいまたは派生クラスかどうかを確認
-    bool IsEqualsOrSubClass( CClass *pClass );
+    bool IsEqualsOrSubClass( const CClass *pClass ) const;
 
 
@@ -214 +203 @@
     CClass *check(const char *name);
 
-    CClass *AddClass(const char *name,int NowLine);
+    CClass *AddClass(const char *name,int nowLine);
 
     void ActionVtblSchedule(LONG_PTR ImageBase, LONG_PTR MemPos_CodeSection);
@@ -220 +209 @@
 private:
     void AddMethod(CClass *pobj_c, DWORD dwAccess, BOOL bStatic, bool isConst, BOOL bAbstract,
-        BOOL bVirtual, BOOL bOverride, char *buffer, int NowLine);
-    BOOL MemberVar_LoopRefCheck(CClass *pobj_c);
+        BOOL bVirtual, BOOL bOverride, char *buffer, int nowLine);
+    BOOL MemberVar_LoopRefCheck(const CClass &objClass);
 public:
     void InitNames(void);
@@ -245 +234 @@
 public:
     //コンパイル開始の通知を受け取るメソッド
-    void StartCompile( SubInfo *psi );
+    void StartCompile( UserProc *pUserProc );
 
     //現在コンパイル中のメソッド情報を取得

BasicCompiler_Common/CommandFormat.cpp

@@ -1 +1 @@
 #include "common.h"
 
-void ComOpen(char *Parameter,char *buffer,int NowLine){
+void ComOpen(char *Parameter,char *buffer,int nowLine){
     int i,i2,IsStr;
     char temporary[255];
@@ -26 +26 @@
         for(i2=0;;i++,i2++){
             if(Parameter[i]=='\0'){
-                SetError(1,NULL,NowLine);
+                SetError(1,NULL,nowLine);
                 return;
             }
@@ -39 +39 @@
         else if(lstrcmpi(temporary,"append")==0) lstrcat(buffer,",3");
         else{
-            SetError(1,NULL,NowLine);
+            SetError(1,NULL,nowLine);
             return;
         }
@@ -63 +63 @@
 }
 
-void ComLine(char *Parameter,char *buffer,int NowLine){
+void ComLine(char *Parameter,char *buffer,int nowLine){
     int i,i2,PareNum;
     char temporary[VN_SIZE],temp2[VN_SIZE];
@@ -75 +75 @@
     else{
         if(Parameter[0]!='('){
-            SetError(10,"Line",NowLine);
+            SetError(10,"Line",nowLine);
             return;
         }
@@ -93 +93 @@
 
         if(Parameter[i+1]!='-'){
-            SetError(10,"Line",NowLine);
+            SetError(10,"Line",nowLine);
             return;
         }
@@ -107 +107 @@
 
     if(Parameter[i]!='('){
-        SetError(10,"Line",NowLine);
+        SetError(10,"Line",nowLine);
         return;
     }
@@ -129 +129 @@
     }
     else if(Parameter[i+1]!=','){
-        SetError(10,"Line",NowLine);
+        SetError(10,"Line",nowLine);
         return;
     }
@@ -147 +147 @@
     else if(lstrcmpi(temporary,"bf")==0) lstrcat(buffer,",2");
     else{
-        SetError(10,"Line",NowLine);
+        SetError(10,"Line",nowLine);
         return;
     }
@@ -158 +158 @@
     i=GetOneParameter(Parameter,i,temporary);   //第７パラメータ取得
     if(Parameter[i-1]==','){
-        SetError(10,"Line",NowLine);
+        SetError(10,"Line",nowLine);
         return;
     }
@@ -165 +165 @@
     lstrcat(buffer,temporary);
 }
-void ComCircle(char *Parameter,char *buffer,int NowLine){
+void ComCircle(char *Parameter,char *buffer,int nowLine){
     int i,i2,PareNum;
     char temporary[VN_SIZE],temp2[VN_SIZE];
@@ -172 +172 @@
 
     if(Parameter[0]!='('){
-        SetError(10,"Circle",NowLine);
+        SetError(10,"Circle",nowLine);
         return;
     }
@@ -189 +189 @@
     i++;
     if(Parameter[i]!=','){
-        SetError(10,"Circle",NowLine);
+        SetError(10,"Circle",nowLine);
         return;
     }
@@ -241 +241 @@
     }
     else{
-        SetError(10,"Circle",NowLine);
+        SetError(10,"Circle",nowLine);
         return;
     }
@@ -251 +251 @@
         lstrcat(buffer,temporary);
         if(Parameter[i-1]==','){
-            SetError(10,"Circle",NowLine);
+            SetError(10,"Circle",nowLine);
             return;
         }
@@ -260 +260 @@
     }
 }
-void ComPSet(char *Parameter,char *buffer,int NowLine){
+void ComPSet(char *Parameter,char *buffer,int nowLine){
     int i,i2,PareNum;
 
@@ -266 +266 @@
 
     if(Parameter[0]!='('){
-        SetError(10,"PSet",NowLine);
+        SetError(10,"PSet",nowLine);
         return;
     }
@@ -284 +284 @@
     else if(Parameter[i+1]=='\0') lstrcat(buffer,",7");
     else{
-        SetError(10,"PSet",NowLine);
-        return;
-    }
-}
-void ComPaint(char *Parameter,char *buffer,int NowLine){
+        SetError(10,"PSet",nowLine);
+        return;
+    }
+}
+void ComPaint(char *Parameter,char *buffer,int nowLine){
     int i,i2,PareNum;
 
@@ -294 +294 @@
 
     if(Parameter[0]!='('){
-        SetError(10,"Paint",NowLine);
+        SetError(10,"Paint",nowLine);
         return;
     }
@@ -309 +309 @@
     }
     if(Parameter[i+1]!=','){
-        SetError(10,"Paint",NowLine);
+        SetError(10,"Paint",nowLine);
         return;
     }

BasicCompiler_Common/Const.cpp

@@ -153 +153 @@
 }
 void CDBConst::AddConst(char *Name, char *Expression){
-    LONG_PTR lpIndex;
     _int64 i64data;
-    int Type = StaticCalculation(false, Expression, 0, &i64data, &lpIndex);
-
-    if(Type){
-        //リテラル値の場合
-        //登録を行う
-
-        CConst *newconst = new CConst(Name, Type, i64data);
-
-        AddConst(Name, newconst);
-    }
-    else{
+    Type resultType;
+    if( !StaticCalculation(false, Expression, 0, &i64data, resultType) ){
         //変数の場合
         //何もしない（実行領域コンパイル時にdim宣言として扱う）
-    }
+        return;
+    }
+
+    //リテラル値の場合
+    //登録を行う
+
+    CConst *newconst = new CConst(Name, resultType.GetBasicType(), i64data);
+
+    AddConst(Name, newconst);
 }
 void CDBConst::AddConst(char *Name, int value){

BasicCompiler_Common/Debug.cpp

@@ -224 +224 @@
     SendDlgItemMessage(hMainDlg,IDC_DEBUGLIST,EM_REPLACESEL,0,(LPARAM)buffer);
 }
-SubInfo *GetSubFromObp(ULONG_PTR pos){
-    extern SubInfo **ppSubHash;
-    SubInfo *psi;
+UserProc *GetSubFromObp(ULONG_PTR pos){
+    extern UserProc **ppSubHash;
+    UserProc *pUserProc;
     int i2;
 
     for(i2=0;i2<MAX_HASH;i2++){
-        psi=ppSubHash[i2];
-        while(psi){
-            if(rva_to_real(psi->CompileAddress) <= pos  &&
-                pos < rva_to_real(psi->EndOpAddr))
-                return psi;
-
-            psi=psi->pNextData;
+        pUserProc=ppSubHash[i2];
+        while(pUserProc){
+            if(rva_to_real(pUserProc->beginOpAddress) <= pos  &&
+                pos < rva_to_real(pUserProc->endOpAddress))
+                return pUserProc;
+
+            pUserProc=pUserProc->pNextData;
         }
     }
@@ -447 +447 @@
     pobj_dti=new CDebugThreadInfo();
 
-    SubInfo *psi;
+    UserProc *pUserProc;
 
     extern DWORD dwStepRun;
@@ -681 +681 @@
                         if(!bRet) MessageBox(hMainDlg,"プロセスメモリーの読み込みに失敗","error",MB_OK);
 
-                        extern SubInfo *pSub_DebugSys_EndProc;
+                        extern UserProc *pSub_DebugSys_EndProc;
                         if((BYTE)temporary[0]==0xE8&&
-                            *((long *)(temporary+1))+5==(long)rva_to_real(pSub_DebugSys_EndProc->CompileAddress)-(long)EIP_RIP(Context)){
+                            *((long *)(temporary+1))+5==(long)rva_to_real(pSub_DebugSys_EndProc->beginOpAddress)-(long)EIP_RIP(Context)){
                             //プロシージャの終端位置の場合はステップインを行う
                             goto StepIn;
@@ -700 +700 @@
                         else{
                             //プロシージャを識別
-                            psi=GetSubFromObp(pobj_dti->lplpObp[pobj_dti->iProcLevel]);
+                            pUserProc=GetSubFromObp(pobj_dti->lplpObp[pobj_dti->iProcLevel]);
 
                             //シングルステップON
                             WriteProcessMemory(hDebugProcess,
-                                (void *)rva_to_real(psi->CompileAddress),
-                                pobj_DBDebugSection->pobj_now->SingleStepCodeBuffer+psi->CompileAddress,
-                                psi->EndOpAddr-psi->CompileAddress,
+                                (void *)rva_to_real(pUserProc->beginOpAddress),
+                                pobj_DBDebugSection->pobj_now->SingleStepCodeBuffer+pUserProc->beginOpAddress,
+                                pUserProc->endOpAddress-pUserProc->beginOpAddress,
                                 &lpAccBytes);
                         }

BasicCompiler_Common/DebugMiddleFile.cpp

@@ -10 +10 @@
 
 
-void SetLpIndex_DebugFile(char *buffer,int *p,int type,LONG_PTR lpIndex){
-    if(NATURAL_TYPE(type)==DEF_OBJECT || NATURAL_TYPE(type)==DEF_STRUCT){
-        lstrcpy(buffer+(*p),((CClass *)lpIndex)->name);
+void SetLpIndex_DebugFile(char *buffer,int *p,const Type &type){
+    if(NATURAL_TYPE(type.GetBasicType())==DEF_OBJECT || NATURAL_TYPE(type.GetBasicType())==DEF_STRUCT){
+        lstrcpy(buffer+(*p),type.GetClass().name);
         (*p)+=lstrlen(buffer+(*p))+1;
     }
     else{
-        *(LONG_PTR *)(buffer+(*p))=lpIndex;
+        *(LONG_PTR *)(buffer+(*p))=type.GetIndex();
         (*p)+=sizeof(LONG_PTR);
     }
@@ -22 +22 @@
 
 
-void GetLpIndex_DebugFile(char *buffer,int *p,int type,LONG_PTR *plpIndex){
-    if(NATURAL_TYPE(type)==DEF_OBJECT || NATURAL_TYPE(type)==DEF_STRUCT){
+void GetLpIndex_DebugFile(char *buffer,int *p,Type &type){
+    if(NATURAL_TYPE(type.GetBasicType())==DEF_OBJECT || NATURAL_TYPE(type.GetBasicType())==DEF_STRUCT){
         char szClassName[VN_SIZE];
         lstrcpy(szClassName,buffer+(*p));
         (*p)+=lstrlen(buffer+(*p))+1;
 
-        *plpIndex=(LONG_PTR)pobj_DBClass->check(szClassName);
+        type.SetIndex( (LONG_PTR)pobj_DBClass->check(szClassName) );
     }
     else{
-        *plpIndex=*(LONG_PTR *)(buffer+(*p));
+        type.SetIndex( *(LONG_PTR *)(buffer+(*p)) );
         (*p)+=sizeof(LONG_PTR);
     }
@@ -49 +49 @@
 }
 void CDebugSection::make(void){
-    extern VARIABLE *GlobalVar;
-    extern int MaxGlobalVarNum;
     extern INCLUDEFILEINFO IncludeFileInfo;
     int i2,i3,i4,i5,BufferSize;
@@ -160 +158 @@
 
     //グローバル変数情報
-    *(long *)(buffer+i2)=MaxGlobalVarNum;
-    i2+=sizeof(long);
-    for(i3=0;i3<MaxGlobalVarNum;i3++){
-        VARIABLE *pVar=&GlobalVar[i3];
-
+    *(long *)(buffer+i2)=(int)::globalVars.size();
+    i2+=sizeof(long);
+    foreach( Variable *pVar, ::globalVars ){
         //変数名
-        lstrcpy(buffer+i2,pVar->name);
+        lstrcpy(buffer+i2,pVar->GetName().c_str());
         i2+=lstrlen(buffer+i2)+1;
 
         //型
-        *(long *)(buffer+i2)=pVar->type;
+        *(long *)(buffer+i2)=pVar->GetBasicType();
         i2+=sizeof(long);
 
         //型の拡張情報
-        SetLpIndex_DebugFile(buffer,&i2,pVar->type,pVar->u.index);
-
-        buffer[i2++]=(char)pVar->fRef;
-
-        buffer[i2++]=(char)pVar->bArray;
-
-        if(pVar->bArray){
-            for(i4=0;;i4++){
-                *(long *)(buffer+i2)=pVar->SubScripts[i4];
+        SetLpIndex_DebugFile(buffer,&i2,*pVar);
+
+        buffer[i2++] = pVar->IsRef() ? 1 : 0;
+
+        buffer[i2++] = pVar->IsArray() ? 1 : 0;
+
+        if(pVar->IsArray()){
+            for(i5=0;;i5++){
+                *(long *)(buffer+i2)=pVar->GetSubScriptsPtr()[i5];
                 i2+=sizeof(long);
-                if(pVar->SubScripts[i4]==-1) break;
+                if(pVar->GetSubScriptsPtr()[i5]==-1) break;
             }
         }
@@ -213 +209 @@
 
     //プロシージャ情報
-    extern SubInfo **ppSubHash;
+    extern UserProc **ppSubHash;
     extern int SubNum;
-    SubInfo *psi;
+    UserProc *pUserProc;
     *(long *)(buffer+i2)=SubNum;
     i2+=sizeof(long);
     for(i3=0;i3<MAX_HASH;i3++){
-        psi=ppSubHash[i3];
-        while(psi){
-            if(psi->pobj_ParentClass){
-                lstrcpy(buffer+i2,psi->pobj_ParentClass->name);
+        pUserProc=ppSubHash[i3];
+        while(pUserProc){
+            if(pUserProc->GetParentClassPtr()){
+                lstrcpy(buffer+i2,pUserProc->GetParentClassPtr()->name);
                 i2+=lstrlen(buffer+i2)+1;
             }
@@ -231 +227 @@
 
             //ID
-            *(long *)(buffer+i2)=psi->id;
+            *(long *)(buffer+i2)=pUserProc->id;
             i2+=sizeof(long);
 
             //関数名
-            lstrcpy(buffer+i2,psi->name);
+            lstrcpy(buffer+i2,pUserProc->GetName().c_str());
             i2+=lstrlen(buffer+i2)+1;
 
-            *(long *)(buffer+i2)=psi->CompileAddress;
-            i2+=sizeof(long);
-            *(long *)(buffer+i2)=psi->EndOpAddr;
-            i2+=sizeof(long);
-
-            *(long *)(buffer+i2)=psi->bVirtual;
+            *(long *)(buffer+i2)=pUserProc->beginOpAddress;
+            i2+=sizeof(long);
+            *(long *)(buffer+i2)=pUserProc->endOpAddress;
             i2+=sizeof(long);
 
             //ローカル変数情報
-            *(long *)(buffer+i2)=psi->VarNum;
+            *(long *)(buffer+i2)=(int)pUserProc->localVars.size();
             i2+=sizeof(long);
 
@@ -256 +249 @@
             }
 
-            for(i4=0;i4<psi->VarNum;i4++){
-                VARIABLE *pVar=&psi->pVar[i4];
-                lstrcpy(buffer+i2,pVar->name);
+            foreach( Variable *pVar, pUserProc->localVars ){
+                lstrcpy(buffer+i2,pVar->GetName().c_str());
                 i2+=lstrlen(buffer+i2)+1;
 
                 //型
-                *(long *)(buffer+i2)=pVar->type;
+                *(long *)(buffer+i2)=pVar->GetBasicType();
                 i2+=sizeof(long);
 
                 //型の拡張情報
-                SetLpIndex_DebugFile(buffer,&i2,pVar->type,pVar->u.index);
+                SetLpIndex_DebugFile(buffer,&i2,*pVar);
 
                 //参照型パラメータかどうか
-                buffer[i2++]=(char)pVar->fRef;
+                buffer[i2++] = pVar->IsRef() ? 1 : 0;
 
                 //配列かどうか
-                buffer[i2++]=(char)pVar->bArray;
+                buffer[i2++] = pVar->IsArray() ? 1 : 0;
 
                 //配列要素
-                if(pVar->bArray){
+                if(pVar->IsArray()){
                     for(i5=0;;i5++){
-                        *(long *)(buffer+i2)=pVar->SubScripts[i5];
+                        *(long *)(buffer+i2)=pVar->GetSubScriptsPtr()[i5];
                         i2+=sizeof(long);
-                        if(pVar->SubScripts[i5]==-1) break;
+                        if(pVar->GetSubScriptsPtr()[i5]==-1) break;
                     }
                 }
-                else pVar->SubScripts[0]=-1;
 
                 //レキシカルスコープ情報
@@ -306 +297 @@
             }
 
-            psi=psi->pNextData;
+            pUserProc=pUserProc->pNextData;
         }
     }
@@ -347 +338 @@
 
             //型
-            *(long *)(buffer+i2)=pobj_c->ppobj_Member[i4]->TypeInfo.type;
+            *(long *)(buffer+i2)=pobj_c->ppobj_Member[i4]->GetBasicType();
             i2+=sizeof(long);
 
             //型の拡張情報
-            SetLpIndex_DebugFile(buffer,&i2,pobj_c->ppobj_Member[i4]->TypeInfo.type,pobj_c->ppobj_Member[i4]->TypeInfo.u.lpIndex);
+            SetLpIndex_DebugFile(buffer,&i2,*pobj_c->ppobj_Member[i4]);
 
             *(long *)(buffer+i2)=pobj_c->ppobj_Member[i4]->dwAccess;
@@ -377 +368 @@
                 i2+=lstrlen(buffer+i2)+1;
             }
-            lstrcpy(buffer+i2,method->psi->name);
+            lstrcpy(buffer+i2,method->pUserProc->GetName().c_str());
             i2+=lstrlen(buffer+i2)+1;
         }
@@ -392 +383 @@
 
             //型
-            *(long *)(buffer+i2)=member->TypeInfo.type;
+            *(long *)(buffer+i2)=member->GetBasicType();
             i2+=sizeof(long);
 
             //型の拡張情報
-            SetLpIndex_DebugFile(buffer,&i2,member->TypeInfo.type,member->TypeInfo.u.lpIndex);
+            SetLpIndex_DebugFile(buffer,&i2,*member);
 
             *(long *)(buffer+i2)=member->dwAccess;
@@ -540 +531 @@
 
     //グローバル変数情報
-    MaxGlobalVarNum=*(long *)(buffer+i2);
-    i2+=sizeof(long);
-    GlobalVar=(VARIABLE *)HeapAlloc(hHeap,0,MaxGlobalVarNum*sizeof(VARIABLE)+1);
-    for(i3=0;i3<MaxGlobalVarNum;i3++){
-        VARIABLE *pVar=&GlobalVar[i3];
+    globalVars.clear();
+    int maxGlobalVars=*(long *)(buffer+i2);
+    i2+=sizeof(long);
+    for(i3=0;i3<maxGlobalVars;i3++){
 
         //変数名
-        lstrcpy(pVar->name,buffer+i2);
-        i2+=lstrlen(buffer+i2)+1;
-
-        pVar->type=*(long *)(buffer+i2);
-        i2+=sizeof(long);
-
-        GetLpIndex_DebugFile(buffer,&i2,pVar->type,&pVar->u.index);
-
-        pVar->fRef=(long)buffer[i2++];
-
-        pVar->bArray=(long)buffer[i2++];
-        if(pVar->bArray){
+        char *name = buffer+i2;
+        i2+=lstrlen(buffer+i2)+1;
+
+        int basicType = *(long *)(buffer+i2);
+        i2+=sizeof(long);
+
+        Type type( basicType );
+        GetLpIndex_DebugFile(buffer,&i2,type);
+
+        bool isRef = (buffer[i2++]) ? true:false;
+
+        bool isArray = (buffer[i2++]) ? true:false;
+
+        Variable *pVar = new Variable( name, type, false, isRef );
+
+        if(isArray){
+            int SubScripts[MAX_ARRAYDIM];
             for(i4=0;;i4++){
-                pVar->SubScripts[i4]=*(long *)(buffer+i2);
+                SubScripts[i4]=*(long *)(buffer+i2);
                 i2+=sizeof(long);
 
-                if(pVar->SubScripts[i4]==-1) break;
-            }
+                if(SubScripts[i4]==-1) break;
+            }
+
+            pVar->SetArray( SubScripts );
         }
 
@@ -578 +575 @@
         pVar->offset=*(long *)(buffer+i2);
         i2+=sizeof(long);
+
+        //変数を追加
+        globalVars.push_back( pVar );
     }
 
@@ -585 +585 @@
 
     //プロシージャ情報
-    SubInfo *psi;
+    UserProc *pUserProc;
     SubNum=*(long *)(buffer+i2);
     i2+=sizeof(long);
-    ppSubHash=(SubInfo **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(SubInfo *));
-    for(i3=0;i3<SubNum;i3++){
-        psi = new SubInfo();
-        psi->pNextData=0;
-
+    ppSubHash=(UserProc **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(UserProc *));
+    for(int i6=0;i6<SubNum;i6++){
         char szParentClassName[VN_SIZE];
         lstrcpy(szParentClassName,buffer+i2);
         i2+=lstrlen(buffer+i2)+1;
 
+        CClass *pClass = NULL;
         if(szParentClassName[0])
-            psi->pobj_ParentClass=pobj_DBClass->check(szParentClassName);
-        else psi->pobj_ParentClass=0;
+            pClass=pobj_DBClass->check(szParentClassName);
 
         //ID
-        psi->id=*(long *)(buffer+i2);
+        int id=*(long *)(buffer+i2);
         i2+=sizeof(long);
 
         //名前
-        psi->name=(char *)HeapAlloc(hHeap,0,lstrlen(buffer+i2)+1);
-        lstrcpy(psi->name,buffer+i2);
-        i2+=lstrlen(buffer+i2)+1;
-
-        psi->CompileAddress=*(long *)(buffer+i2);
-        i2+=sizeof(long);
-        psi->EndOpAddr=*(long *)(buffer+i2);
-        i2+=sizeof(long);
-
-        psi->bVirtual=*(long *)(buffer+i2);
-        i2+=sizeof(long);
-
-        psi->bCompile=1;
+        char *name = buffer+i2;
+        i2+=lstrlen(buffer+i2)+1;
+
+        // オブジェクトを生成
+        pUserProc = new UserProc( name, UserProc::Function, false, false, false );
+        pUserProc->pNextData=0;
+        pUserProc->id=id;
+        pUserProc->SetParentClass( pClass );
+
+        pUserProc->beginOpAddress=*(long *)(buffer+i2);
+        i2+=sizeof(long);
+        pUserProc->endOpAddress=*(long *)(buffer+i2);
+        i2+=sizeof(long);
+
+        pUserProc->CompleteCompile();
 
         //ローカル変数情報
-        psi->VarNum=*(long *)(buffer+i2);
-        i2+=sizeof(long);
-        psi->pVar=(VARIABLE *)HeapAlloc(hHeap,0,psi->VarNum*sizeof(VARIABLE)+1);
-        for(i4=0;i4<psi->VarNum;i4++){
-            VARIABLE *pVar=&psi->pVar[i4];
-
-            //ローカル変数名
-            lstrcpy(pVar->name,buffer+i2);
+        pUserProc->localVars.clear();
+        int maxLocalVar=*(long *)(buffer+i2);
+        i2+=sizeof(long);
+        for(i3=0;i3<maxLocalVar;i3++){
+            //変数名
+            char *name = buffer+i2;
             i2+=lstrlen(buffer+i2)+1;
 
-            //型
-            pVar->type=*(long *)(buffer+i2);
-            i2+=sizeof(long);
-
-            //型の拡張情報
-            GetLpIndex_DebugFile(buffer,&i2,pVar->type,&pVar->u.index);
-
-            //参照型パラメータかどうか
-            pVar->fRef=(long)buffer[i2++];
-
-            //配列かどうか
-            pVar->bArray=(long)buffer[i2++];
-            if(pVar->bArray){
-                for(i5=0;;i5++){
-                    //配列要素
-                    pVar->SubScripts[i5]=*(long *)(buffer+i2);
+            int basicType = *(long *)(buffer+i2);
+            i2+=sizeof(long);
+
+            Type type( basicType );
+            GetLpIndex_DebugFile(buffer,&i2,type);
+
+            bool isRef = (buffer[i2++]) ? true:false;
+
+            bool isArray = (buffer[i2++]) ? true:false;
+
+            Variable *pVar = new Variable( name, type, false, isRef );
+
+            if(isArray){
+                int SubScripts[MAX_ARRAYDIM];
+                for(i4=0;;i4++){
+                    SubScripts[i4]=*(long *)(buffer+i2);
                     i2+=sizeof(long);
 
-                    if(pVar->SubScripts[i5]==-1) break;
+                    if(SubScripts[i4]==-1) break;
                 }
+
+                pVar->SetArray( SubScripts );
             }
 
@@ -661 +660 @@
             i2+=sizeof(long);
 
-            //メモリ上の位置
+            //メモリ位置
             pVar->offset=*(long *)(buffer+i2);
             i2+=sizeof(long);
+
+            //変数を追加
+            pUserProc->localVars.push_back( pVar );
         }
 
 
         /////////////////////////////////
-        // 格納位置を計算してpsiをセット
+        // 格納位置を計算してpUserProcをセット
         /////////////////////////////////
 
-        i4=hash_default(psi->name);
-
-        SubInfo *psi2;
+        i4=hash_default(pUserProc->GetName().c_str());
+
+        UserProc *psi2;
         if(ppSubHash[i4]){
             psi2=ppSubHash[i4];
             while(1){
                 if(psi2->pNextData==0){
-                    psi2->pNextData=psi;
+                    psi2->pNextData=pUserProc;
                     break;
                 }
@@ -685 +687 @@
         }
         else{
-            ppSubHash[i4]=psi;
+            ppSubHash[i4]=pUserProc;
         }
     }
@@ -723 +725 @@
 
             //型
-            pobj_c->ppobj_Member[i4]->TypeInfo.type=*(long *)(buffer+i2);
+            Type type( *(long *)(buffer+i2) );
             i2+=sizeof(long);
 
             //型の拡張情報
-            GetLpIndex_DebugFile(buffer,&i2,pobj_c->ppobj_Member[i4]->TypeInfo.type,&pobj_c->ppobj_Member[i4]->TypeInfo.u.lpIndex);
+            GetLpIndex_DebugFile(buffer,&i2,type);
+
+            pobj_c->ppobj_Member[i4]->SetType( type.GetBasicType(), type.GetIndex() );
 
             pobj_c->ppobj_Member[i4]->dwAccess=*(long *)(buffer+i2);
@@ -757 +761 @@
             if(pobj_temp_c==0) pobj_temp_c=pobj_c;
             i5=hash_default(temp2);
-            psi=ppSubHash[i5];
+            pUserProc=ppSubHash[i5];
             while(1){
-                if(lstrcmp(psi->name,temp2)==0&&psi->pobj_ParentClass==pobj_temp_c) break;
-                psi=psi->pNextData;
-            }
-            method->psi=psi;
+                if( pUserProc->GetName() == temp2 &&pUserProc->GetParentClassPtr()==pobj_temp_c) break;
+                pUserProc=pUserProc->pNextData;
+            }
+            method->pUserProc=pUserProc;
 
             pobj_c->methods.push_back( method );
@@ -781 +785 @@
 
             //型
-            member->TypeInfo.type=*(long *)(buffer+i2);
+            Type type( *(long *)(buffer+i2) );
             i2+=sizeof(long);
 
             //型の拡張情報
-            GetLpIndex_DebugFile(buffer,&i2,member->TypeInfo.type,&member->TypeInfo.u.lpIndex);
+            GetLpIndex_DebugFile(buffer,&i2,type);
+
+            member->SetType( type.GetBasicType(), type.GetIndex() );
 
             member->dwAccess=*(long *)(buffer+i2);
@@ -800 +806 @@
 
 
-    extern SubInfo **ppSubHash;
+    extern UserProc **ppSubHash;
     ppSubHash=this->ppSubHash;
     pSub_DebugSys_EndProc=GetSubHash("_DebugSys_EndProc");
@@ -956 +962 @@
     ppConstHash=this->ppConstHash;
 
-    //グローバル変数に関する情報
-    extern VARIABLE *GlobalVar;
-    extern int MaxGlobalVarNum;
-    GlobalVar=this->GlobalVar;
-    MaxGlobalVarNum=this->MaxGlobalVarNum;
-
     //グローバル実行領域のサイズ
     extern int GlobalOpBufferSize;
@@ -969 +969 @@
     extern char **ppMacroNames;
     ppMacroNames=0;
-    extern SubInfo **ppSubHash;
+    extern UserProc **ppSubHash;
     extern int SubNum;
     ppSubHash=this->ppSubHash;
     SubNum=this->SubNum;
 
-    extern SubInfo *pSub_DebugSys_EndProc;
+    extern UserProc *pSub_DebugSys_EndProc;
     pSub_DebugSys_EndProc=this->pSub_DebugSys_EndProc;
 
@@ -989 +989 @@
         HeapDefaultFree(IncludeFileInfo.ppFileNames[i2]);
     HeapDefaultFree(IncludeFileInfo.ppFileNames);
-
-    //グローバル変数に関する情報を解放
-    HeapDefaultFree(GlobalVar);
-
-    //ローカル変数に関する情報を解放
-    SubInfo *psi;
-    for(i2=0;i2<MAX_HASH;i2++){
-        psi=ppSubHash[i2];
-        while(psi){
-            if(psi->bCompile)
-                HeapDefaultFree(psi->pVar);
-
-            psi=psi->pNextData;
-        }
-    }
 
     //クラスに関するメモリを解放

BasicCompiler_Common/DebugSection.h

@@ -41 +41 @@
     CONSTINFO **ppConstHash;
 
-    //グローバル変数に関する情報
-    VARIABLE *GlobalVar;
-    int MaxGlobalVarNum;
-
     //グローバル実行領域のサイズ
     int GlobalOpBufferSize;
 
     //プロシージャ
-    SubInfo **ppSubHash;
+    UserProc **ppSubHash;
     int SubNum;
 
-    SubInfo *pSub_DebugSys_EndProc;
+    UserProc *pSub_DebugSys_EndProc;
 
     //ネイティブコードバッファ

BasicCompiler_Common/Enum.cpp

@@ -15 +15 @@
 
 
-CEnumParent::CEnumParent(char *buffer,int NowLine){
+CEnumParent::CEnumParent(char *buffer,int nowLine){
     ppobj_EnumMember=(CEnumMember **)HeapAlloc(hHeap,0,1);
     iEnumMemberNum=0;
@@ -42 +42 @@
 
     if(buffer[i]=='\0'){
-        SetError(22,"Enum",NowLine);
+        SetError(22,"Enum",nowLine);
         return;
     }
@@ -65 +65 @@
         if(temporary[0]=='\0'){
             if(buffer[i]=='\0'){
-                SetError(22,"Enum",NowLine);
+                SetError(22,"Enum",nowLine);
                 break;
             }

BasicCompiler_Common/Enum.h

@@ -17 +17 @@
 public:
 
-    CEnumParent(char *buffer,int NowLine);
+    CEnumParent(char *buffer,int nowLine);
     ~CEnumParent();
 

BasicCompiler_Common/Intermediate_Step2.cpp

@@ -146 +146 @@
         //数値定数
         _int64 i64data;
-        pci->type=StaticCalculation(true, temporary,0,&i64data,&pci->lpIndex);
+        Type resultType;
+        StaticCalculation(true, temporary,0,&i64data,resultType);
+        pci->type=resultType.GetBasicType();
         if(IsRealNumberType(pci->type)){
             //実数型
@@ -231 +233 @@
 
             _int64 i64data;
-            LONG_PTR lpIndex;
-            StaticCalculation(true, temp2,DEF_LONG,&i64data,&lpIndex);
+            StaticCalculation(true, temp2,DEF_LONG,&i64data,Type());
             NextValue=(int)i64data;
         }
@@ -303 +304 @@
 
 char ConstructorDestructorSchedule[MAX_PATH];
-void MakeConstructorAndDestructor(char *buffer,int NowLine,char *ClassName){
+void MakeConstructorAndDestructor(char *buffer,int nowLine,char *ClassName){
     int i,i2;
     char temporary[MAX_PATH],*pTemp;
@@ -312 +313 @@
     bDestructor=0;
 
-    for(i=NowLine;;i++){
+    for(i=nowLine;;i++){
         if(buffer[i]=='\0') break;
         if(buffer[i]==1&&buffer[i+1]==ESC_ENDCLASS){
@@ -360 +361 @@
     }
 }
-void ChangeCommand(char *buffer,int NowLine,char *Command){
+void ChangeCommand(char *buffer,int nowLine,char *Command){
     int i,i2,IsStr;
     unsigned _int16 ComNum;
@@ -391 +392 @@
 
                 //コンストラクタ、デストラクタを暗黙的に生成
-                MakeConstructorAndDestructor(buffer,NowLine,Command+2);
+                MakeConstructorAndDestructor(buffer,nowLine,Command+2);
                 break;
             case ESC_INTERFACE:
@@ -457 +458 @@
     if( nCountOfNonGlobalScope == 0 ){
         //グローバル
-        if(lstrcmpi(com,"Open")==0) ComOpen(Command+i,pam,NowLine);
+        if(lstrcmpi(com,"Open")==0) ComOpen(Command+i,pam,nowLine);
         else if(lstrcmpi(com,"Close")==0) ComClose(Command+i,pam);
         else if(lstrcmpi(com,"Field")==0||
             lstrcmpi(com,"Get")==0||
             lstrcmpi(com,"Put")==0) ComField(Command+i,pam);
-        else if(lstrcmpi(com,"Line")==0) ComLine(Command+i,pam,NowLine);
-        else if(lstrcmpi(com,"Circle")==0) ComCircle(Command+i,pam,NowLine);
-        else if(lstrcmpi(com,"PSet")==0) ComPSet(Command+i,pam,NowLine);
-        else if(lstrcmpi(com,"Paint")==0) ComPaint(Command+i,pam,NowLine);
+        else if(lstrcmpi(com,"Line")==0) ComLine(Command+i,pam,nowLine);
+        else if(lstrcmpi(com,"Circle")==0) ComCircle(Command+i,pam,nowLine);
+        else if(lstrcmpi(com,"PSet")==0) ComPSet(Command+i,pam,nowLine);
+        else if(lstrcmpi(com,"Paint")==0) ComPaint(Command+i,pam,nowLine);
 
         else if(

BasicCompiler_Common/LexicalScoping.cpp

@@ -85 +85 @@
     CallDestructorsOfScopeEnd();
 
-    extern BOOL bCompilingGlobal;
-    VARIABLE *pVar;
-    int num;
-    if(bCompilingGlobal){
-        //グローバル領域をコンパイルしているとき
-        extern VARIABLE *GlobalVar;
-        extern int MaxGlobalVarNum;
-        pVar=GlobalVar;
-        num=MaxGlobalVarNum;
-    }
-    else{
-        //ローカル領域をコンパイルしているとき
-        extern VARIABLE *LocalVar;
-        extern int MaxLocalVarNum;
-        pVar=LocalVar;
-        num=MaxLocalVarNum;
-    }
+    Variables &vars = UserProc::IsGlobalAreaCompiling()?
+        globalVars :
+        UserProc::CompilingUserProc().localVars;
 
     //使用済みローカル変数の生存チェックを外す
-    for(int i=0;i<num;i++){
-        if(pVar[i].bLiving&&pVar[i].ScopeLevel==level){
-            pVar[i].bLiving=0;
+    foreach( Variable *pVar, vars ){
+        if(pVar->bLiving&&pVar->ScopeLevel==level){
+            pVar->bLiving=0;
             extern int obp;
-            pVar[i].ScopeEndAddress=obp;
+            pVar->ScopeEndAddress=obp;
         }
     }
@@ -163 +149 @@
 // スコープ終了時のデストラクタ呼び出し
 void CLexicalScopes::CallDestructorsOfScopeEnd(){
-    extern BOOL bCompilingGlobal;
-    VARIABLE *pVar;
-    int num;
-    if(bCompilingGlobal){
-        //グローバルオブジェクトの解放処理
-        extern VARIABLE *GlobalVar;
-        extern int MaxGlobalVarNum;
-        pVar=GlobalVar;
-        num=MaxGlobalVarNum;
-    }
-    else{
-        //ローカルオブジェクトの解放処理
-        extern VARIABLE *LocalVar;
-        extern int MaxLocalVarNum;
-        pVar=LocalVar;
-        num=MaxLocalVarNum;
-    }
+
+    Variables &vars = UserProc::IsGlobalAreaCompiling()?
+        globalVars :
+        UserProc::CompilingUserProc().localVars;
 
 
     int i3;
     int indexSystemGC=-1;
-    for( i3 = num - 1; i3 >= 0; i3-- ){     //確保したのと逆順序で解放するため、バックサーチにする
-
-        if( bCompilingGlobal && GetNowLevel() == 0 ){
-            if(lstrcmp(pVar[i3].name,"_System_GC")==0){
+    for( i3 = (int)vars.size() - 1; i3 >= 0; i3-- ){        //確保したのと逆順序で解放するため、バックサーチにする
+
+        Variable *pVar = vars[i3];
+
+        if( UserProc::IsGlobalAreaCompiling() && GetNowLevel() == 0 ){
+            if( pVar->GetName() == "_System_GC" ){
                 indexSystemGC=i3;
                 continue;
@@ -194 +169 @@
 
         //同一レベルのレキシカルスコープのみを検知
-        if(!pVar[i3].bLiving) continue;
-        if( pVar[i3].ScopeLevel != GetNowLevel() ) continue;
-
-        if(pVar[i3].type==DEF_STRUCT&&pVar[i3].fRef&OBJECT_PARAMETER){
+        if(!pVar->bLiving) continue;
+        if( pVar->ScopeLevel != GetNowLevel() ) continue;
+
+        if( pVar->IsStruct() && pVar->IsParameter() ){
             //構造体パラメータを持つとき
 
@@ -207 +182 @@
             //mov rcx,qword ptr[rsp+offset]
             op_mov_RM(sizeof(_int64),REG_RCX,REG_RSP,
-                -pVar[i3].offset,
+                -pVar->offset,
                 MOD_BASE_DISP32);
             obp-=sizeof(long);
@@ -216 +191 @@
 
             //mov ecx,dword ptr[ebp+offset]
-            op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar[i3].offset,MOD_BASE_DISP32);
+            op_mov_RM(sizeof(long),REG_ECX,REG_EBP,-pVar->offset,MOD_BASE_DISP32);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -226 +201 @@
 
             //call free
-            extern SubInfo *pSub_free;
+            extern UserProc *pSub_free;
             op_call(pSub_free);
 
 
-            if(bCompilingGlobal){
+            if( UserProc::IsGlobalAreaCompiling() ){
                 //ここには来ないハズ
                 SetError(300,NULL,cp);
             }
         }
-
-        /*
-        TODO: 消す
-        else if(pVar[i3].type==DEF_OBJECT&&pVar[i3].fRef==0){
-            //デストラクタの呼び出し
-            CMethod *method = pVar[i3].u.pobj_c->GetDestructorMethod();
-            if( method ){
-                int ss[MAX_ARRAYDIM];
-                memset(ss,0,MAX_ARRAYDIM*sizeof(int));
-                if(pVar[i3].SubScripts[0]!=-1){
-                    while(1){
-                        for(i4=0;;i4++){
-                            if(pVar[i3].SubScripts[i4]==-1) break;
-
-                            if(ss[i4]>pVar[i3].SubScripts[i4]){
-                                ss[i4]=0;
-                                ss[i4+1]++;
-                            }
-                            else break;
-                        }
-                        if(pVar[i3].SubScripts[i4]==-1) break;
-                        char temporary[VN_SIZE];
-                        sprintf(temporary,"%s[%d",pVar[i3].name,ss[0]);
-                        for(i4=1;;i4++){
-                            if(pVar[i3].SubScripts[i4]==-1) break;
-
-                            sprintf(temporary+lstrlen(temporary),",%d",ss[i4]);
-                        }
-                        lstrcat(temporary,"]");
-                        Opcode_CallProc("",method->psi,0,temporary,DEF_OBJECT);
-
-                        ss[0]++;
-
-
-                        //ネイティブコードバッファの再確保
-                        extern int obp_AllocSize;
-                        if(obp_AllocSize<obp+8192){
-                            obp_AllocSize+=8192;
-                            OpBuffer=(char *)HeapReAlloc(hHeap,0,OpBuffer,obp_AllocSize); //matea
-                        }
-                    }
-                }
-                else{
-                    Opcode_CallProc("",method->psi,0,pVar[i3].name,DEF_OBJECT);
-                }
-            }
-        }
-        */
     }
 
     if(indexSystemGC!=-1){
         //_System_GCオブジェクトのデストラクタの呼び出し処理
-        CMethod *method = pVar[indexSystemGC].u.pobj_c->GetDestructorMethod();
+        CMethod *method = vars[indexSystemGC]->GetClass().GetDestructorMethod();
         if( method ){
-            Opcode_CallProc("",method->psi,0,pVar[indexSystemGC].name,DEF_OBJECT);
+            Opcode_CallProc("",method->pUserProc,0,vars[indexSystemGC]->GetName().c_str(),DEF_OBJECT);
         }
     }

BasicCompiler_Common/LexicalScoping.h

@@ -70 +70 @@
     //Returnステートメント用のデストラクタ呼び出し
     void CallDestructorsOfReturn( int BaseLevel = 0 );
-
-private:
-    VARIABLE *add(void);
 };
 

BasicCompiler_Common/MakeExe.cpp

@@ -165 +165 @@
     for(i3=0;i3<SynonymErrorNum;i3++) HeapDefaultFree(SynonymErrorWords[i3]);
     HeapDefaultFree(SynonymErrorWords);
+    SynonymErrorWords=0;
 
     if(bError||bStopCompile){
@@ -181 +182 @@
 
     //グローバル変数に関する情報
-    extern VARIABLE *GlobalVar;
     extern int MaxGlobalVarNum;
     extern int AllGlobalVarSize;
     extern int AllInitGlobalVarSize;
-    GlobalVar=(VARIABLE *)HeapAlloc(hHeap,0,1);
+    globalVars.clear();
     MaxGlobalVarNum=0;
     AllGlobalVarSize=0;
@@ -214 +214 @@
     HeapDefaultFree(pLineInfo);
 
-    //グローバル変数に関する情報を解放
-    int i;
-    for(i=0;i<MaxGlobalVarNum;i++){
-        if(GlobalVar[i].ConstractParameter)
-            HeapDefaultFree(GlobalVar[i].ConstractParameter);
-    }
-    HeapDefaultFree(GlobalVar);
-
-    //ローカル変数に関する情報を解放
-    extern SubInfo **ppSubHash;
-    SubInfo *psi;
-    for(i2=0;i2<MAX_HASH;i2++){
-        psi=ppSubHash[i2];
-        while(psi){
-            if(psi->bCompile) HeapDefaultFree(psi->pVar);
-            psi=psi->pNextData;
-        }
-    }
-
     //TypeDef情報を初期化
     delete pobj_DBTypeDef;
@@ -238 +219 @@
 
     //サブルーチン（ユーザー定義）情報のメモリ解放
-    extern SubInfo **ppSubHash;
+    extern UserProc **ppSubHash;
     extern char **ppMacroNames;
     extern int MacroNum;

BasicCompiler_Common/NumOpe_GetType.cpp

@@ -28 +28 @@
     type=CalcType;
 
-    if(!BaseType){
+    if(BaseType==0||BaseType==-1){
         //ベースタイプが未定のとき
         return type;
@@ -38 +38 @@
     }
 
-    if(BaseType==DEF_OBJECT){
+    if(BaseType==DEF_OBJECT||BaseType==DEF_STRUCT){
         //ベースタイプがオブジェクトのときは暗黙の変換は必要なし
         return type;
@@ -188 +188 @@
 }
 
-int GetReturnType_OperatorProc(int idCalc,TYPEINFO *pBaseTypeInfo,int *type,LONG_PTR *index_stack,int &sp){
+int GetReturnType_OperatorProc(int idCalc,const Type &baseType,int *type,LONG_PTR *index_stack,int &sp){
     //オーバーロードされたオペレータ関数の戻り値を取得
     CClass *pobj_c;
     pobj_c=(CClass *)index_stack[sp-2];
 
-    std::vector<SubInfo *> subs;
+    std::vector<UserProc *> subs;
     pobj_c->EnumMethod( idCalc, subs );
     if( subs.size() == 0 ){
@@ -212 +212 @@
 
     //_System_LocalThis
-    PARAMETER_INFO *ppi = (PARAMETER_INFO *)HeapAlloc(hHeap,0,sizeof(PARAMETER_INFO)*3);
-    int iParmNum=0;
+    Parameters params;
 
     if(bTwoTerm){
-        ppi[iParmNum].bArray=0;
-        ppi[iParmNum].bByVal=0;
-        ppi[iParmNum].name=0;
-        ppi[iParmNum].type=type[sp-1];
-        ppi[iParmNum].u.index=index_stack[sp-1];
-        ppi[iParmNum].SubScripts[0]=-1;
-        iParmNum++;
+        params.push_back( new Parameter( "", Type( type[sp-1], index_stack[sp-1] ) ) );
     }
 
@@ -230 +223 @@
     if(idCalc==CALC_EQUAL) lstrcpy(temporary,"==");
     else GetCalcName(idCalc,temporary);
-    SubInfo *psi;
-    psi=OverloadSolution(temporary,subs,ppi,iParmNum,pBaseTypeInfo);
-
-
-    if(!psi){
-        HeapDefaultFree(ppi);
+    UserProc *pUserProc = OverloadSolution( temporary, subs, params, baseType );
+
+    if(bTwoTerm){
+        delete params[0];
+    }
+
+    if(!pUserProc){
         return 0;
     }
     else{
         //オーバーロードされていないが、パラメータ個数が一致しないとき
-        if(iParmNum!=psi->params.size()){
-            HeapDefaultFree(ppi);
+        if(params.size()!=pUserProc->Params().size()){
             return 0;
         }
     }
 
-    HeapDefaultFree(ppi);
-
     sp--;
-    type[sp-1]=psi->ReturnType;
-    index_stack[sp-1]=psi->u.ReturnIndex;
+    type[sp-1]=pUserProc->ReturnType().GetBasicType();
+    index_stack[sp-1]=pUserProc->ReturnType().GetIndex();
 
     return 1;
 }
 
-int Operator_New_GetType(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo ){
+bool Operator_New_GetType(const char *Parameter,const Type &baseType, Type &resultType ){
     char TypeName[VN_SIZE],CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
     int i,i2;
@@ -279 +270 @@
             if(Parameter[i]!='\0'){
                 SetError(42,NULL,cp);
-                return 0;
+                return false;
             }
             break;
@@ -290 +281 @@
     }
 
-    int type;
-    type=GetTypeFixed(TypeName,plpIndex);
-
-    if( baseTypeInfo.type == DEF_OBJECT ){
-        return DEF_OBJECT;
-    }
-    return DEF_PTR_OBJECT;
+    if( !Type::StringToType( TypeName, resultType ) ){
+        return false;
+    }
+
+    if( baseType.IsObject() ){
+        resultType.SetBasicType( DEF_OBJECT );
+    }
+    else{
+        resultType.SetBasicType( DEF_PTR_OBJECT );
+    }
+    return true;
 }
 
-int NumOpe_GetType_Old( const char *Command,TYPEINFO *pBaseType,LONG_PTR *plpIndex){
+bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType ){
     extern int cp;
     int i,i2,i3,i4;
     char temporary[1024],temp2[1024],temp3[1024];
 
-    if(Command[0]=='\0'){
+    if(expression[0]=='\0'){
         SetError(1,NULL,cp);
-        return 0;
-    }
-
-    if(Command[0]==1&& Command[1]==ESC_NEW ){
+        return false;
+    }
+
+    if(expression[0]==1&& expression[1]==ESC_NEW ){
         //New演算子（オブジェクト生成）
-        return Operator_New_GetType(Command+2,plpIndex, *pBaseType );
+        return Operator_New_GetType(expression+2,baseType, resultType );
     }
 
@@ -323 +318 @@
     long stack[255];
     int pnum;
-    if(!GetNumOpeElements(Command,&pnum,values,calc,stack)){
+    if(!GetNumOpeElements(expression,&pnum,values,calc,stack)){
         for(i=0;i<pnum;i++){
             if(values[i]) HeapDefaultFree(values[i]);
         }
-        return 0;
+        return false;
     }
 
@@ -343 +338 @@
 
     int sp;
-    int type[255];
+    int type_stack[255];
     LONG_PTR index_stack[255];
     _int64 i64data;
@@ -351 +346 @@
 
         if(idCalc){
-            if(type[sp-2]==DEF_OBJECT){
+            if(type_stack[sp-2]==DEF_OBJECT){
                 //オーバーロードされたオペレータを呼び出す
-                if(!GetReturnType_OperatorProc(idCalc,pBaseType,type,index_stack,sp)){
+                if(!GetReturnType_OperatorProc(idCalc,baseType,type_stack,index_stack,sp)){
                     goto error;
                 }
@@ -360 +355 @@
             }
 
-            if(!CheckCalcType(idCalc,type,sp)) goto error;
+            if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
         }
 
@@ -374 +369 @@
 StrLiteral:
 
-                    if(pBaseType){
-                        if(pBaseType->type==DEF_OBJECT){
-                            if(IsStringObjectType(*pBaseType)){
-                                //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
-                                extern CClass *pobj_StringClass;
-                                type[sp]=DEF_OBJECT;
-                                index_stack[sp]=(LONG_PTR)pobj_StringClass;
-                                bLiteralCalculation=0;
-
-                                sp++;
-                                break;
-                            }
-                        }
+                    if( baseType.IsStringObject() ){
+                        //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
+                        extern CClass *pobj_StringClass;
+                        type_stack[sp]=DEF_OBJECT;
+                        index_stack[sp]=(LONG_PTR)pobj_StringClass;
+                        bLiteralCalculation=0;
+
+                        sp++;
+                        break;
                     }
 
-                    type[sp]=typeOfPtrChar;
+                    type_stack[sp]=typeOfPtrChar;
                     bLiteralCalculation=0;
                 }
@@ -413 +404 @@
 
                         int idProc;
-                        void *pInfo;
-                        idProc=GetProc(temporary,&pInfo);
+                        void *pProc;
+                        idProc=GetProc(temporary,(void **)&pProc);
 
                         if(idProc){
@@ -433 +424 @@
                             ////////////////
 
-                            i2=GetReturnTypeOfProc(idProc,pInfo,temporary,temp2,&index_stack[sp]);
-                            if(i2==-1){
+                            Type resultType;
+                            if( !CallProc(idProc,pProc,temporary,temp2, resultType, false ) ){
+                                goto error;
+                            }
+                            if( resultType.IsNull() ){
                                 //戻り値が存在しないとき
                                 goto error;
                             }
 
-                            type[sp]=i2;
+                            type_stack[sp] = resultType.GetBasicType();
+                            index_stack[sp] = resultType.GetIndex();
+
                             bLiteralCalculation=0;
 
@@ -454 +450 @@
 
                             //マクロ関数の場合
-                            i2=NumOpe_GetType_Old(temp3,NULL,&index_stack[sp]);
-
-                            if(!IS_LITERAL(index_stack[sp])){
+                            Type tempType;
+                            NumOpe_GetType(temp3,Type(),tempType);
+
+                            if(!IS_LITERAL(tempType.GetIndex())){
                                 //リテラル値ではなかったとき
                                 bLiteralCalculation=0;
                             }
 
-                            type[sp]=i2;
+                            type_stack[sp] = tempType.GetBasicType();
+                            index_stack[sp] = tempType.GetIndex(); 
 
                             sp++;
@@ -473 +471 @@
                     GetArrayElement(term,VarName,ArrayElements);
                     if(ArrayElements[0]){
-                        CClass *pobj_c;
-                        i2=GetVarType(VarName,(LONG_PTR *)&pobj_c,0);
-                        if(i2==DEF_OBJECT){
-                            TYPEINFO RetTypeInfo;
-                            if( !GetReturnTypeOfIndexerGetterProc(pobj_c,RetTypeInfo) ){
+                        Type type;
+                        GetVarType(VarName,type,false);
+                        if( type.IsObject() ){
+                            if( !GetReturnTypeOfIndexerGetterProc( type.GetClass(),type) ){
                                 SetError(1,NULL,cp);
                                 goto error;
                             }
-                            type[sp]=RetTypeInfo.type;
-                            index_stack[sp]=RetTypeInfo.u.lpIndex;
+                            type_stack[sp]=type.GetBasicType();
+                            index_stack[sp]=type.GetIndex();
                             bLiteralCalculation=0;
 
@@ -493 +490 @@
                     // Nothing
                     if( lstrcmp( term, "Nothing" ) == 0 ){
-                        type[sp] = DEF_OBJECT;
-                        if( pBaseType && pBaseType->type == DEF_OBJECT ){
-                            index_stack[sp] = pBaseType->u.lpIndex;
+                        type_stack[sp] = DEF_OBJECT;
+                        if( baseType.IsObject() ){
+                            index_stack[sp] = baseType.GetIndex();
                         }
                         else{
@@ -506 +503 @@
 
 
-                    i2=GetVarType(term,&index_stack[sp],0);
-                    if(i2!=-1){
+                    Type varType;
+                    if( GetVarType(term,varType,0) ){
                         //////////
                         // 変数
                         //////////
 
-                        if(i2&FLAG_PTR){
+                        if( varType.GetBasicType() & FLAG_PTR ){
                             //配列ポインタ
-                            type[sp]=GetPtrType(i2^FLAG_PTR,index_stack[sp]);
+                            type_stack[sp]=GetPtrType( varType.GetBasicType()^FLAG_PTR );
                         }
                         else{
-                            type[sp]=i2;
-                        }
+                            type_stack[sp]=varType.GetBasicType();
+                        }
+                        index_stack[sp] = varType.GetIndex();
 
                         bLiteralCalculation=0;
@@ -532 +530 @@
                     i3 = CDBConst::obj.GetType(term);
                     if(i3){
-                        type[sp]=i3;
+                        type_stack[sp]=i3;
                         if(IsRealNumberType(i3)){
                             //実数
@@ -563 +561 @@
                     i3=GetTypeFixed(term,&lp);
                     if(i3!=-1){
-                        type[sp]=i3|FLAG_CAST;
+                        type_stack[sp]=i3|FLAG_CAST;
                         index_stack[sp]=lp;
                         sp++;
@@ -579 +577 @@
 
                     if(GetSubHash(VarName,0)){
-                        TYPEINFO RetTypeInfo;
-                        GetReturnTypeOfPropertyMethod(term,NULL,&RetTypeInfo);
+                        Type tempType;
+                        GetReturnTypeOfPropertyMethod(term,NULL,tempType);
 
                         //大きな型への暗黙の変換
-                        type[sp]=RetTypeInfo.type;
-
-                        index_stack[sp]=RetTypeInfo.u.lpIndex;
+                        type_stack[sp]=tempType.GetBasicType();
+
+                        index_stack[sp]=tempType.GetIndex();
                         bLiteralCalculation=0;
 
@@ -597 +595 @@
                     bError=1;
                     SetError(3,term,cp);
-                    type[sp]=DEF_DOUBLE;
+                    type_stack[sp]=DEF_DOUBLE;
                 }
                 else{
                     //リテラル値
-                    int base_type;
-                    base_type=0;
-                    if(pBaseType) base_type=pBaseType->type;
-                    type[sp]=GetLiteralValue(term,&i64data,base_type);
+                    int base_type = 0;
+                    if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
+                    type_stack[sp]=GetLiteralValue(term,&i64data,base_type);
 Literal:
                     if((long)i64data==0&&index_stack[sp]==-1) index_stack[sp]=LITERAL_NULL;
@@ -617 +614 @@
             case CALC_AND:
                 sp--;
-                type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
+                type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
                 break;
             case CALC_NOT:
@@ -632 +629 @@
             case CALC_EQUAL:    //values[sp-2] =  values[sp-1]  
                 sp--;
-                type[sp-1]=DEF_LONG;
+                type_stack[sp-1]=DEF_LONG;
                 break;
 
@@ -646 +643 @@
             case CALC_PRODUCT:
                 sp--;
-                type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
+                type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
                 break;
             case CALC_MOD:
@@ -652 +649 @@
                 //剰余演算
                 sp--;
-                type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
+                type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
                 break;
             case CALC_QUOTIENT:
@@ -658 +655 @@
                 //除算
                 sp--;
-                type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
+                type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
                 break;
             case CALC_INTQUOTIENT:
@@ -664 +661 @@
                 //整数除算
                 sp--;
-                type[sp-1]=NeutralizationType(type[sp-1],index_stack[sp-1],type[sp],index_stack[sp]);
+                type_stack[sp-1]=NeutralizationType(type_stack[sp-1],index_stack[sp-1],type_stack[sp],index_stack[sp]);
                 break;
             case CALC_MINUSMARK:
@@ -677 +674 @@
             case CALC_AS:
                 //キャスト
-                type[sp-2]=type[sp-1]&(~FLAG_CAST);
+                type_stack[sp-2]=type_stack[sp-1]&(~FLAG_CAST);
                 index_stack[sp-2]=index_stack[sp-1];
 
@@ -685 +682 @@
             case CALC_BYVAL:
                 //ポインタ型→参照型
-                if( PTR_LEVEL( type[sp-1] ) <= 0 ){
+                if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
                     //ポインタ型ではないとき
                     SetError( 3, NULL, cp );
@@ -691 +688 @@
                 }
 
-                type[sp-1] = PTR_LEVEL_DOWN( type[sp-1] );
+                type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
                 break;
         }
@@ -705 +702 @@
     if(bLiteralCalculation){
         //右辺値が数値の定数式の場合
-        LONG_PTR lpCalcIndex;
-        int base_type=0;
-        if(pBaseType) base_type=pBaseType->type;
-        i2=StaticCalculation(true, Command,base_type,&i64data,&lpCalcIndex);
-
-        type[0]=i2;
-        index_stack[0]=lpCalcIndex;
+        int base_type = 0;
+        if( !baseType.IsNull() ) base_type = baseType.GetBasicType();
+        Type tempType;
+        StaticCalculation(true, expression,base_type,&i64data,tempType);
+
+        type_stack[0]=tempType.GetBasicType();
+        index_stack[0]=tempType.GetIndex();
     }
     else{
@@ -718 +715 @@
     }
 
-    if(plpIndex) *plpIndex=index_stack[0];
-
-    int RetType;
-    RetType=type[0];
+    resultType.SetType( type_stack[0], index_stack[0] );
+
+    bool isSuccessful = true;
     goto finish;
 
@@ -730 +726 @@
 
 error:
-    RetType=-1;
+    isSuccessful = false;
     goto finish;
 
@@ -738 +734 @@
         if(values[i]) HeapDefaultFree(values[i]);
     }
-    return RetType;
+    return isSuccessful;
 }
-
-bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType ){
-    TYPEINFO baseTypeInfo = {
-        baseType.GetBasicType(),
-        baseType.GetIndex()
-    };
-    LONG_PTR lpIndex;
-    int basicType = NumOpe_GetType_Old( expression,
-        baseType.IsNull() ? NULL:&baseTypeInfo,
-        &lpIndex );
-
-    resultType.SetBasicType( basicType );
-    resultType.SetIndex( lpIndex );
-
-    return ( basicType != -1 );
-}

BasicCompiler_Common/Object.cpp

@@ -9 +9 @@
 extern HANDLE hHeap;
 
-void CallConstructor(char *ObjectName,int *SubScripts,TYPEINFO &TypeInfo,char *Parameter){
-    if(TypeInfo.type!=DEF_OBJECT) return;
+void CallConstructor( const char *ObjectName,const int *SubScripts,const Type &type,const char *Parameter){
+    if( !type.IsObject() ){
+        return;
+    }
 
     /////////////////////////////////////
@@ -16 +18 @@
     // ※コンストラクタの呼び出し
     /////////////////////////////////////
-    CClass *pobj_c;
-    pobj_c=(CClass *)TypeInfo.u.lpIndex;
 
-    SubInfo *psi;
-    psi=GetMethodHash(ObjectName,pobj_c->name,Parameter);
-    if(!psi){
-        if(Parameter[0]) SetError(113,pobj_c->name,cp);
+    UserProc *pUserProc;
+    pUserProc=GetMethodHash(ObjectName,type.GetClass().name,Parameter);
+    if(!pUserProc){
+        if(Parameter[0]) SetError(113,type.GetClass().name,cp);
         return;
     }
@@ -52 +52 @@
             lstrcat(temporary,"]");
 
-            LONG_PTR lp;
-            sprintf(temporary+lstrlen(temporary),".%s",pobj_c->name);
-            CallProc(PROC_DEFAULT,
-                psi,
+            Type dummyType;
+            sprintf(temporary+lstrlen(temporary),".%s",type.GetClass().name);
+            CallProc( PROC_DEFAULT,
+                pUserProc,
                 temporary,
                 Parameter,
-                &lp);
+                dummyType );
 
             ss[0]++;
@@ -72 +72 @@
     }
     else{
-        LONG_PTR lp;
-        sprintf(temporary,"%s.%s",ObjectName,pobj_c->name);
-        CallProc(PROC_DEFAULT,
-            psi,
+        Type dummyType;
+        sprintf(temporary,"%s.%s",ObjectName,type.GetClass().name);
+        CallProc( PROC_DEFAULT,
+            pUserProc,
             temporary,
             Parameter,
-            &lp);
+            dummyType );
     }
 }
+
+bool Operator_New( const char *expression, const Type &baseType, Type &resultType ){
+    char CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
+    int i,i2;
+
+    i=0;
+
+    if(expression[0]=='['){
+        i=GetStringInBracket(objectSizeStr,expression);
+
+        SlideString(objectSizeStr+1,-1);
+        objectSizeStr[i-2]=0;
+    }
+    else objectSizeStr[0]=0;
+
+    char typeName[VN_SIZE];
+    for(i2=0;;i++,i2++){
+        if(expression[i]=='('){
+            typeName[i2]=0;
+
+            //コンストラクタに渡すパラメータを取得
+            i2=GetStringInPare(CreateParameter,expression+i);
+            RemoveStringPare(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;
+        }
+    }
+
+    if( !Type::StringToType( typeName, resultType ) ){
+        SetError(3,typeName,cp);
+        return false;
+    }
+
+    if( !resultType.IsObject() ){
+        ////////////////////////
+        // 通常のデータ型の場合
+        ////////////////////////
+
+        SetError(121,NULL,cp);
+        return false;
+    }
+
+    Operator_New( resultType.GetClass(), objectSizeStr, CreateParameter, baseType );
+
+    if( !baseType.IsObject() ){
+        // オブジェクトポインタ向け
+        resultType.SetBasicType( DEF_PTR_OBJECT );
+    }
+
+    return true;
+}

BasicCompiler_Common/Overload.cpp

@@ -7 +7 @@
 #endif
 
-SubInfo *OverloadSolutionWithStrParam(
+UserProc *OverloadSolutionWithStrParam(
     const char *name,
-    std::vector<SubInfo *> &subs,
+    std::vector<UserProc *> &subs,
     const char *Parameter,
-    const char *ObjectName,
-    TYPEINFO *pReturnTypeInfo){
+    const char *ObjectName){
 
         // オーバーロードの解決
@@ -31 +30 @@
         //メソッドの場合は静的かどうかを調べる
         bool isStatic = false;
-        CClass *pClass = subs[0]->pobj_ParentClass;
+        CClass *pClass = subs[0]->GetParentClassPtr();
         if( pClass ){
             isStatic = pClass->IsExistStaticMethod( MethodName );
@@ -37 +36 @@
 */
         //パラメータオブジェクトを生成
-        if(lstrcmp(Parameter,"\"test\"")==0){
-            int i=0;
-        }
         pobj_parameter=new ParamImpl(Parameter);
-        if(pReturnTypeInfo) pobj_parameter->SetReturnType(pReturnTypeInfo);
 
 
-        SubInfo *psi;
-        psi=pobj_parameter->OverloadSolution(name,subs);
+        UserProc *pUserProc;
+        pUserProc=pobj_parameter->OverloadSolution(name,subs);
 
 
@@ -52 +47 @@
         pobj_parameter=0;
 
-        return psi;
+        return pUserProc;
 }
-
-SubInfo *OverloadSolution(
+UserProc *OverloadSolution(
     const char *name,
-    std::vector<SubInfo *> &subs,
-    const PARAMETER_INFO *ppi,
-    const int ParmNum,
-    TYPEINFO *pReturnTypeInfo){
+    std::vector<UserProc *> &subs,
+    const Parameters &params,
+    const Type &returnType ){
 
         // オーバーロードの解決
@@ -68 +61 @@
 
 
-        ParamImpl *pobj_Parameter=new ParamImpl(ppi,ParmNum);
-        if(pReturnTypeInfo) pobj_Parameter->SetReturnType(pReturnTypeInfo);
+        ParamImpl *pobj_Parameter=new ParamImpl( params );
+        if( !returnType.IsNull() ){
+            pobj_Parameter->SetReturnType( returnType );
+        }
 
-        SubInfo *psi;
-        psi=pobj_Parameter->OverloadSolution(name,subs);
+        UserProc *pUserProc;
+        pUserProc=pobj_Parameter->OverloadSolution(name,subs);
 
         delete pobj_Parameter;
 
-        return psi;
+        return pUserProc;
 }

BasicCompiler_Common/PESchedule.cpp

@@ -197 +197 @@
 
 CImportAddrSchedule::CImportAddrSchedule(){
-    ppdi=(DECLAREINFO **)HeapAlloc(hHeap,0,1);
+    ppdi=(DllProc **)HeapAlloc(hHeap,0,1);
 }
 CImportAddrSchedule::~CImportAddrSchedule(){
@@ -203 +203 @@
 }
 
-void CImportAddrSchedule::add(DECLAREINFO *pdi){
-    ppdi=(DECLAREINFO **)HeapReAlloc(hHeap,0,ppdi,(num+1)*sizeof(DECLAREINFO *));
-    ppdi[num]=pdi;
+void CImportAddrSchedule::add(DllProc *pDllProc){
+    ppdi=(DllProc **)HeapReAlloc(hHeap,0,ppdi,(num+1)*sizeof(DllProc *));
+    ppdi[num]=pDllProc;
 
     CSchedule::add();
@@ -220 +220 @@
 
 CSubAddrSchedule::CSubAddrSchedule(){
-    ppsi=(SubInfo **)HeapAlloc(hHeap,0,1);
+    ppsi=(UserProc **)HeapAlloc(hHeap,0,1);
     pbCall=(BOOL *)HeapAlloc(hHeap,0,1);
 }
@@ -228 +228 @@
 }
 
-void CSubAddrSchedule::add(SubInfo *psi,BOOL bCall){
-    if(!psi) return;
-
-    ppsi=(SubInfo **)HeapReAlloc(hHeap,0,ppsi,(num+1)*sizeof(SubInfo *));
-    ppsi[num]=psi;
+void CSubAddrSchedule::add(UserProc *pUserProc,BOOL bCall){
+    if(!pUserProc) return;
+
+    ppsi=(UserProc **)HeapReAlloc(hHeap,0,ppsi,(num+1)*sizeof(UserProc *));
+    ppsi[num]=pUserProc;
     pbCall=(BOOL *)HeapReAlloc(hHeap,0,pbCall,(num+1)*sizeof(BOOL));
     pbCall[num]=bCall;
@@ -283 +283 @@
 
 
+
+

BasicCompiler_Common/PESchedule.h

@@ -63 +63 @@
 class CImportAddrSchedule:public CSchedule{
 public:
-    DECLAREINFO **ppdi;
+    DllProc **ppdi;
 
     CImportAddrSchedule();
     ~CImportAddrSchedule();
 
-    void add(DECLAREINFO *pdi);
+    void add(DllProc *pDllProc);
 };
 extern CImportAddrSchedule *pobj_ImportAddrSchedule;
@@ -79 +79 @@
 class CSubAddrSchedule:public CSchedule{
 public:
-    SubInfo **ppsi;
+    UserProc **ppsi;
     BOOL *pbCall;
 
@@ -85 +85 @@
     ~CSubAddrSchedule();
 
-    void add(SubInfo *psi,BOOL bCall);
+    void add(UserProc *pUserProc,BOOL bCall);
 };
 extern CSubAddrSchedule *pobj_SubAddrSchedule;

BasicCompiler_Common/ParamImpl.cpp

@@ -7 +7 @@
 #endif
 
-ParamImpl::ParamImpl(const char *buffer){
+ParamImpl::ParamImpl(const char *buffer):
+    returnType()
+{
     ///////////////////////////
     // パラメータ文字列を整理
@@ -55 +57 @@
         ParmsNum++;
 
+        types.push_back( Type() );
+
         if(buffer[i]==',') i++;
     }
-
-    ReturnTypeInfo.type=DEF_NON;
-    ReturnTypeInfo.u.lpIndex=-1;
-}
-ParamImpl::ParamImpl(const PARAMETER_INFO *pParamInfo,const int ParmNum){
-    int i;
-    for(i=0;i<ParmNum;i++){
-        Parms[i]=0;
-        types[i].type=pParamInfo[i].type;
-        types[i].u.lpIndex=pParamInfo[i].u.index;
-    }
-    this->ParmsNum=ParmNum;
-
-    ReturnTypeInfo.type=DEF_NON;
-    ReturnTypeInfo.u.lpIndex=-1;
-}
-ParamImpl::ParamImpl(const Parameters &params){
-    int count = 0;
+}
+ParamImpl::ParamImpl(const Parameters &params):
+    returnType()
+{
+    ParmsNum = 0;
     foreach( Parameter *pParam, params ){
-        types[count].type = pParam->GetBasicType();
-        types[count].u.lpIndex = pParam->GetIndex();
-        count++;
-    }
-    this->ParmsNum=params.size();
-
-    ReturnTypeInfo.type=DEF_NON;
-    ReturnTypeInfo.u.lpIndex=-1;
+        Parms[ParmsNum]=0;
+        ParmsNum++;
+
+        types.push_back( *pParam );
+    }
 }
 ParamImpl::~ParamImpl(){
@@ -96 +84 @@
 }
 
-void ParamImpl::SetReturnType(TYPEINFO *pTypeInfo){
-    ReturnTypeInfo=*pTypeInfo;
-}
-
-BOOL ParamImpl::_overload_check( Parameters &params,TYPEINFO *pReturnTypeInfo,int overload_level){
+void ParamImpl::SetReturnType( const Type &returnType ){
+    this->returnType = returnType;
+}
+
+bool ParamImpl::_overload_check( int level, const Parameters &targetParms, const Type &targetResultType ){
     //パラメータを識別してオーバーロードを解決
 
     //パラメータの個数が不一致の場合
-    int max = (int)params.size();
-    if(max!=ParmsNum) return 0;
+    int max = (int)targetParms.size();
+    if(max!=ParmsNum){
+        return false;
+    }
 
     Type argType;
     for(int i=0;i<max;i++){
-        Parameter &param = *params[i];
+        Parameter &param = *targetParms[i];
 
         if(Parms[i]){
@@ -115 +105 @@
 
             NumOpe_GetType(Parms[i],
-                (overload_level==OVERLOAD_LEVEL0)? nullParam : param,
+                (level==OVERLOAD_LEVEL0)? nullParam : param,
                 argType);
         }
         else{
-            argType.SetType( types[i].type, types[i].u.lpIndex );
+            argType = types[i];
         }
 
         if(argType.GetBasicType()!=param.GetBasicType()){
-            if(overload_level==OVERLOAD_LEVEL1 || overload_level == OVERLOAD_LEVEL0){
-                return 0;
-            }
-            else if(overload_level==OVERLOAD_LEVEL2){
+            if(level==OVERLOAD_LEVEL1 || level == OVERLOAD_LEVEL0){
+                return false;
+            }
+            else if(level==OVERLOAD_LEVEL2){
                 if(!(
                     IsWholeNumberType(argType.GetBasicType())&&IsWholeNumberType(param.GetBasicType())||
                     IsRealNumberType(argType.GetBasicType())&&IsRealNumberType(param.GetBasicType())
-                    )) return 0;
-            }
-            else if(overload_level==OVERLOAD_LEVEL3){
+                    )){
+                        return false;
+                }
+            }
+            else if(level==OVERLOAD_LEVEL3){
                 if(argType.GetBasicType()==DEF_OBJECT||param.GetBasicType()==DEF_OBJECT) return 0;
             }
@@ -138 +130 @@
         else{
             if(NATURAL_TYPE(argType.GetBasicType())==DEF_OBJECT || NATURAL_TYPE(argType.GetBasicType())==DEF_STRUCT){
-                if(argType.GetIndex()!=param.GetIndex()) return 0;
-            }
-        }
-    }
-
-    if(pReturnTypeInfo){
+                if(argType.GetIndex()!=param.GetIndex()){
+                    return false;
+                }
+            }
+        }
+    }
+
+    if( !targetResultType.IsNull() ){
         //戻り値も比較対象にする
-        if(ReturnTypeInfo.type==pReturnTypeInfo->type){
-            if(NATURAL_TYPE(ReturnTypeInfo.type)==DEF_OBJECT
-                || NATURAL_TYPE(ReturnTypeInfo.type)==DEF_STRUCT ){
-                    if(ReturnTypeInfo.u.lpIndex != pReturnTypeInfo->u.lpIndex) return 0;
-            }
-        }
-        else return 0;
-    }
-
-    return 1;
-}
-
-SubInfo *ParamImpl::OverloadSolutionWithReturnType( const char *name, std::vector<SubInfo *> &subs ){
+        if( !returnType.Equals( targetResultType ) ){
+            return false;
+        }
+    }
+
+    return true;
+}
+
+UserProc *ParamImpl::OverloadSolutionWithReturnType( const char *name, std::vector<UserProc *> &subs ){
     int sw=0;
-    SubInfo *psi;
-    psi=0;
+    UserProc *pUserProc = NULL;
 
     for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
-        foreach( SubInfo *temp_psi, subs ){
-
-            TYPEINFO ReturnTypeInfo;
-            ReturnTypeInfo.type=temp_psi->ReturnType;
-            ReturnTypeInfo.u.lpIndex=temp_psi->u.ReturnIndex;
+        foreach( UserProc *pTempUserProc, subs ){
 
             //エラーチェック
-            if(_overload_check(temp_psi->params,&ReturnTypeInfo,level)){
+            if(_overload_check( level, pTempUserProc->Params(), pTempUserProc->ReturnType() )){
                 if(sw){
                     SetError(52,name,cp);
@@ -177 +162 @@
                 sw=1;
 
-                psi = temp_psi;
+                pUserProc = pTempUserProc;
                 break;
             }
@@ -190 +175 @@
     }
 
-    return psi;
-}
-SubInfo *ParamImpl::OverloadSolution( const char *name, std::vector<SubInfo *> &subs ){
+    return pUserProc;
+}
+UserProc *ParamImpl::OverloadSolution( const char *name, std::vector<UserProc *> &subs ){
     int sw=0;
-    SubInfo *psi;
-    psi=0;
+    UserProc *pUserProc;
+    pUserProc=0;
 
     for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
 
-        foreach( SubInfo *temp_psi, subs ){
+        foreach( UserProc *pTempUserProc, subs ){
 
             //エラーチェック
-            if(_overload_check(temp_psi->params,NULL,level)){
+            if(_overload_check( level, pTempUserProc->Params(), Type() )){
                 if(sw){
                     return OverloadSolutionWithReturnType(name,subs);
@@ -208 +193 @@
                 sw=1;
 
-                psi = temp_psi;
+                pUserProc = pTempUserProc;
             }
         }
@@ -216 +201 @@
 
     if(!sw){
-        SubInfo *temp_psi;
-        foreach( temp_psi, subs ){
+        foreach( UserProc *pTempUserProc, subs ){
 
             //エラーチェック
-            if(temp_psi->params.size()==this->ParmsNum){
+            if(pTempUserProc->Params().size()==this->ParmsNum){
                 if(sw){
                     sw=0;
@@ -227 +211 @@
                 sw=1;
 
-                psi=temp_psi;
+                pUserProc=pTempUserProc;
             }
         }
@@ -237 +221 @@
     }
 
-    return psi;
-}
-
-BOOL ParamImpl::ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
-    if(ParmsNum>pi_num){
-        if(ppi[pi_num-1].type!=DEF_ELLIPSE){
-            //パラメータが多すぎるとき
-            SetError(10,FuncName,cp);
-            return 0;
-        }
-    }
-    else if(ParmsNum<pi_num){
-        if(ParmsNum<SecondParmNum){
-            if(ppi[ParmsNum].type==DEF_ELLIPSE){
-                return 1;
-            }
-
-            //パラメータが少なすぎるとき
-            SetError(10,FuncName,cp);
-            return 0;
-        }
-
-        //省略パラメータに "0" を指定する
-        for(;ParmsNum < pi_num;ParmsNum++){
-            extern HANDLE hHeap;
-            char temporary[64];
-            if(ppi[ParmsNum].bByVal) lstrcpy(temporary,"0");
-            else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
-            Parms[ParmsNum]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
-            lstrcpy(Parms[ParmsNum],temporary);
-        }
-    }
-
-    return 1;
-}
-bool ParamImpl::ErrorCheck( const char *procName, const Parameters &params, int SecondParmNum ){
+    return pUserProc;
+}
+
+bool ParamImpl::ErrorCheck( const string &procName, const Parameters &params, int SecondParmNum ){
+    if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
+
     if(ParmsNum>(int)params.size()){
         if(params[params.size()-1]->GetBasicType()!=DEF_ELLIPSE){
@@ -305 +259 @@
 }
 
-void ParamImpl::MacroParameterSupport(PARAMETER_INFO *ppi){
-    for(int i=0;i<ParmsNum;i++){
-        if(Parms[i][0]=='\0'){
-            extern HANDLE hHeap;
-            char temporary[64];
-            if(ppi[i].bByVal) lstrcpy(temporary,"0");
-            else sprintf(temporary,"%c%c0",1,ESC_BYVAL);
-            HeapDefaultFree(Parms[i]);
-            Parms[i]=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
-            lstrcpy(Parms[i],temporary);
-        }
-    }
-}
 void ParamImpl::MacroParameterSupport( const Parameters &params ){
     for(int i=0;i<ParmsNum;i++){

BasicCompiler_Common/Parameter.h

@@ -46 +46 @@
     }
 
-    bool IsRef(){
+    bool IsRef() const
+    {
         return isRef;
     }

BasicCompiler_Common/Procedure.cpp

@@ -1 +1 @@
 #include "common.h"
 
-SubInfo::SubInfo():
-  pNextData( NULL )
-{
+bool UserProc::SetParamsAndReturnType( const char *sourceOfParams, int nowLine, bool isStatic ){
+    int i = 0;
+    int i2,i3,sw;
+    char temporary[8192],temp2[VN_SIZE];
+
+    //ソースコードの位置
+    this->codePos = nowLine;
+
+    //パラメータ
+    if(sourceOfParams[i]!='('){
+        SetError(1,NULL,nowLine);
+        return 0;
+    }
+    i++;
+    if(sourceOfParams[i]!=')'&& this->pParentClass ){
+        //クラスのメンバ関数の場合のみ、デストラクタにパラメータがある場合にエラーをだす
+        if(this->GetName()[0]=='~'){
+            SetError(114,NULL,nowLine);
+            i=JumpStringInPare(sourceOfParams,i);
+        }
+    }
+    while(1){
+        if(sourceOfParams[i]==')') break;
+
+        //ByRef
+        bool isRef;
+        if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYVAL){
+            isRef = false;
+            i+=2;
+        }
+        else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYREF){
+            isRef = true;
+            i+=2;
+        }
+        else isRef = false;
+
+        //パラメータ名
+        bool isArray = false;
+        int subScripts[MAX_ARRAYDIM];
+        char name[VN_SIZE];
+        sw=0;
+        for(i2=0;;i++,i2++){
+            if(sourceOfParams[i]=='('){
+                if(!sw) sw=1;
+
+                i3=GetStringInPare(name+i2,sourceOfParams+i);
+                i2+=i3-1;
+                i+=i3-1;
+                continue;
+            }
+            if(sourceOfParams[i]=='['){
+                if(!sw) sw=1;
+
+                i3=GetStringInBracket(name+i2,sourceOfParams+i);
+                i2+=i3-1;
+                i+=i3-1;
+                continue;
+            }
+            if(!IsVariableChar(sourceOfParams[i])){
+                name[i2]=0;
+                break;
+            }
+            name[i2]=sourceOfParams[i];
+        }
+        if(sw){
+            //配列パラメータ
+            if( isRef == false ) SetError(29,NULL,nowLine);
+            isArray = true;
+
+            if((name[i2-2]=='('&&name[i2-1]==')')||
+                (name[i2-2]=='['&&name[i2-1]==']')){
+                subScripts[0]=LONG_MAX;
+                subScripts[1]=-1;
+
+                name[i2-2]=0;
+            }
+            else{
+                GetArrange(name,temp2,subScripts);
+                lstrcpy(name,temp2);
+            }
+
+            i2=lstrlen(name);
+        }
+
+        //型
+        Type type( DEF_NON );
+        if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
+            i+=2;
+
+            i2=0;
+            while(sourceOfParams[i]=='*'){
+                temporary[i2]=sourceOfParams[i];
+                i++;
+                i2++;
+            }
+            for(;;i++,i2++){
+                if(!IsVariableChar(sourceOfParams[i])){
+                    if(sourceOfParams[i]==1&&(sourceOfParams[i+1]==ESC_FUNCTION||sourceOfParams[i+1]==ESC_SUB)){
+                        temporary[i2++]=sourceOfParams[i++];
+                        temporary[i2]=sourceOfParams[i];
+                        continue;
+                    }
+                    temporary[i2]=0;
+                    break;
+                }
+                temporary[i2]=sourceOfParams[i];
+            }
+
+            Type::StringToType( temporary, type );
+
+            if(temporary[0]=='*'&&
+                temporary[1]==1&&
+                (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
+                if(sourceOfParams[i]!='('){
+                    SetError(10,temporary,nowLine);
+                    break;
+                }
+                i3=GetStringInPare(temporary+i2,sourceOfParams+i);
+                i+=i3;
+                i2+=i3;
+
+                if(temporary[2]==ESC_FUNCTION&&sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
+                    temporary[i2++]=sourceOfParams[i++];
+                    temporary[i2++]=sourceOfParams[i++];
+                    for(;;i++,i2++){
+                        if(!IsVariableChar(sourceOfParams[i])){
+                            temporary[i2]=0;
+                            break;
+                        }
+                        temporary[i2]=sourceOfParams[i];
+                    }
+                }
+            }
+            else{
+                //TypeDefをする前のベース型を取得
+                GetOriginalTypeName(temporary);
+            }
+
+            if( type.IsNull() ){
+                SetError(3,temporary,nowLine);
+                type.SetBasicType( DEF_PTR_VOID );
+            }
+        }
+        else{
+            type.SetBasicType( GetTypeFromSimpleName(temporary) );
+            SetError(-103,temporary,nowLine);
+        }
+
+        if( type.IsProcPtr() ){
+            //関数ポインタの場合
+            type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2], nowLine) );
+        }
+
+        Parameter *pParam = new Parameter( name, type, isRef );
+        if( isArray ){
+            pParam->SetArray( subScripts );
+        }
+
+        //パラメータを追加
+        this->params.push_back( pParam );
+
+        if(sourceOfParams[i]==','){
+            i++;
+            continue;
+        }
+        else if(sourceOfParams[i]==')') continue;
+        else{
+            SetError(1,NULL,nowLine);
+            break;
+        }
+    }
+    this->secondParmNum = (int)this->params.size();
+    i++;
+    if(sourceOfParams[i]=='('){
+        i++;
+        while(1){
+            if(sourceOfParams[i]==')') break;
+
+            //ByRef
+            bool isRef;
+            if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYVAL){
+                isRef = false;
+                i+=2;
+            }
+            else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYREF){
+                isRef = true;
+                i+=2;
+            }
+            else isRef = false;
+
+            //パラメータ名
+            bool isArray = false;
+            int subScripts[MAX_ARRAYDIM];
+            char name[VN_SIZE];
+            sw=0;
+            for(i2=0;;i++,i2++){
+                if(sourceOfParams[i]=='('){
+                    if(!sw) sw=1;
+
+                    i3=GetStringInPare(name+i2,sourceOfParams+i);
+                    i2+=i3-1;
+                    i+=i3-1;
+                    continue;
+                }
+                if(sourceOfParams[i]=='['){
+                    if(!sw) sw=1;
+
+                    i3=GetStringInBracket(name+i2,sourceOfParams+i);
+                    i2+=i3-1;
+                    i+=i3-1;
+                    continue;
+                }
+                if(!IsVariableChar(sourceOfParams[i])){
+                    name[i2]=0;
+                    break;
+                }
+                name[i2]=sourceOfParams[i];
+            }
+            if(sw){
+                //配列パラメータ
+                if( isRef == false ) SetError(29,NULL,nowLine);
+                isArray = true;
+
+                if((name[i2-2]=='('&&name[i2-1]==')')||
+                    (name[i2-2]=='['&&name[i2-1]==']')){
+                    subScripts[0]=LONG_MAX;
+                    subScripts[1]=-1;
+
+                    name[i2-2]=0;
+                }
+                else{
+                    GetArrange(name,temp2,subScripts);
+                    lstrcpy(name,temp2);
+                }
+
+                i2=lstrlen(name);
+            }
+
+            //型
+            Type type( DEF_NON );
+            if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
+                i+=2;
+
+                i2=0;
+                while(sourceOfParams[i]=='*'){
+                    temporary[i2]=sourceOfParams[i];
+                    i++;
+                    i2++;
+                }
+                for(;;i++,i2++){
+                    if(!IsVariableChar(sourceOfParams[i])){
+                        if(sourceOfParams[i]==1&&(sourceOfParams[i+1]==ESC_FUNCTION||sourceOfParams[i+1]==ESC_SUB)){
+                            temporary[i2++]=sourceOfParams[i++];
+                            temporary[i2]=sourceOfParams[i];
+                            continue;
+                        }
+                        temporary[i2]=0;
+                        break;
+                    }
+                    temporary[i2]=sourceOfParams[i];
+                }
+
+                Type::StringToType( temporary, type );
+
+                if(temporary[0]=='*'&&
+                    temporary[1]==1&&
+                    (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
+                    if(sourceOfParams[i]!='('){
+                        SetError(10,temporary,nowLine);
+                        break;
+                    }
+                    i3=GetStringInPare(temporary+i2,sourceOfParams+i);
+                    i+=i3;
+                    i2+=i3;
+
+                    if(temporary[2]==ESC_FUNCTION&&sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
+                        temporary[i2++]=sourceOfParams[i++];
+                        temporary[i2++]=sourceOfParams[i++];
+                        for(;;i++,i2++){
+                            if(!IsVariableChar(sourceOfParams[i])){
+                                temporary[i2]=0;
+                                break;
+                            }
+                            temporary[i2]=sourceOfParams[i];
+                        }
+                    }
+                }
+                else{
+                    //TypeDefをする前のベース型を取得
+                    GetOriginalTypeName(temporary);
+                }
+
+                if( type.IsNull() ){
+                    SetError(3,temporary,nowLine);
+                    type.SetBasicType( DEF_PTR_VOID );
+                }
+            }
+            else{
+                type.SetBasicType( GetTypeFromSimpleName(temporary) );
+                SetError(-103,temporary,nowLine);
+            }
+
+            if( type.IsProcPtr() ){
+                //関数ポインタの場合
+                type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2], nowLine) );
+            }
+
+            Parameter *pParam = new Parameter( name, type, isRef );
+            if( isArray ){
+                pParam->SetArray( subScripts );
+            }
+
+            //パラメータを追加
+            this->params.push_back( pParam );
+
+            if(sourceOfParams[i]==','){
+                i++;
+                continue;
+            }
+            else if(sourceOfParams[i]==')') continue;
+            else{
+                SetError(1,NULL,nowLine);
+                break;
+            }
+        }
+        i++;
+    }
+
+    if(sourceOfParams[i]){
+        ///////////////////
+        // 戻り値を取得
+        ///////////////////
+
+        if( !this->IsFunction() ){
+            // Sub/Macroの場合
+            SetError(38,this->GetName(),nowLine);
+        }
+
+        if( this->pParentClass ){
+            if( this->GetName() == this->pParentClass->name ||
+                this->GetName()[0]=='~'){
+                //クラスのコンストラクタ、デストラクタがFunction定義の場合はエラーをだす
+                SetError(115,NULL,nowLine);
+            }
+        }
+
+
+        i2=lstrlen(sourceOfParams)-2;
+
+        int sw_as=0;
+        for(;i2>0;i2--){
+            if(sourceOfParams[i2]==')') break;
+
+            if(sourceOfParams[i2]==1&&sourceOfParams[i2+1]==ESC_AS){
+                i2+=2;
+                i3=0;
+                while(sourceOfParams[i2]=='*') temporary[i3++]=sourceOfParams[i2++];
+                for(;;i2++,i3++){
+                    if(!IsVariableChar(sourceOfParams[i2])){
+                        temporary[i3]=0;
+                        break;
+                    }
+                    temporary[i3]=sourceOfParams[i2];
+                }
+                Type::StringToType( temporary, this->returnType );
+                if( this->returnType.IsNull() ) SetError(3,temporary,nowLine);
+
+                sw_as=1;
+                break;
+            }
+        }
+
+        if(!sw_as){
+            SetError(-104,this->GetName().c_str(),nowLine);
+
+            this->returnType.SetBasicType( DEF_DOUBLE );
+        }
+    }
+    else{
+        //戻り値なしのSub定義
+        this->returnType.SetNull();
+    }
+
+    //リアルパラメータ領域を取得（_System_LocalThisを考慮して2つだけ多く確保する場合がある）
+
+    if( this->pParentClass && isStatic == false ){
+        //オブジェクトメンバの場合は、第一パラメータを_System_LocalThis引き渡し用として利用
+        string name = "_System_LocalThis";
+        Type type( DEF_PTR_VOID );
+        this->realParams.push_back( new Parameter( name, type ) );
+    }
+
+    if( this->returnType.IsStruct() ){
+        //構造体を戻り値として持つ場合
+        //※第一パラメータ（Thisポインタありの場合は第二パラメータ）を戻り値用の参照宣言にする
+
+        string name = this->GetName();
+        if(name[0]==1&&name[1]==ESC_OPERATOR){
+            name="_System_ReturnValue";
+        }
+        Type type( DEF_STRUCT, this->returnType.GetIndex() );
+        this->realParams.push_back( new Parameter( name, type, true ) );
+    }
+
+    //パラメータをコピー
+    foreach( Parameter *pParam, params ){
+        this->realParams.push_back( new Parameter( *pParam ) );
+    }
+
+    return true;
 }
+
+bool DllProc::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
+    int i = 0;
+    int i2,i3,sw;
+    char temporary[8192],temp2[VN_SIZE];
+
+    //ソースコードの位置
+    this->codePos = nowLine;
+
+    //パラメータ
+    if(sourceOfParams[i]!='('){
+        SetError(1,NULL,nowLine);
+        return 0;
+    }
+    i++;
+
+    while(1){
+        if(sourceOfParams[i]==')') break;
+
+        //ByRef
+        bool isRef;
+        if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYVAL){
+            isRef = false;
+            i+=2;
+        }
+        else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYREF){
+            isRef = true;
+            i+=2;
+        }
+        else isRef = false;
+
+        //パラメータ名
+        bool isArray = false;
+        int subScripts[MAX_ARRAYDIM];
+        char name[VN_SIZE];
+        sw=0;
+        for(i2=0;;i++,i2++){
+            if(sourceOfParams[i]=='('){
+                if(!sw) sw=1;
+
+                i3=GetStringInPare(name+i2,sourceOfParams+i);
+                i2+=i3-1;
+                i+=i3-1;
+                continue;
+            }
+            if(sourceOfParams[i]=='['){
+                if(!sw) sw=1;
+
+                i3=GetStringInBracket(name+i2,sourceOfParams+i);
+                i2+=i3-1;
+                i+=i3-1;
+                continue;
+            }
+            if(!IsVariableChar(sourceOfParams[i])){
+                name[i2]=0;
+                break;
+            }
+            name[i2]=sourceOfParams[i];
+        }
+        if(sw){
+            //配列パラメータ
+            if( isRef == false ) SetError(29,NULL,nowLine);
+            isArray = true;
+
+            if((name[i2-2]=='('&&name[i2-1]==')')||
+                (name[i2-2]=='['&&name[i2-1]==']')){
+                subScripts[0]=LONG_MAX;
+                subScripts[1]=-1;
+
+                name[i2-2]=0;
+            }
+            else{
+                GetArrange(name,temp2,subScripts);
+                lstrcpy(name,temp2);
+            }
+
+            i2=lstrlen(name);
+        }
+
+        //型
+        Type type( DEF_NON );
+        if(lstrcmp(name,"...")==0) type.SetBasicType( DEF_ELLIPSE );
+        else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
+            i+=2;
+
+            i2=0;
+            while(sourceOfParams[i]=='*'){
+                temporary[i2]=sourceOfParams[i];
+                i++;
+                i2++;
+            }
+            for(;;i++,i2++){
+                if(!IsVariableChar(sourceOfParams[i])){
+                    if(sourceOfParams[i]==1&&(sourceOfParams[i+1]==ESC_FUNCTION||sourceOfParams[i+1]==ESC_SUB)){
+                        temporary[i2++]=sourceOfParams[i++];
+                        temporary[i2]=sourceOfParams[i];
+                        continue;
+                    }
+                    temporary[i2]=0;
+                    break;
+                }
+                temporary[i2]=sourceOfParams[i];
+            }
+
+            Type::StringToType( temporary, type );
+
+            if(temporary[0]=='*'&&
+                temporary[1]==1&&
+                (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
+                if(sourceOfParams[i]!='('){
+                    SetError(10,temporary,nowLine);
+                    break;
+                }
+                i3=GetStringInPare(temporary+i2,sourceOfParams+i);
+                i+=i3;
+                i2+=i3;
+
+                if(temporary[2]==ESC_FUNCTION&&sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
+                    temporary[i2++]=sourceOfParams[i++];
+                    temporary[i2++]=sourceOfParams[i++];
+                    for(;;i++,i2++){
+                        if(!IsVariableChar(sourceOfParams[i])){
+                            temporary[i2]=0;
+                            break;
+                        }
+                        temporary[i2]=sourceOfParams[i];
+                    }
+                }
+            }
+            else{
+                //TypeDefをする前のベース型を取得
+                GetOriginalTypeName(temporary);
+            }
+
+            if( type.IsNull() ){
+                SetError(3,temporary,nowLine);
+                type.SetBasicType( DEF_PTR_VOID );
+            }
+        }
+        else{
+            type.SetBasicType( GetTypeFromSimpleName(temporary) );
+            SetError(-103,temporary,nowLine);
+        }
+
+        if( type.IsProcPtr() ){
+            //関数ポインタの場合
+            type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2], nowLine ) );
+        }
+
+        Parameter *pParam = new Parameter( name, type, isRef );
+        if( isArray ){
+            pParam->SetArray( subScripts );
+        }
+
+        //パラメータを追加
+        this->params.push_back( pParam );
+
+        if(sourceOfParams[i]==','){
+            i++;
+            continue;
+        }
+        else if(sourceOfParams[i]==')') continue;
+        else{
+            SetError(1,NULL,nowLine);
+            break;
+        }
+    }
+    i++;
+
+    if(sourceOfParams[i]){
+        ///////////////////
+        // 戻り値を取得
+        ///////////////////
+
+        i2=lstrlen(sourceOfParams)-2;
+
+        int sw_as=0;
+        for(;i2>0;i2--){
+            if(sourceOfParams[i2]==')') break;
+
+            if(sourceOfParams[i2]==1&&sourceOfParams[i2+1]==ESC_AS){
+                i2+=2;
+                i3=0;
+                while(sourceOfParams[i2]=='*') temporary[i3++]=sourceOfParams[i2++];
+                for(;;i2++,i3++){
+                    if(!IsVariableChar(sourceOfParams[i2])){
+                        temporary[i3]=0;
+                        break;
+                    }
+                    temporary[i3]=sourceOfParams[i2];
+                }
+                Type::StringToType( temporary, this->returnType );
+                if( this->returnType.IsNull() ) SetError(3,temporary,nowLine);
+
+                sw_as=1;
+                break;
+            }
+        }
+    }
+    else{
+        //戻り値なしのSub定義
+        this->returnType.SetNull();
+    }
+
+    return true;
+}
+
+bool ProcPointer::SetParamsAndReturnType( const char *sourceOfParams, int nowLine ){
+    int i = 0;
+    int i2,i3,sw;
+    char temporary[8192],temp2[VN_SIZE];
+
+    //ソースコードの位置
+    this->codePos = nowLine;
+
+    //パラメータ
+    if(sourceOfParams[i]!='('){
+        SetError(1,NULL,nowLine);
+        return 0;
+    }
+    i++;
+    while(1){
+        if(sourceOfParams[i]==')') break;
+
+        //ByRef
+        bool isRef;
+        if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYVAL){
+            isRef = false;
+            i+=2;
+        }
+        else if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_BYREF){
+            isRef = true;
+            i+=2;
+        }
+        else isRef = false;
+
+        //パラメータ名
+        bool isArray = false;
+        int subScripts[MAX_ARRAYDIM];
+        char name[VN_SIZE];
+        sw=0;
+        for(i2=0;;i++,i2++){
+            if(sourceOfParams[i]=='('){
+                if(!sw) sw=1;
+
+                i3=GetStringInPare(name+i2,sourceOfParams+i);
+                i2+=i3-1;
+                i+=i3-1;
+                continue;
+            }
+            if(sourceOfParams[i]=='['){
+                if(!sw) sw=1;
+
+                i3=GetStringInBracket(name+i2,sourceOfParams+i);
+                i2+=i3-1;
+                i+=i3-1;
+                continue;
+            }
+            if(!IsVariableChar(sourceOfParams[i])){
+                name[i2]=0;
+                break;
+            }
+            name[i2]=sourceOfParams[i];
+        }
+        if(sw){
+            //配列パラメータ
+            if( isRef == false ) SetError(29,NULL,nowLine);
+            isArray = true;
+
+            if((name[i2-2]=='('&&name[i2-1]==')')||
+                (name[i2-2]=='['&&name[i2-1]==']')){
+                subScripts[0]=LONG_MAX;
+                subScripts[1]=-1;
+
+                name[i2-2]=0;
+            }
+            else{
+                GetArrange(name,temp2,subScripts);
+                lstrcpy(name,temp2);
+            }
+
+            i2=lstrlen(name);
+        }
+
+        //型
+        Type type( DEF_NON );
+        if(sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
+            i+=2;
+
+            i2=0;
+            while(sourceOfParams[i]=='*'){
+                temporary[i2]=sourceOfParams[i];
+                i++;
+                i2++;
+            }
+            for(;;i++,i2++){
+                if(!IsVariableChar(sourceOfParams[i])){
+                    if(sourceOfParams[i]==1&&(sourceOfParams[i+1]==ESC_FUNCTION||sourceOfParams[i+1]==ESC_SUB)){
+                        temporary[i2++]=sourceOfParams[i++];
+                        temporary[i2]=sourceOfParams[i];
+                        continue;
+                    }
+                    temporary[i2]=0;
+                    break;
+                }
+                temporary[i2]=sourceOfParams[i];
+            }
+
+            Type::StringToType( temporary, type );
+
+            if(temporary[0]=='*'&&
+                temporary[1]==1&&
+                (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
+                if(sourceOfParams[i]!='('){
+                    SetError(10,temporary,nowLine);
+                    break;
+                }
+                i3=GetStringInPare(temporary+i2,sourceOfParams+i);
+                i+=i3;
+                i2+=i3;
+
+                if(temporary[2]==ESC_FUNCTION&&sourceOfParams[i]==1&&sourceOfParams[i+1]==ESC_AS){
+                    temporary[i2++]=sourceOfParams[i++];
+                    temporary[i2++]=sourceOfParams[i++];
+                    for(;;i++,i2++){
+                        if(!IsVariableChar(sourceOfParams[i])){
+                            temporary[i2]=0;
+                            break;
+                        }
+                        temporary[i2]=sourceOfParams[i];
+                    }
+                }
+            }
+            else{
+                //TypeDefをする前のベース型を取得
+                GetOriginalTypeName(temporary);
+            }
+
+            if( type.IsNull() ){
+                SetError(3,temporary,nowLine);
+                type.SetBasicType( DEF_PTR_VOID );
+            }
+        }
+        else{
+            type.SetBasicType( GetTypeFromSimpleName(temporary) );
+            SetError(-103,temporary,nowLine);
+        }
+
+        if( type.IsProcPtr() ){
+            //関数ポインタの場合
+            type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2], nowLine ) );
+        }
+
+        Parameter *pParam = new Parameter( name, type, isRef );
+        if( isArray ){
+            pParam->SetArray( subScripts );
+        }
+
+        //パラメータを追加
+        this->params.push_back( pParam );
+
+        if(sourceOfParams[i]==','){
+            i++;
+            continue;
+        }
+        else if(sourceOfParams[i]==')') continue;
+        else{
+            SetError(1,NULL,nowLine);
+            break;
+        }
+    }
+    i++;
+
+    if(sourceOfParams[i]){
+        ///////////////////
+        // 戻り値を取得
+        ///////////////////
+
+        i2=lstrlen(sourceOfParams)-2;
+
+        int sw_as=0;
+        for(;i2>0;i2--){
+            if(sourceOfParams[i2]==')') break;
+
+            if(sourceOfParams[i2]==1&&sourceOfParams[i2+1]==ESC_AS){
+                i2+=2;
+                i3=0;
+                while(sourceOfParams[i2]=='*') temporary[i3++]=sourceOfParams[i2++];
+                for(;;i2++,i3++){
+                    if(!IsVariableChar(sourceOfParams[i2])){
+                        temporary[i3]=0;
+                        break;
+                    }
+                    temporary[i3]=sourceOfParams[i2];
+                }
+                Type::StringToType( temporary, this->returnType );
+                if( this->returnType.IsNull() ) SetError(3,temporary,nowLine);
+
+                sw_as=1;
+                break;
+            }
+        }
+    }
+    else{
+        //戻り値なしのSub定義
+        this->returnType.SetNull();
+    }
+
+    //戻り値のエラーチェック
+    if( IsFunction() ){
+        // Function定義
+
+        if( this->ReturnType().IsNull() ){
+            // 戻り値がない
+            SetError(26,this->GetName(),nowLine);
+        }
+    }
+    else{
+        if( !this->ReturnType().IsNull() ){
+            // Sub定義なのに、戻り値がある
+            SetError(38,this->GetName(),nowLine);
+        }
+    }
+
+    return true;
+}
+
+UserProc *UserProc::pCompilingUserProc = NULL;

BasicCompiler_Common/Procedure.h

@@ -2 +2 @@
 struct VARIABLE;
 
-#define SUBTYPE_SUB         1
-#define SUBTYPE_FUNCTION    2
-#define SUBTYPE_MACRO       3
-class SubInfo{
-public:
-    SubInfo();
-
-    DWORD dwType;
-
-    //クラス情報
-    CClass *pobj_ParentClass;
-
+class Procedure{
+public:
+    // 種類
+    enum Kind{
+        Sub,
+        Function,
+    };
+
+private:
+    const string name;
+
+    Kind kind;
+
+    bool isCdecl;
+    bool isUsing;
+
+protected:
+
+    // パラメータ
+    Parameters params;
+
+    // 戻り値の型
+    Type returnType;
+
+    // ソースコードの位置
+    int codePos;
+
+public:
+    Procedure( const string &name, Kind kind, bool isCdecl ):
+      name( name ),
+      kind( kind ),
+      isCdecl( isCdecl ),
+      isUsing( false ),
+      codePos( -1 )
+    {}
+    ~Procedure(){
+        foreach( Parameter *pParam, params ){
+            delete pParam;
+        }
+    }
+
+    const string &GetName() const
+    {
+        return name;
+    }
+
+    bool IsSub() const
+    {
+        return ( kind == Sub );
+    }
+    bool IsFunction() const
+    {
+        return ( kind == Function );
+    }
+
+    bool IsCdecl() const
+    {
+        return isCdecl;
+    }
+    void Using(){
+        isUsing = true;
+    }
+    bool IsUsing() const
+    {
+        return isUsing;
+    }
+
+    int GetCodePos() const
+    {
+        return codePos;
+    }
+
+    const Parameters &Params() const
+    {
+        return params;
+    }
+    const Type &ReturnType() const
+    {
+        return returnType;
+    }
+};
+
+class UserProc : public Procedure
+{
+
+private:
+    bool isMacro;
+
+    // パラメータの追加情報
+    int secondParmNum;
+    Parameters realParams;
+    int realSecondParmNum;
+
+    // 親クラスと対応するメソッド
+    CClass *pParentClass;
+    CMethod *pMethod;
+
+    // 各種フラグ
+    bool isExport;
+    bool isSystem;
+    bool isCompiled;
+
+public:
+    // ハッシュリスト用
+    UserProc *pNextData;
+
+    UserProc( const string &name, Kind kind, bool isMacro, bool isCdecl, bool isExport ):
+      Procedure( name, kind, isCdecl ),
+      isMacro( isMacro ),
+      pParentClass( NULL ),
+      pMethod( NULL ),
+      isExport( isExport ),
+      isSystem( false ),
+      isCompiled( false ),
+      pNextData( NULL )
+    {
+    }
+    ~UserProc(){
+        foreach( Parameter *pParam, realParams ){
+            delete pParam;
+        }
+    }
+
+    bool IsMacro() const
+    {
+        return isMacro;
+    }
+
+    virtual bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine, bool isStatic );
+
+    int GetSecondParmNum() const
+    {
+        return secondParmNum;
+    }
+    const Parameters &RealParams() const
+    {
+        return realParams;
+    }
+    int GetRealSecondParmNum() const
+    {
+        return realSecondParmNum;
+    }
+
+    void SetParentClass( CClass *pParentClass ){
+        this->pParentClass = pParentClass;
+    }
+    CClass *GetParentClassPtr()
+    {
+        return pParentClass;
+    }
+    const CClass &GetParentClass() const
+    {
+        return *pParentClass;
+    }
+    void SetMethod( CMethod *pMethod ){
+        this->pMethod = pMethod;
+    }
+
+    void ExportOff(){
+        isExport = false;
+    }
+    bool IsExport() const
+    {
+        return isExport;
+    }
+    void ThisIsSystemProc(){
+        isSystem = true;
+    }
+    bool IsSystem() const
+    {
+        return isSystem;
+    }
+    void CompleteCompile(){
+        isCompiled = true;
+    }
+    void KillCompileStatus(){
+        isCompiled = false;
+    }
+    bool IsCompiled() const
+    {
+        return isCompiled;
+    }
+    bool IsDestructor() const
+    {
+        return ( GetName()[0] == '~' );
+    }
+    bool IsVirtual() const
+    {
+        if( pMethod == NULL ){
+            return false;
+        }
+        return ( pMethod->bVirtual != 0 );
+    }
+
+
+    // バイナリコードの位置
+    DWORD beginOpAddress;
+    DWORD endOpAddress;
+
+    // ローカル変数
+    Variables localVars;
+
+    // TODO: 適切なコードへ直す
     long id;
 
-    char *name;
-    long address;
-
-    //パラメータ
-    Parameters params;
-    int SecondParmNum;
-    Parameters realParams;
-    int RealSecondParmNum;
-
-    //戻り値
-    int ReturnType;
-    union{
-        LONG_PTR ReturnIndex;
-        CClass *Return_pobj_c;
-    }u;
-    bool isReturnRef;
-
-    DWORD CompileAddress;
-    DWORD EndOpAddr;
-    VARIABLE *pVar;
-    int VarNum;
-
-    BOOL bExport;
-    BOOL bCdecl;
-    BOOL bVirtual;
-    BOOL bUse;
-    BOOL bCompile;
-    BOOL bSystem;
-
-    SubInfo *pNextData;
-};
+
+    /////////////////////////////////////////////////////////////////
+    // コンパイル中の関数を管理
+    /////////////////////////////////////////////////////////////////
+private:
+    static UserProc *pCompilingUserProc;
+public:
+    static void CompileStartForGlobalArea(){
+        pCompilingUserProc = NULL;
+    }
+    static void CompileStartForUserProc( UserProc *pUserProc ){
+        pCompilingUserProc = pUserProc;
+    }
+    static bool IsGlobalAreaCompiling(){
+        return ( pCompilingUserProc == NULL );
+    }
+    static bool IsLocalAreaCompiling(){
+        return ( pCompilingUserProc != NULL );
+    }
+    static UserProc &CompilingUserProc(){
+        return *pCompilingUserProc;
+    }
+};
+
+class DllProc : public Procedure
+{
+    const string dllFileName;
+    const string alias;
+    int lookupAddress;
+
+public:
+    // ハッシュリスト用
+    DllProc *pNextData;
+
+    DllProc( const string &name, Kind kind, bool isCdecl, const string &dllFileName, const string &alias ):
+      Procedure( name, kind, isCdecl ),
+      dllFileName( dllFileName ),
+      alias( alias ),
+      lookupAddress( 0 ),
+      pNextData( NULL )
+    {
+    }
+    ~DllProc(){}
+
+    virtual bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine );
+
+    const string &GetDllFileName() const
+    {
+        return dllFileName;
+    }
+    const string &GetAlias() const
+    {
+        return alias;
+    }
+
+    void SetLookupAddress( int lookupAddress ){
+        this->lookupAddress = lookupAddress;
+    }
+    int GetLookupAddress() const
+    {
+        return lookupAddress;
+    }
+
+};
+
+class ProcPointer : public Procedure
+{
+public:
+    ProcPointer( Kind kind ):
+      Procedure( "", kind, false )
+    {
+    }
+    ~ProcPointer(){}
+
+    virtual bool SetParamsAndReturnType( const char *sourceOfParams, int nowLine );
+};

BasicCompiler_Common/Resource.cpp

@@ -50 +50 @@
 
         _int64 i64data;
-        int type;
-        type=StaticCalculation(true, temporary,0,&i64data,0);
-        if(IsRealNumberType(type)){
+        Type resultType;
+        if( !StaticCalculation(true, temporary,0,&i64data,resultType) ){
+            return;
+        }
+        if(resultType.IsReal()){
             SetError(9,temporary,0);
             return;

BasicCompiler_Common/Subroutine.cpp

@@ -6 +6 @@
 #include "../BasicCompiler32/opcode.h"
 #endif
-
-//コンパイル中の関数情報
-SubInfo *pCompilingSubInfo;
 
 int GetCallProcName(char *buffer,char *name){
@@ -56 +53 @@
 
     //関数ポインタ
-    int type;
-    LONG_PTR lpIndex;
-    type=GetVarType(name,&lpIndex,0);
-    if(type==DEF_PTR_PROC) return PROC_PTR;
+    Type type;
+    if( !GetVarType( name, type, false ) ){
+        return 0;
+    }
+    if( type.IsProcPtr() ){
+        return PROC_PTR;
+    }
 
     return 0;
@@ -105 +105 @@
 }
 
-
-int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
-    int ret_type;
-
-    if(idProc==PROC_DEFAULT){
+bool CallProc( int kind, const void *pProc, const char *fullCallName, const char *lpszParms, Type &resultType, bool isCallOn ){
+
+    //GetSubHash内でエラー提示が行われた場合
+    if(pProc==(Procedure *)-1){
+        return false;
+    }
+
+    if(kind==PROC_DEFAULT){
         /////////////////////
         // ユーザー定義関数
         /////////////////////
 
-        SubInfo *pSub;
-        pSub=(SubInfo *)pInfo;
-
-        //GetSubHash内でエラー提示が行われた場合
-        if(pSub==(SubInfo *)-1) return -1;
-
+        UserProc *pUserProc = (UserProc *)pProc;
 
         //オブジェクト名を取得
         char ObjectName[VN_SIZE];
         int RefType;
-        SplitObjectName(name,ObjectName,&RefType);
+        SplitObjectName(fullCallName,ObjectName,&RefType);
 
 
@@ -131 +129 @@
         ////////////////////////
 
-        std::vector<SubInfo *> subs;
-        GetOverloadSubHash(name,subs);
+        std::vector<UserProc *> subs;
+        GetOverloadSubHash(fullCallName,subs);
         if(subs.size()){
             //オーバーロードを解決
-            pSub=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
-
-            if(!pSub) return 0;
-        }
-
-
-        Opcode_CallProc(Parameter,pSub,0,ObjectName,RefType);
-        if( plpRetIndex ){
-            *plpRetIndex = pSub->u.ReturnIndex;
-        }
-        return pSub->ReturnType;
-    }
-    else if(idProc==PROC_DLL){
+            pUserProc=OverloadSolutionWithStrParam(fullCallName,subs,lpszParms,ObjectName);
+
+            if(!pUserProc){
+                return false;
+            }
+        }
+
+        resultType = pUserProc->ReturnType();
+
+        if( isCallOn ){
+            if( !Opcode_CallProc(lpszParms,pUserProc,0,ObjectName,RefType) ){
+                return false;
+            }
+        }
+    }
+    else if(kind==PROC_DLL){
         /////////////////////////
         // DLL関数
         /////////////////////////
-        DECLAREINFO *pdi;
-        pdi=(DECLAREINFO *)pInfo;
-
-        ret_type=Opcode_CallDllProc(Parameter,pdi,plpRetIndex);
-    }
-    else if(idProc==PROC_BUILTIN){
+        DllProc *pDllProc = (DllProc *)pProc;
+
+        resultType = pDllProc->ReturnType();
+
+        if( isCallOn ){
+            if( !Opcode_CallDllProc(lpszParms,pDllProc) ){
+                return false;
+            }
+        }
+    }
+    else if(kind==PROC_BUILTIN){
         /////////////////////////
         // 組み込み関数
         /////////////////////////
-        int FuncId;
-        FuncId=(int)(_int64)pInfo;
-
-        TYPEINFO ReturnTypeInfo = { DEF_LONG, NULL };
-        Opcode_CallFunc( Parameter, FuncId, ReturnTypeInfo );
-        if( plpRetIndex ){
-            *plpRetIndex = ReturnTypeInfo.u.lpIndex;
-        }
-        return ReturnTypeInfo.type;
-    }
-    else if(idProc==PROC_PTR){
+        int FuncId = (int)(_int64)pProc;
+
+        if( !Opcode_CallFunc( lpszParms, FuncId, resultType, isCallOn ) ){
+            return false;
+        }
+    }
+    else if(kind==PROC_PTR){
         /////////////////
         // 関数ポインタ
         /////////////////
 
-        LONG_PTR lpIndex;
-        GetVarType(name,&lpIndex,0);
-
-        extern PROCPTRINFO *pProcPtrInfo;
-        ret_type=Opcode_CallProcPtr(name,Parameter,&pProcPtrInfo[lpIndex],plpRetIndex);
-    }
-
-    return ret_type;
-}
-BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
+        Type type;
+        GetVarType(fullCallName,type,false);
+
+        extern ProcPointer **ppProcPointer;
+        ProcPointer *pProcPtr = ppProcPointer[type.GetIndex()];
+        resultType = pProcPtr->ReturnType();
+
+        if( isCallOn ){
+            if( !Opcode_CallProcPtr(fullCallName,lpszParms,pProcPtr) ){
+                return false;
+            }
+        }
+    }
+    else{
+        return false;
+    }
+
+    return true;
+}
+bool CallPropertyMethod( const char *variable, const char *rightSide, Type &resultType){
     //プロパティ用のメソッドを呼び出す
 
@@ -197 +209 @@
 
     //オーバーロード用の関数リストを作成
-    std::vector<SubInfo *> subs;
+    std::vector<UserProc *> subs;
     GetOverloadSubHash(VarName,subs);
     if(subs.size()==0){
-        return 0;
+        return false;
     }
 
     //パラメータを整備
     char *Parameter;
-    Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
+    Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(rightSide)+32);
     lstrcpy(Parameter,ArrayElements);
-    if(RightSide){
-        if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
-        lstrcat(Parameter,RightSide);
+    if(rightSide){
+        if(Parameter[0]&&rightSide[0]) lstrcat(Parameter,",");
+        lstrcat(Parameter,rightSide);
     }
 
     //オーバーロードを解決
-    SubInfo *pSub;
-    pSub=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
-
-    if(pSub){
+    UserProc *pUserProc;
+    pUserProc=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName);
+
+    if(pUserProc){
         //呼び出し
-        Opcode_CallProc(Parameter,pSub,0,ObjectName,RefType);
-
-        if( pRetTypeInfo ){
-            pRetTypeInfo->type = pSub->ReturnType;
-            pRetTypeInfo->u.lpIndex = pSub->u.ReturnIndex;
-        }
+        Opcode_CallProc(Parameter,pUserProc,0,ObjectName,RefType);
+
+        resultType = pUserProc->ReturnType();
     }
 
     HeapDefaultFree(Parameter);
 
-    return 1;
-}
-
-
-int GetReturnTypeOfProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex){
-    int ret_type;
-
-    if(idProc==PROC_DEFAULT){
-        /////////////////////
-        // ユーザー定義関数
-        /////////////////////
-
-        SubInfo *pSub;
-        pSub=(SubInfo *)pInfo;
-
-        //GetSubHash内でエラー提示が行われた場合
-        if(pSub==(SubInfo *)-1) return -1;
-
-
-        //オブジェクト名を取得
-        char ObjectName[VN_SIZE];
-        int RefType;
-        SplitObjectName(name,ObjectName,&RefType);
-
-
-        ////////////////////////
-        // オーバーロードを解決
-        ////////////////////////
-
-        std::vector<SubInfo *> subs;
-        GetOverloadSubHash(name,subs);
-        if( subs.size() > 0 ){
-            //オーバーロードを解決
-            pSub=OverloadSolutionWithStrParam(name,subs,Parameter,ObjectName,NULL);
-
-            if(!pSub) return 0;
-        }
-
-
-        ret_type=pSub->ReturnType;
-        *plpRetIndex=pSub->u.ReturnIndex;
-    }
-    else if(idProc==PROC_DLL){
-        /////////////////////////
-        // DLL関数
-        /////////////////////////
-        DECLAREINFO *pdi;
-        pdi=(DECLAREINFO *)pInfo;
-
-        ret_type=pdi->ReturnType;
-        *plpRetIndex=pdi->u.ReturnIndex;
-    }
-    else if(idProc==PROC_BUILTIN){
-        /////////////////////////
-        // 組み込み関数
-        /////////////////////////
-        int FuncId;
-        FuncId=(int)(_int64)pInfo;
-
-        ret_type=GetFunctionType(FuncId);
-        *plpRetIndex=-1;
-    }
-    else if(idProc==PROC_PTR){
-        /////////////////
-        // 関数ポインタ
-        /////////////////
-
-        LONG_PTR lpIndex;
-        GetVarType(name,&lpIndex,0);
-
-        extern PROCPTRINFO *pProcPtrInfo;
-        ret_type=pProcPtrInfo[lpIndex].ReturnType;
-        *plpRetIndex=pProcPtrInfo[lpIndex].u.ReturnIndex;
-    }
-
-    return ret_type;
-}
-BOOL GetReturnTypeOfPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo){
+    return true;
+}
+
+bool GetReturnTypeOfPropertyMethod( const char *variable, const char *rightSide, Type &resultType ){
     //プロパティ用のメソッドを呼び出す
 
@@ -318 +253 @@
 
     //オーバーロード用の関数リストを作成
-    std::vector<SubInfo *> subs;
+    std::vector<UserProc *> subs;
     GetOverloadSubHash(VarName,subs);
     if(subs.size()==0){
@@ -326 +261 @@
     //パラメータを整備
     char *Parameter;
-    Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(RightSide)+32);
+    Parameter=(char *)HeapAlloc(hHeap,0,lstrlen(ArrayElements)+lstrlen(rightSide)+32);
     lstrcpy(Parameter,ArrayElements);
-    if(RightSide){
-        if(Parameter[0]&&RightSide[0]) lstrcat(Parameter,",");
-        lstrcat(Parameter,RightSide);
+    if(rightSide){
+        if(Parameter[0]&&rightSide[0]) lstrcat(Parameter,",");
+        lstrcat(Parameter,rightSide);
     }
 
     //オーバーロードを解決
-    SubInfo *pSub;
-    pSub=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName,NULL);
-
-    if(pSub){
-        if(pRetTypeInfo){
-            pRetTypeInfo->type=pSub->ReturnType;
-            pRetTypeInfo->u.lpIndex=pSub->u.ReturnIndex;
-        }
+    UserProc *pUserProc;
+    pUserProc=OverloadSolutionWithStrParam(VarName,subs,Parameter,ObjectName);
+
+    if(pUserProc){
+        resultType = pUserProc->ReturnType();
     }
 
@@ -348 +280 @@
 
 //インデクサ（getter）の戻り値を取得
-bool GetReturnTypeOfIndexerGetterProc(CClass *pobj_Class,TYPEINFO &RetTypeInfo){
-    std::vector<SubInfo *> subs;
-    pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
+bool GetReturnTypeOfIndexerGetterProc( const CClass &objClass, Type &resultType ){
+    std::vector<UserProc *> subs;
+    objClass.EnumMethod( CALC_ARRAY_GET, subs );
     if( subs.size() == 0 ){
         return false;
     }
 
-    RetTypeInfo.type = subs[0]->ReturnType;
-    RetTypeInfo.u.lpIndex = subs[0]->u.ReturnIndex;
+    resultType = subs[0]->ReturnType();
 
     return true;
@@ -362 +293 @@
 
 
-void AddDeclareData(char *buffer,int NowLine){
+void AddDeclareData(char *buffer,int nowLine){
     extern HANDLE hHeap;
-    int i,i2,i3,i4,sw,IsFunction;
-    char temporary[VN_SIZE];
-
-    i=0;
-
-    DWORD dwType;
-    BOOL bCdecl=0;
-
-    //Static/Dynamic
-    if(buffer[i]==ESC_STATIC){
-        dwType=DECLARE_STATIC;
-        i++;
-    }
-    else dwType=DECLARE_DYNAMIC;
+    int i2;
+
+    int i=0;
 
     //Sub/Function
-    if(buffer[i]==ESC_SUB) IsFunction=0;
-    else if(buffer[i]==ESC_FUNCTION) IsFunction=1;
+    Procedure::Kind kind = Procedure::Sub;
+    if(buffer[i]==ESC_SUB){
+    }
+    else if(buffer[i]==ESC_FUNCTION){
+        kind = Procedure::Function;
+    }
     else{
-        SetError(1,NULL,NowLine);
+        SetError(1,NULL,nowLine);
         return;
     }
@@ -389 +313 @@
 
     //プロシージャ名
+    char procName[VN_SIZE];
+    bool isCdecl = false;
     for(i2=0;;i++,i2++){
         if(buffer[i]==1&&buffer[i+1]==ESC_CDECL){
-            bCdecl=1;
+            isCdecl = true;
 
             i+=2;
-            temporary[i2]=0;
+            procName[i2]=0;
             break;
         }
         if(buffer[i]==','){
-            temporary[i2]=0;
+            procName[i2]=0;
             break;
         }
         if(buffer[i]=='\0'){
-            SetError(1,NULL,NowLine);
+            SetError(1,NULL,nowLine);
             return;
         }
-        temporary[i2]=buffer[i];
-    }
+        procName[i2]=buffer[i];
+    }
+    i++;
 
     //ユーザー定義関数との重複チェック
-    if(GetSubHash(temporary)){
-        SetError(15,temporary,NowLine);
+    if(GetSubHash(procName)){
+        SetError(15,procName,nowLine);
         return;
     }
 
 
+    //ライブラリ
+    char dllFileName[MAX_PATH];
+    i = GetOneParameter( buffer, i, dllFileName );
+    Type resultType;
+    _int64 i64data;
+    if( !StaticCalculation( true, dllFileName, 0, &i64data, resultType ) ){
+        return;
+    }
+    if( resultType.GetBasicType() != typeOfPtrChar ){
+        SetError(1,NULL,nowLine);
+        return;
+    }
+    lstrcpy( dllFileName, (char *)i64data );
+    CharUpper(dllFileName);
+    if(!strstr(dllFileName,".")){
+        lstrcat(dllFileName,".DLL");
+        if(lstrlen(dllFileName)>=16){
+            SetError(7,NULL,nowLine);
+            return;
+        }
+    }
+
+    //エイリアス
+    char alias[VN_SIZE];
+    i = GetOneParameter( buffer, i, alias );
+    if( alias[0] ){
+        if( !StaticCalculation( true, alias, 0, &i64data, resultType ) ){
+            return;
+        }
+        if( resultType.GetBasicType() != typeOfPtrChar ){
+            SetError(1,NULL,nowLine);
+            return;
+        }
+        lstrcpy( alias, (char *)i64data );
+    }
+    else{
+        //省略されたときは関数名
+        lstrcpy( alias, procName );
+    }
+
+
+    // オブジェクトを生成
+    DllProc *pDllProc = new DllProc( procName, kind, isCdecl, dllFileName, alias );
+
+    // パラメータを解析
+    // ※第1パラメータにに指定するデータの例："( s As String ) As String"
+    pDllProc->SetParamsAndReturnType( buffer + i, nowLine );
+
+    // パラメータのエラーチェック
+    foreach( const Parameter *pParam, pDllProc->Params() ){
+        if( pParam->IsObject() ){
+            SetError(25,pParam->GetVarName(),nowLine);
+        }
+        if( !pParam->IsRef() ){
+            if( pParam->IsStruct() ){
+                SetError(28,pParam->GetVarName(),nowLine);
+            }
+        }
+    }
+
+    //戻り値のエラーチェック
+    if( pDllProc->IsFunction() ){
+        // Function定義
+
+        if( pDllProc->ReturnType().IsObject() ){
+            // DLL関数ではオブジェクトを戻り値にできない
+            SetError(40,pDllProc->GetName(),nowLine);
+        }
+    }
+
+
     /////////////////////////////////
-    // 格納位置を計算してpciにセット
+    // 格納位置を計算してppDeclareHashにセット
     /////////////////////////////////
 
     //ハッシュ値を取得
     int key;
-    key=hash_default(temporary);
-
-    extern DECLAREINFO **ppDeclareHash;
-    DECLAREINFO *pdi;
+    key=hash_default(procName);
+
+    extern DllProc **ppDeclareHash;
     if(ppDeclareHash[key]){
-        pdi=ppDeclareHash[key];
+        DllProc *pTempProc;
+        pTempProc=ppDeclareHash[key];
         while(1){
-            if(lstrcmpi(pdi->name,temporary)==0){
+            if( pDllProc->GetName() == pTempProc->GetName() ){
                 //重複エラー
-                SetError(15,temporary,NowLine);
+                SetError(15,procName,nowLine);
                 return;
             }
 
-            if(pdi->pNextData==0){
-                pdi->pNextData=(DECLAREINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(DECLAREINFO));
+            if(pTempProc->pNextData==0){
+                pTempProc->pNextData=pDllProc;
                 break;
             }
-            pdi=pdi->pNextData;
-        }
-        pdi=pdi->pNextData;
+            pTempProc=pTempProc->pNextData;
+        }
+        pTempProc=pTempProc->pNextData;
     }
     else{
-        ppDeclareHash[key]=(DECLAREINFO *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,sizeof(DECLAREINFO));
-        pdi=ppDeclareHash[key];
-    }
-
-    pdi->dwType=dwType;
-    pdi->bCdecl=bCdecl;
-
-    pdi->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
-    lstrcpy(pdi->name,temporary);
+        ppDeclareHash[key]=pDllProc;
+    }
+}
+
+UserProc *AddSubData(char *buffer,int nowLine,BOOL bVirtual,CClass *pobj_c, bool isStatic){
+    int i2,i3;
+    char temporary[8192];
+
+    int i=1;
+
+    UserProc::Kind kind = Procedure::Sub;
+    bool isMacro = false;
+    if(buffer[i]==ESC_FUNCTION) kind = Procedure::Function;
+    if(buffer[i]==ESC_MACRO){
+        isMacro = true;
+    }
+
     i++;
 
-    //ライブラリ
-    i = GetOneParameter( buffer, i, temporary );
-    int type;
-    LONG_PTR lpIndex;
-    _int64 i64data;
-    type = StaticCalculation( true, temporary, 0, &i64data, &lpIndex );
-    if( type != typeOfPtrChar ){
-        SetError(1,NULL,NowLine);
-        return;
-    }
-    lstrcpy( temporary, (char *)i64data );
-    CharUpper(temporary);
-    if(!strstr(temporary,".")){
-        if(pdi->dwType==DECLARE_STATIC) lstrcat(temporary,".LIB");
-        else{
-            lstrcat(temporary,".DLL");
-            if(lstrlen(temporary)>=16){
-                SetError(7,NULL,NowLine);
-                return;
-            }
-        }
-    }
-    pdi->file=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
-    lstrcpy(pdi->file,temporary);
-
-    //エイリアス
-    i = GetOneParameter( buffer, i, temporary );
-    if( temporary[0] ){
-        type = StaticCalculation( true, temporary, 0, &i64data, &lpIndex );
-        if( type != typeOfPtrChar ){
-            SetError(1,NULL,NowLine);
-            return;
-        }
-        lstrcpy( temporary, (char *)i64data );
-
-        pdi->alias=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
-        lstrcpy(pdi->alias,temporary);
-    }
-    else{
-        //省略されたときは関数名
-        pdi->alias=(char *)HeapAlloc(hHeap,0,lstrlen(pdi->name)+1);
-        lstrcpy(pdi->alias,pdi->name);
-    }
-
-    //パラメータの始めのカッコ
-    if(buffer[i]!='('){
-        SetError(1,NULL,NowLine);
-        return;
-    }
-    i++;
-
-    pdi->pParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,1);
-
-    //各パラメータ
-    for(i3=0;;i3++){
-        if(buffer[i]==')') break;
-
-        pdi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,pdi->pParmInfo,(i3+1)*sizeof(PARAMETER_INFO));
-
-        //ByVal
-        if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
-            pdi->pParmInfo[i3].bByVal=1;
+    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_BYREF){
-            pdi->pParmInfo[i3].bByVal=0;
-            i+=2;
-        }
-        else pdi->pParmInfo[i3].bByVal=1;
-
-        //変数名は無視（temporaryの変数名は型宣言文字判断のため）
-        sw=0;
-        for(i2=0;;i++,i2++){
-            if(buffer[i]=='('){
-                if(!sw) sw=1;
-
-                i4=GetStringInPare(temporary+i2,buffer+i);
-                i2+=i4-1;
-                i+=i4-1;
-                continue;
-            }
-            if(buffer[i]=='['){
-                if(!sw) sw=1;
-
-                i4=GetStringInBracket(temporary+i2,buffer+i);
-                i2+=i4-1;
-                i+=i4-1;
-                continue;
-            }
-            if(!IsVariableChar(buffer[i])){
-                temporary[i2]=0;
-                break;
-            }
-            temporary[i2]=buffer[i];
-        }
-        if(lstrcmp(temporary,"...")==0) pdi->pParmInfo[i3].type=DEF_ELLIPSE;
-        else{
-            //型
-            if(buffer[i]==1&&buffer[i+1]==ESC_AS){
-                i+=2;
-                for(i2=0;;i++,i2++){
-                    if(!(IsVariableChar(buffer[i])||buffer[i]=='*')){
-                        temporary[i2]=0;
-                        break;
-                    }
-                    temporary[i2]=buffer[i];
-                }
-                pdi->pParmInfo[i3].type=GetTypeFixed(temporary,&pdi->pParmInfo[i3].u.index);
-            }
-            else{
-                pdi->pParmInfo[i3].type=GetTypeFromSimpleName(temporary);
-                SetError(-103,temporary,NowLine);
-            }
-
-            if(sw){
-                //配列ポインタを引き渡すとき
-                pdi->pParmInfo[i3].type=GetPtrType(pdi->pParmInfo[i3].type,pdi->pParmInfo[i3].u.index);
-            }
-        }
-
-        //名前はダミー（使用しないため）
-        pdi->pParmInfo[i3].name="";
-
-        //構造体の場合はエラーチェック
-        if(pdi->pParmInfo[i3].type==-1) SetError(3,temporary,NowLine);
-        if(pdi->pParmInfo[i3].type==DEF_OBJECT){
-            if(pdi->pParmInfo[i3].bByVal) pdi->pParmInfo[i3].type=DEF_LONG;//SetError(28,temporary,NowLine);
-        }
-
-        //構造体アドレスの空白部
-        while(buffer[i]==' ') i++;
-
-        if(buffer[i]==','){
-            i++;
-            continue;
-        }
-        else if(buffer[i]==')') continue;
-        else{
-            SetError(1,NULL,NowLine);
-            break;
-        }
-    }
-    pdi->ParmNum=i3;
-
-    //戻り値
-    i++;
-    if(buffer[i]==1&&buffer[i+1]==ESC_AS){
-        if(IsFunction==0) SetError(1,NULL,NowLine);
-        i+=2;
-        pdi->ReturnType=GetTypeFixed(buffer+i,&pdi->u.ReturnIndex);
-        if(pdi->ReturnType==DEF_NON) SetError(3,buffer+i,NowLine);
-        if(pdi->ReturnType==DEF_OBJECT) SetError(40,NULL,NowLine);
-    }
-    else if(buffer[i]) SetError(1,NULL,NowLine);
-    else pdi->ReturnType=DEF_NON;
-
-    pdi->pos=NowLine;
-}
-
-BOOL CompareParameter(PARAMETER_INFO *ppi1,int pi_num1,PARAMETER_INFO *ppi2,int pi_num2){
-    if(pi_num1!=pi_num2) return 1;
-
-    int i;
-    for(i=0;i<pi_num1;i++){
-        if(ppi1[i].type!=ppi2[i].type){
-
-            if(ppi1[i].bByVal==0&&ppi1[i].type==DEF_ANY&&
-                ppi2[i].bByVal==1&&IsPtrType(ppi2[i].type)||
-                ppi1[i].bByVal==1&&IsPtrType(ppi1[i].type)&&
-                ppi2[i].bByVal==0&&ppi2[i].type==DEF_ANY){
-                    /* ByRef var As Any
-                            と
-                        var As VoidPtr
-                        は同等
-                    */
-                    continue;
-            }
-
-            return 1;
-        }
-        else{
-            if(NATURAL_TYPE(ppi1[i].type)==DEF_OBJECT
-                || NATURAL_TYPE(ppi1[i].type)==DEF_STRUCT ){
-                if(ppi1[i].u.index!=ppi2[i].u.index) return 1;
-            }
-        }
-    }
-
-    return 0;
-}
-SubInfo *AddSubData(char *buffer,int NowLine,BOOL bVirtual,CClass *pobj_c,BOOL bStatic){
-    int i,i2,i3,sw;
-    DWORD dwType;
-    char temporary[8192],temp2[VN_SIZE];
-
-    i=1;
-    if(buffer[i]==ESC_SUB) dwType=SUBTYPE_SUB;
-    else if(buffer[i]==ESC_FUNCTION) dwType=SUBTYPE_FUNCTION;
-    else if(buffer[i]==ESC_MACRO) dwType=SUBTYPE_MACRO;
-
-    i++;
-
-    BOOL bExport=0,bCdecl=0;
-    while(1){
-        if(buffer[i]==1&&buffer[i+1]==ESC_EXPORT&&bExport==0){
-            bExport=1;
-
-            i+=2;
-        }
-        else if(buffer[i]==1&&buffer[i+1]==ESC_CDECL&&bCdecl==0){
-            bCdecl=1;
+        else if(buffer[i]==1&&buffer[i+1]==ESC_EXPORT&& isExport == false ){
+            isExport = true;
 
             i+=2;
@@ -674 +479 @@
     if(buffer[i]==1&&buffer[i+1]==ESC_OPERATOR){
         if(!pobj_c){
-            SetError(126,NULL,NowLine);
+            SetError(126,NULL,nowLine);
             return 0;
         }
@@ -708 +513 @@
         }
         if(!iCalcId){
-            SetError(1,NULL,NowLine);
+            SetError(1,NULL,nowLine);
             return 0;
         }
@@ -735 +540 @@
     }
 
-    if(dwType==SUBTYPE_MACRO){
+    if( isMacro ){
         //大文字に変換
         CharUpper(temporary);
@@ -753 +558 @@
 
         if(GetDeclareHash(temporary)){
-            SetError(15,temporary,NowLine);
+            SetError(15,temporary,nowLine);
             return 0;
         }
@@ -761 +566 @@
     SubNum++;
 
-    SubInfo *pSub = new SubInfo();
-
-    //クラス名
-    pSub->pobj_ParentClass=pobj_c;
+
+    UserProc *pUserProc = new UserProc( temporary, kind, isMacro, isCdecl, isExport );
+    pUserProc->SetParentClass( pobj_c );
 
     //ID
     static int id_base=0;
-    pSub->id=(id_base++);
-
-    //関数名
-    pSub->name=(char *)HeapAlloc(hHeap,0,lstrlen(temporary)+1);
-    lstrcpy(pSub->name,temporary);
-
-    //ソースコードの位置
-    pSub->address=NowLine;
-
-    pSub->bExport=bExport;
-    pSub->bCdecl=bCdecl;
-    pSub->bVirtual=bVirtual;
-    if(bExport) pSub->bUse=1;
-    else pSub->bUse=0;
-    pSub->bCompile=0;
-    pSub->bSystem=0;
-
-    pSub->dwType=dwType;
-
-
-    if(pSub->dwType==SUBTYPE_FUNCTION){
-        ///////////////////
-        // 戻り値を取得
-        ///////////////////
-
-        pSub->isReturnRef = false;
-
-        if(pobj_c){
-            if(lstrcmp(pSub->name,pobj_c->name)==0||
-                pSub->name[0]=='~'){
-                //クラスのコンストラクタ、デストラクタがFunction定義の場合はエラーをだす
-                SetError(115,NULL,NowLine);
-            }
-        }
-
-
-        i2=lstrlen(buffer)-2;
-
-        int sw_as=0;
-        for(;i2>0;i2--){
-            if(buffer[i2]==')') break;
-
-            if(buffer[i2]==1&&buffer[i2+1]==ESC_AS){
-                if( buffer[i2-2] == 1 && buffer[i2-1] == ESC_BYREF ){
-                    //参照型
-                    pSub->isReturnRef = true;
-                }
-
-                i2+=2;
-                i3=0;
-                while(buffer[i2]=='*') temporary[i3++]=buffer[i2++];
-                for(;;i2++,i3++){
-                    if(!IsVariableChar(buffer[i2])){
-                        temporary[i3]=0;
-                        break;
-                    }
-                    temporary[i3]=buffer[i2];
-                }
-                pSub->ReturnType=GetTypeFixed(temporary,&pSub->u.ReturnIndex);
-                if(pSub->ReturnType==DEF_NON) SetError(3,temporary,NowLine);
-
-                sw_as=1;
-                break;
-            }
-        }
-
-        if(!sw_as){
-            SetError(-104,pSub->name,NowLine);
-
-            pSub->ReturnType=DEF_DOUBLE;
-        }
-    }
-    else{
-        //戻り値なしのSub定義
-        pSub->ReturnType=DEF_NON;
-        pSub->u.ReturnIndex=-1;
-    }
-
-    //パラメータ
-    if(buffer[i]!='('){
-        SetError(1,NULL,NowLine);
-        return 0;
-    }
-    i++;
-    if(buffer[i]!=')'&&pobj_c){
-        //クラスのメンバ関数の場合のみ、デストラクタにパラメータがある場合にエラーをだす
-        if(pSub->name[0]=='~'){
-            SetError(114,NULL,NowLine);
-            i=JumpStringInPare(buffer,i);
-        }
-    }
-    while(1){
-        if(buffer[i]==')') break;
-
-        //ByRef
-        bool isRef;
-        if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
-            isRef = false;
-            i+=2;
-        }
-        else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
-            isRef = true;
-            i+=2;
-        }
-        else isRef = false;
-
-        //パラメータ名
-        bool isArray = false;
-        int subScripts[MAX_ARRAYDIM];
-        char name[VN_SIZE];
-        sw=0;
-        for(i2=0;;i++,i2++){
-            if(buffer[i]=='('){
-                if(!sw) sw=1;
-
-                i3=GetStringInPare(name+i2,buffer+i);
-                i2+=i3-1;
-                i+=i3-1;
-                continue;
-            }
-            if(buffer[i]=='['){
-                if(!sw) sw=1;
-
-                i3=GetStringInBracket(name+i2,buffer+i);
-                i2+=i3-1;
-                i+=i3-1;
-                continue;
-            }
-            if(!IsVariableChar(buffer[i])){
-                name[i2]=0;
-                break;
-            }
-            name[i2]=buffer[i];
-        }
-        if(sw){
-            //配列パラメータ
-            if( isRef == false ) SetError(29,NULL,NowLine);
-            isArray = true;
-
-            if((name[i2-2]=='('&&name[i2-1]==')')||
-                (name[i2-2]=='['&&name[i2-1]==']')){
-                subScripts[0]=LONG_MAX;
-                subScripts[1]=-1;
-
-                name[i2-2]=0;
-            }
-            else{
-                GetArrange(name,temp2,subScripts);
-                lstrcpy(name,temp2);
-            }
-
-            i2=lstrlen(name);
-        }
-
-        //型
-        Type type( DEF_NON );
-        if(buffer[i]==1&&buffer[i+1]==ESC_AS){
-            i+=2;
-
-            i2=0;
-            while(buffer[i]=='*'){
-                temporary[i2]=buffer[i];
-                i++;
-                i2++;
-            }
-            for(;;i++,i2++){
-                if(!IsVariableChar(buffer[i])){
-                    if(buffer[i]==1&&(buffer[i+1]==ESC_FUNCTION||buffer[i+1]==ESC_SUB)){
-                        temporary[i2++]=buffer[i++];
-                        temporary[i2]=buffer[i];
-                        continue;
-                    }
-                    temporary[i2]=0;
-                    break;
-                }
-                temporary[i2]=buffer[i];
-            }
-
-            Type::StringToType( temporary, type );
-
-            if(temporary[0]=='*'&&
-                temporary[1]==1&&
-                (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
-                if(buffer[i]!='('){
-                    SetError(10,temporary,NowLine);
-                    break;
-                }
-                i3=GetStringInPare(temporary+i2,buffer+i);
-                i+=i3;
-                i2+=i3;
-
-                if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
-                    temporary[i2++]=buffer[i++];
-                    temporary[i2++]=buffer[i++];
-                    for(;;i++,i2++){
-                        if(!IsVariableChar(buffer[i])){
-                            temporary[i2]=0;
-                            break;
-                        }
-                        temporary[i2]=buffer[i];
-                    }
-                }
-            }
-            else{
-                //TypeDefをする前のベース型を取得
-                GetOriginalTypeName(temporary);
-            }
-
-            if( type.IsNull() ){
-                SetError(3,temporary,NowLine);
-                type.SetBasicType( DEF_PTR_VOID );
-            }
-        }
-        else{
-            type.SetBasicType( GetTypeFromSimpleName(temporary) );
-            SetError(-103,temporary,NowLine);
-        }
-
-        if( type.IsProcPtr() ){
-            //関数ポインタの場合
-            type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2]) );
-        }
-
-        Parameter *pParam = new Parameter( name, type, isRef );
-        if( isArray ){
-            pParam->SetArray( subScripts );
-        }
-
-        //パラメータを追加
-        pSub->params.push_back( pParam );
-
-        if(buffer[i]==','){
-            i++;
-            continue;
-        }
-        else if(buffer[i]==')') continue;
-        else{
-            SetError(1,NULL,NowLine);
-            break;
-        }
-    }
-    pSub->SecondParmNum = (int)pSub->params.size();
-    i++;
-    if(buffer[i]=='('){
-        i++;
-        while(1){
-            if(buffer[i]==')') break;
-
-            //ByRef
-            bool isRef;
-            if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
-                isRef = false;
-                i+=2;
-            }
-            else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
-                isRef = true;
-                i+=2;
-            }
-            else isRef = false;
-
-            //パラメータ名
-            bool isArray = false;
-            int subScripts[MAX_ARRAYDIM];
-            char name[VN_SIZE];
-            sw=0;
-            for(i2=0;;i++,i2++){
-                if(buffer[i]=='('){
-                    if(!sw) sw=1;
-
-                    i3=GetStringInPare(name+i2,buffer+i);
-                    i2+=i3-1;
-                    i+=i3-1;
-                    continue;
-                }
-                if(buffer[i]=='['){
-                    if(!sw) sw=1;
-
-                    i3=GetStringInBracket(name+i2,buffer+i);
-                    i2+=i3-1;
-                    i+=i3-1;
-                    continue;
-                }
-                if(!IsVariableChar(buffer[i])){
-                    name[i2]=0;
-                    break;
-                }
-                name[i2]=buffer[i];
-            }
-            if(sw){
-                //配列パラメータ
-                if( isRef == false ) SetError(29,NULL,NowLine);
-                isArray = true;
-
-                if((name[i2-2]=='('&&name[i2-1]==')')||
-                    (name[i2-2]=='['&&name[i2-1]==']')){
-                    subScripts[0]=LONG_MAX;
-                    subScripts[1]=-1;
-
-                    name[i2-2]=0;
-                }
-                else{
-                    GetArrange(name,temp2,subScripts);
-                    lstrcpy(name,temp2);
-                }
-
-                i2=lstrlen(name);
-            }
-
-            //型
-            Type type( DEF_NON );
-            if(buffer[i]==1&&buffer[i+1]==ESC_AS){
-                i+=2;
-
-                i2=0;
-                while(buffer[i]=='*'){
-                    temporary[i2]=buffer[i];
-                    i++;
-                    i2++;
-                }
-                for(;;i++,i2++){
-                    if(!IsVariableChar(buffer[i])){
-                        if(buffer[i]==1&&(buffer[i+1]==ESC_FUNCTION||buffer[i+1]==ESC_SUB)){
-                            temporary[i2++]=buffer[i++];
-                            temporary[i2]=buffer[i];
-                            continue;
-                        }
-                        temporary[i2]=0;
-                        break;
-                    }
-                    temporary[i2]=buffer[i];
-                }
-
-                Type::StringToType( temporary, type );
-
-                if(temporary[0]=='*'&&
-                    temporary[1]==1&&
-                    (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
-                    if(buffer[i]!='('){
-                        SetError(10,temporary,NowLine);
-                        break;
-                    }
-                    i3=GetStringInPare(temporary+i2,buffer+i);
-                    i+=i3;
-                    i2+=i3;
-
-                    if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
-                        temporary[i2++]=buffer[i++];
-                        temporary[i2++]=buffer[i++];
-                        for(;;i++,i2++){
-                            if(!IsVariableChar(buffer[i])){
-                                temporary[i2]=0;
-                                break;
-                            }
-                            temporary[i2]=buffer[i];
-                        }
-                    }
-                }
-                else{
-                    //TypeDefをする前のベース型を取得
-                    GetOriginalTypeName(temporary);
-                }
-
-                if( type.IsNull() ){
-                    SetError(3,temporary,NowLine);
-                    type.SetBasicType( DEF_PTR_VOID );
-                }
-            }
-            else{
-                type.SetBasicType( GetTypeFromSimpleName(temporary) );
-                SetError(-103,temporary,NowLine);
-            }
-
-            if( type.IsProcPtr() ){
-                //関数ポインタの場合
-                type.SetIndex( AddProcPtrInfo(temporary+3,temporary[2]) );
-            }
-
-            Parameter *pParam = new Parameter( name, type, isRef );
-            if( isArray ){
-                pParam->SetArray( subScripts );
-            }
-
-            //パラメータを追加
-            pSub->params.push_back( pParam );
-
-            if(buffer[i]==','){
-                i++;
-                continue;
-            }
-            else if(buffer[i]==')') continue;
-            else{
-                SetError(1,NULL,NowLine);
-                break;
-            }
-        }
-        i++;
-    }
-
-    //リアルパラメータ領域を取得（_System_LocalThisを考慮して2つだけ多く確保する場合がある）
-
-    if(pobj_c&&bStatic==0){
-        //オブジェクトメンバの場合は、第一パラメータを_System_LocalThis引き渡し用として利用
-        string name = "_System_LocalThis";
-        Type type( DEF_PTR_VOID );
-        pSub->realParams.push_back( new Parameter( name, type ) );
-    }
-
-    if(pSub->ReturnType==DEF_STRUCT){
-        //構造体を戻り値として持つ場合
-        //※第一パラメータ（Thisポインタありの場合は第二パラメータ）を戻り値用の参照宣言にする
-
-        string name = pSub->name;
-        if(pSub->name[0]==1&&pSub->name[1]==ESC_OPERATOR){
-            name="_System_ReturnValue";
-        }
-        Type type( DEF_STRUCT, pSub->u.ReturnIndex );
-        pSub->realParams.push_back( new Parameter( name, type, true ) );
-    }
-
-    //パラメータをコピー
-    foreach( Parameter *pParam, pSub->params ){
-        pSub->realParams.push_back( new Parameter( *pParam ) );
-    }
+    pUserProc->id = (id_base++);
+
+    if(isExport){
+        pUserProc->Using();
+    }
+
+    // パラメータを解析
+    // ※第1パラメータにに指定するデータの例："( s As String ) As String"
+    pUserProc->SetParamsAndReturnType( buffer + i, nowLine, isStatic );
 
 
@@ -1198 +588 @@
 
     int key;
-    key=hash_default(pSub->name);
-
-    extern SubInfo **ppSubHash;
+    key=hash_default(pUserProc->GetName().c_str());
+
+    extern UserProc **ppSubHash;
     if(ppSubHash[key]){
-        SubInfo *psi2;
+        UserProc *psi2;
         psi2=ppSubHash[key];
         while(1){
-            if(pobj_c==psi2->pobj_ParentClass){
+            if(pobj_c==psi2->GetParentClassPtr()){
                 //重複エラーチェックを行う
-                if(lstrcmp(psi2->name,pSub->name)==0){
-                    if( Parameter::Equals( psi2->params, pSub->params ) ){
-                        SetError(15,pSub->name,NowLine);
+                if( pUserProc->GetName() == psi2->GetName() ){
+                    if( Parameter::Equals( psi2->Params(), pUserProc->Params() ) ){
+                        SetError(15,pUserProc->GetName().c_str(),nowLine);
                         return 0;
                     }
@@ -1218 +608 @@
             psi2=psi2->pNextData;
         }
-        psi2->pNextData=pSub;
+        psi2->pNextData=pUserProc;
     }
     else{
-        ppSubHash[key]=pSub;
-    }
-
-    return pSub;
+        ppSubHash[key]=pUserProc;
+    }
+
+    return pUserProc;
 }
 
@@ -1234 +624 @@
 
     //Declare（DLL関数）情報を初期化
-    extern DECLAREINFO **ppDeclareHash;
-    ppDeclareHash=(DECLAREINFO **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(DECLAREINFO *));
+    extern DllProc **ppDeclareHash;
+    ppDeclareHash=(DllProc **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(DllProc *));
 
     //サブルーチン（ユーザー定義）情報を初期化
-    extern SubInfo **ppSubHash;
+    extern UserProc **ppSubHash;
     extern int SubNum;
-    ppSubHash=(SubInfo **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(SubInfo *));
+    ppSubHash=(UserProc **)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,MAX_HASH*sizeof(UserProc *));
     SubNum=0;
 
@@ -1334 +724 @@
     AddSubData(temporary,0,0,0);
 }
-void Delete_si(SubInfo *pSub){
-    foreach( Parameter *pParam, pSub->params ){
-        delete pParam;
-    }
-
-    foreach( Parameter *pParam, pSub->realParams ){
-        delete pParam;
-    }
-
-    if(pSub->pNextData) Delete_si(pSub->pNextData);
-
-    HeapDefaultFree(pSub->name);
-    delete pSub;
-}
-void DeleteSubInfo(SubInfo **ppSubHash,char **ppMacroNames,int MacroNum){   //サブルーチン情報のメモリ解放
+void Delete_si(UserProc *pUserProc){
+    if(pUserProc->pNextData) Delete_si(pUserProc->pNextData);
+    delete pUserProc;
+}
+void DeleteSubInfo(UserProc **ppSubHash,char **ppMacroNames,int MacroNum){  //サブルーチン情報のメモリ解放
     int i;
     for(i=0;i<MAX_HASH;i++){
@@ -1365 +745 @@
     }
 }
-void Delete_di(DECLAREINFO *pdi){
-    if(pdi->pParmInfo) HeapDefaultFree(pdi->pParmInfo);
-
-    HeapDefaultFree(pdi->name);
-    if(pdi->file) HeapDefaultFree(pdi->file);
-    if(pdi->alias) HeapDefaultFree(pdi->alias);
-
-    if(pdi->pNextData) Delete_di(pdi->pNextData);
-
-    HeapDefaultFree(pdi);
+void Delete_di(DllProc *pDllProc){
+    if(pDllProc->pNextData) Delete_di(pDllProc->pNextData);
+
+    delete pDllProc;
 }
 void DeleteDeclareInfo(void){
     //DLL情報を解放
-    extern DECLAREINFO **ppDeclareHash;
+    extern DllProc **ppDeclareHash;
     int i;
     for(i=0;i<MAX_HASH;i++){
@@ -1394 +768 @@
 ///////////////////////
 
-int AddProcPtrInfo(char *buffer,DWORD dwProcType){
-    extern HANDLE hHeap;
-    extern int cp;
-    extern PROCPTRINFO *pProcPtrInfo;
+int AddProcPtrInfo( char *buffer, DWORD dwProcType, int nowLine ){
+
+    Procedure::Kind kind = Procedure::Sub;
+    if( dwProcType == ESC_FUNCTION ){
+        kind = Procedure::Function;
+    }
+
+    ProcPointer *pProcPointer = new ProcPointer( kind );
+
+    //buffer[0]は'('となっている
+    pProcPointer->SetParamsAndReturnType( buffer, nowLine );
+
+    extern ProcPointer **ppProcPointer;
     extern int ProcPtrInfoNum;
-    int i,i2,i3,sw;
-    PROCPTRINFO *pi;
-    char temporary[VN_SIZE],temp2[VN_SIZE];
-
-    pProcPtrInfo=(PROCPTRINFO *)HeapReAlloc(hHeap,0,pProcPtrInfo,(ProcPtrInfoNum+1)*sizeof(PROCPTRINFO));
-    pi=&pProcPtrInfo[ProcPtrInfoNum];
+    ppProcPointer=(ProcPointer **)HeapReAlloc(hHeap,0,ppProcPointer,(ProcPtrInfoNum+1)*sizeof(ProcPointer *));
+    ppProcPointer[ProcPtrInfoNum] = pProcPointer;
     ProcPtrInfoNum++;
 
-    pi->pParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,1);
-    pi->ParmNum=0;
-
-    //buffer[0]は'('となっている
-    i=1;
-
-    while(1){
-        if(buffer[i]==')') break;
-
-        pi->pParmInfo=(PARAMETER_INFO *)HeapReAlloc(hHeap,0,pi->pParmInfo,(pi->ParmNum+1)*sizeof(PARAMETER_INFO));
-
-        //ByVal
-        if(buffer[i]==1&&buffer[i+1]==ESC_BYVAL){
-            pi->pParmInfo[pi->ParmNum].bByVal=1;
-            i+=2;
-        }
-        else if(buffer[i]==1&&buffer[i+1]==ESC_BYREF){
-            pi->pParmInfo[pi->ParmNum].bByVal=0;
-            i+=2;
-        }
-        else pi->pParmInfo[pi->ParmNum].bByVal=1;
-
-        //パラメータ名
-        sw=0;
-        for(i2=0;;i++,i2++){
-            if(buffer[i]=='('){
-                if(!sw) sw=1;
-
-                i3=GetStringInPare(temporary+i2,buffer+i);
-                i2+=i3-1;
-                i+=i3-1;
-                continue;
-            }
-            if(buffer[i]=='['){
-                if(!sw) sw=1;
-
-                i3=GetStringInBracket(temporary+i2,buffer+i);
-                i2+=i3-1;
-                i+=i3-1;
-                continue;
-            }
-            if(!IsVariableChar(buffer[i])){
-                temporary[i2]=0;
-                break;
-            }
-            temporary[i2]=buffer[i];
-        }
-        pi->pParmInfo[pi->ParmNum].name=0;
-
-        if(sw){
-            //配列パラメータ
-            if(pi->pParmInfo[pi->ParmNum].bByVal) SetError(29,NULL,cp);
-            pi->pParmInfo[pi->ParmNum].bArray=1;
-
-            if((temporary[i2-2]=='('&&temporary[i2-1]==')')||
-                (temporary[i2-2]=='['&&temporary[i2-1]==']')){
-                pi->pParmInfo[pi->ParmNum].SubScripts[0]=LONG_MAX;
-                pi->pParmInfo[pi->ParmNum].SubScripts[1]=-1;
-
-                temporary[i2-2]=0;
-            }
-            else{
-                GetArrange(temporary,temp2,pi->pParmInfo[pi->ParmNum].SubScripts);
-                lstrcpy(temporary,temp2);
-            }
-
-            i2=lstrlen(temporary);
-        }
-        else{
-            pi->pParmInfo[pi->ParmNum].bArray=0;
-            pi->pParmInfo[pi->ParmNum].SubScripts[0]=-1;
-        }
-
-        //型
-        if(buffer[i]==1&&buffer[i+1]==ESC_AS){
-            i+=2;
-
-            i2=0;
-            while(buffer[i]=='*'){
-                temporary[i2]=buffer[i];
-                i++;
-                i2++;
-            }
-            for(;;i++,i2++){
-                if(!IsVariableChar(buffer[i])){
-                    temporary[i2]=0;
-                    break;
-                }
-                temporary[i2]=buffer[i];
-            }
-
-            pi->pParmInfo[pi->ParmNum].type=
-                GetTypeFixed(temporary,&pi->pParmInfo[pi->ParmNum].u.index);
-            if(pi->pParmInfo[pi->ParmNum].type==-1){
-                SetError(3,temporary,cp);
-                pi->pParmInfo[pi->ParmNum].type=DEF_PTR_VOID;
-            }
-            if(pi->pParmInfo[pi->ParmNum].type==DEF_OBJECT){
-                if(pi->pParmInfo[pi->ParmNum].bByVal) SetError(28,temporary,cp);
-            }
-        }
-        else{
-            pi->pParmInfo[pi->ParmNum].type=GetTypeFromSimpleName(temporary);
-            SetError(-103,temporary,cp);
-        }
-
-        pi->ParmNum++;
-
-        if(buffer[i]==','){
-            i++;
-            continue;
-        }
-        else if(buffer[i]==')') continue;
-        else{
-            SetError(1,NULL,cp);
-            return 0;
-        }
-    }
-    i++;
-
-    //戻り値
-    if(dwProcType==ESC_FUNCTION){
-        if(buffer[i]==1&&buffer[i+1]==ESC_AS){
-            i+=2;
-            i2=0;
-            if(buffer[i]=='*') temporary[i2++]=buffer[i++];
-            for(;;i++,i2++){
-                if(!IsVariableChar(buffer[i])){
-                    temporary[i2]=0;
-                    break;
-                }
-                temporary[i2]=buffer[i];
-            }
-            pi->ReturnType=GetTypeFixed(temporary,&pi->u.ReturnIndex);
-            if(pi->ReturnType==DEF_NON) SetError(3,temporary,cp);
-        }
-        else pi->ReturnType=DEF_DOUBLE;
-    }
-    else pi->ReturnType=DEF_NON;
-
     return ProcPtrInfoNum-1;
 }
 void DeleteProcPtrInfo(void){
-    extern PROCPTRINFO *pProcPtrInfo;
+    extern ProcPointer **ppProcPointer;
     extern int ProcPtrInfoNum;
-    int i;
-
-    for(i=0;i<ProcPtrInfoNum;i++){
-        HeapDefaultFree(pProcPtrInfo[i].pParmInfo);
-    }
-
-    HeapDefaultFree(pProcPtrInfo);
-}
+
+    for(int i=0;i<ProcPtrInfoNum;i++){
+        delete ppProcPointer[i];
+    }
+
+    HeapDefaultFree(ppProcPointer);
+}

BasicCompiler_Common/Type.cpp

@@ -65 +65 @@
                 //関数ポインタ（*Function）
                 type.basicType = DEF_PTR_PROC;
+                return true;
         }
 
@@ -109 +110 @@
 }
 
+int Type::GetBasicSize( int basicType )
+{
+
+    // 基本型
+    switch( basicType ){
+        case DEF_SBYTE:
+        case DEF_BYTE:
+        case DEF_BOOLEAN:
+            return sizeof(BYTE);
+
+        case DEF_INTEGER:
+        case DEF_WORD:
+            return sizeof(WORD);
+
+        case DEF_LONG:
+        case DEF_DWORD:
+            return sizeof(DWORD);
+
+        case DEF_INT64:
+        case DEF_QWORD:
+            return sizeof(_int64);
+
+        case DEF_DOUBLE:
+            return sizeof(double);
+        case DEF_SINGLE:
+            return sizeof(float);
+    }
+
+    // ポインタ
+    if(IsPtrType(basicType)){
+        return PTR_SIZE;
+    }
+
+    // オブジェクト
+    if(basicType==DEF_OBJECT){
+        return PTR_SIZE;
+    }
+
+    SetError();
+    return 0;
+}
+
 
 bool Type::Equals( const Type &type ) const
@@ -128 +171 @@
 }
 
+int Type::GetBasicSize() const
+{
+    GetBasicSize( basicType );
+    return 0;
+}
+int Type::GetSize() const
+{
+
+    // 基本型
+    switch( basicType ){
+        case DEF_LONG:
+            if(index==LITERAL_NULL||index==LITERAL_M128_0||index==LITERAL_0_255){
+                return sizeof(BYTE);
+            }
+            else if(index==LITERAL_M32768_0||index==LITERAL_0_65535){
+                return sizeof(WORD);
+            }
+            return sizeof(DWORD);
+
+        case DEF_SBYTE:
+        case DEF_BYTE:
+        case DEF_BOOLEAN:
+            return sizeof(BYTE);
+
+        case DEF_INTEGER:
+        case DEF_WORD:
+            return sizeof(WORD);
+
+        case DEF_DWORD:
+            return sizeof(DWORD);
+
+        case DEF_INT64:
+        case DEF_QWORD:
+            return sizeof(_int64);
+
+        case DEF_DOUBLE:
+            return sizeof(double);
+        case DEF_SINGLE:
+            return sizeof(float);
+    }
+
+    // ポインタ
+    if(IsPtrType(basicType)){
+        return PTR_SIZE;
+    }
+
+    // 構造体
+    if( basicType == DEF_STRUCT ){
+        if( !pClass ){
+            SetError();
+            return 0;
+        }
+
+        return pClass->GetSize();
+    }
+
+    // オブジェクト
+    if(basicType==DEF_OBJECT){
+        return PTR_SIZE;
+    }
+
+    SetError();
+    return 0;
+}
+
 bool Type::IsNull() const{
   if( basicType == DEF_NON ){
@@ -134 +242 @@
   return false;
 }
+
+bool Type::IsByte() const{
+  if( basicType == DEF_BYTE ){
+      return true;
+  }
+  return false;
+}
+bool Type::IsSByte() const{
+  if( basicType == DEF_SBYTE ){
+      return true;
+  }
+  return false;
+}
+bool Type::IsWord() const{
+  if( basicType == DEF_WORD ){
+      return true;
+  }
+  return false;
+}
+bool Type::IsInteger() const{
+  if( basicType == DEF_INTEGER ){
+      return true;
+  }
+  return false;
+}
+bool Type::IsDWord() const{
+  if( basicType == DEF_DWORD ){
+      return true;
+  }
+  return false;
+}
+bool Type::IsLong() const{
+  if( basicType == DEF_LONG ){
+      return true;
+  }
+  return false;
+}
+bool Type::IsQWord() const{
+  if( basicType == DEF_QWORD ){
+      return true;
+  }
+  return false;
+}
+bool Type::IsInt64() const{
+  if( basicType == DEF_INT64 ){
+      return true;
+  }
+  return false;
+}
+bool Type::IsSingle() const{
+  if( basicType == DEF_SINGLE ){
+      return true;
+  }
+  return false;
+}
+bool Type::IsDouble() const{
+  if( basicType == DEF_DOUBLE ){
+      return true;
+  }
+  return false;
+}
+bool Type::IsBoolean() const{
+  if( basicType == DEF_BOOLEAN ){
+      return true;
+  }
+  return false;
+}
+
 bool Type::IsPointer() const
 {
@@ -219 +395 @@
     return false;
 }
+bool Type::IsStructPtr() const
+{
+    if( basicType == DEF_PTR_STRUCT ){
+        return true;
+    }
+    return false;
+}
+bool Type::IsObject() const
+{
+    if( basicType == DEF_OBJECT ){
+        return true;
+    }
+    return false;
+}
+bool Type::IsObjectPtr() const
+{
+    if( basicType == DEF_PTR_OBJECT ){
+        return true;
+    }
+    return false;
+}
+bool Type::IsStringObject() const
+{
+    if( basicType == DEF_OBJECT ){
+        if( lstrcmp( pClass->name,"String")==0){
+            return true;
+        }
+    }
+    return false;
+}
+bool Type::IsVoidPtr() const
+{
+    if( basicType == DEF_PTR_VOID ){
+        return true;
+    }
+    return false;
+}
+
+bool Type::IsAny() const
+{
+    if( basicType == DEF_ANY ){
+        return true;
+    }
+    return false;
+}
+
+const string Type::ToString() const
+{
+    if( PTR_LEVEL( basicType ) ){
+        //ポインタレベルが1以上の場合
+        Type type( *this );
+        type.PtrLevelDown();
+
+        return (string)"*" + type.ToString();
+    }
+    else if( IsObject() || IsStruct() ){
+        //オブジェクトまたは構造体
+
+        if( !( index == 0 || index == -1 ) ){
+            return pClass->name;
+        }
+    }
+    else if( IsProcPtr() ){
+        if( index == 0 || index == -1 ){
+            return "VoidPtr";
+        }
+        else{
+            extern ProcPointer **ppProcPointer;
+            if( ppProcPointer[index]->ReturnType().IsNull() ){
+                return "*Sub";
+            }
+            return "*Function";
+        }
+    }
+    else{
+        // 基本型
+
+        for( int i=0; ; i++ ){
+            if( basicTypeList[i] == DEF_NON ){
+                break;
+            }
+            if( basicTypeList[i] == basicType ){
+                return basicTypeNameList[i];
+            }
+        }
+    }
+
+    extern int cp;
+    SetError(1,NULL,cp);
+
+    return (string)"(null)";
+}

BasicCompiler_Common/Type.h

@@ +1 @@
+#pragma once
 
-#ifndef _ACTIVEBASIC_COMPILER_TYPE_H
-#define _ACTIVEBASIC_COMPILER_TYPE_H
+class CClass;
 
 class Type{
@@ -18 +18 @@
     static bool StringToBasicType( const string &typeName, int &basicType );
     static bool StringToType( const string &typeName, Type &type );
+    static int GetBasicSize( int basicType );
 
     Type():
@@ -30 +31 @@
       index( index ){}
 
-    Type( int basicType, CClass &objClass ):
+    Type( int basicType, const CClass &objClass ):
       basicType( basicType ),
       index( (LONG_PTR)&objClass ){}
@@ -38 +39 @@
       index( type.index ){}
 
-    int GetBasicType() const
+    __inline int GetBasicType() const
     {
-#ifdef _DEBUG
-        if( basicType<-10000 ){
-            DebugBreak();
-        }
-#endif
         return basicType;
     }
@@ -64 +60 @@
     void SetNull(){
         SetBasicType( DEF_NON );
+        SetIndex( -1 );
     }
     void SetType( int basicType, LONG_PTR index ){
@@ -74 +71 @@
     }
 
+    int PtrLevel() const
+    {
+        return PTR_LEVEL( basicType );
+    }
     void PtrLevelUp(){
         PTR_LEVEL_UP( basicType );
+    }
+    void PtrLevelDown(){
+        PTR_LEVEL_DOWN( basicType );
     }
 
     bool Equals( const Type &type ) const;
 
+    int GetBasicSize() const;
+    int GetSize() const;
+
     bool IsNull() const;
+
+    bool IsByte() const;
+    bool IsSByte() const;
+    bool IsWord() const;
+    bool IsInteger() const;
+    bool IsDWord() const;
+    bool IsLong() const;
+    bool IsQWord() const;
+    bool IsInt64() const;
+    bool IsSingle() const;
+    bool IsDouble() const;
+    bool IsBoolean() const;
+
     bool IsPointer() const;
     bool IsSigned() const;
@@ -89 +109 @@
     bool IsProcPtr() const;
     bool IsStruct() const;
+    bool IsStructPtr() const;
+    bool IsObject() const;
+    bool IsObjectPtr() const;
+    bool IsStringObject() const;
+    bool IsVoidPtr() const;
+    bool IsAny() const;
 
+    const string ToString() const;
+
+    void operator= ( const Type &type ){
+        basicType = type.basicType;
+        index = type.index;
+    }
 };
-
-#endif //_ACTIVEBASIC_COMPILER_TYPE_H

BasicCompiler_Common/Variable.cpp

@@ -1 @@
-#include "../BasicCompiler_Common/common.h"
-
-#ifdef _AMD64_
-#include "../BasicCompiler64/opcode.h"
-#else
-#include "../BasicCompiler32/opcode.h"
-#endif
-
-BOOL IsVariableTopChar(char c){
-    if((c>='A'&&c<='Z')||(c>='a'&&c<='z')||c=='_') return 1;
-    return 0;
-}
-BOOL IsVariableChar(char c){
-    if((c>='A'&&c<='Z')||(c>='a'&&c<='z')||(c>='0'&&c<='9')||
-        c=='%'||c=='!'||c=='#'||c=='$'||
-        c=='_'||c=='.') return 1;
-    return 0;
-}
-BOOL IsPtrType(int type){
-    if(type==-1) return 0;
-
-    if(PTR_LEVEL(type)||type==DEF_PTR_VOID||type==DEF_PTR_PROC||
-        (type&FLAG_PTR) ) return 1;
-
-    return 0;
-}
-BOOL IsSignedType(int type){
-    switch(type){
-        case DEF_SBYTE:
-        case DEF_INTEGER:
-        case DEF_LONG:
-        case DEF_INT64:
-        case DEF_SINGLE:
-        case DEF_DOUBLE:
-        case DEF_CHAR:
-            return 1;
-        default:
-            break;
-    }
-    return 0;
-}
-BOOL IsNaturalWholeNumberType(int type){
-    switch(type){
-        case DEF_SBYTE:
-        case DEF_BYTE:
-        case DEF_INTEGER:
-        case DEF_WORD:
-        case DEF_LONG:
-        case DEF_DWORD:
-        case DEF_INT64:
-        case DEF_QWORD:
-        case DEF_CHAR:
-            return 1;
-        default:
-            break;
-    }
-    return 0;
-}
-BOOL IsWholeNumberType(int type){
-    return (
-        IsNaturalWholeNumberType(type)
-        || IsPtrType(type)
-        || type == DEF_BOOLEAN
-        );
-}
-BOOL IsRealNumberType(int type){
-    switch(type){
-        case DEF_DOUBLE:
-        case DEF_SINGLE:
-            return 1;
-        default:
-            break;
-    }
-    return 0;
-}
-BOOL Is64Type(int type){
-    switch(type){
-        case DEF_INT64:
-        case DEF_QWORD:
-            return 1;
-        default:
-            break;
-    }
-#ifdef _AMD64_
-    return IsPtrType(type);
-#else
-    return 0;
-#endif
-}
-int GetSignedType(int type){
-    switch(type){
-        case DEF_BYTE:
-            return DEF_SBYTE;
-        case DEF_WORD:
-            return DEF_INTEGER;
-        case DEF_DWORD:
-            return DEF_LONG;
-        case DEF_QWORD:
-            return DEF_INT64;
-        default:
-            break;
-    }
-#ifdef _AMD64_
-    if(IsPtrType(type)) return DEF_INT64;
-#else
-    if(IsPtrType(type)) return DEF_LONG;
-#endif
-    return type;
-}
-int GetUnsignedType(int type){
-    switch(type){
-        case DEF_SBYTE:
-            return DEF_BYTE;
-        case DEF_INTEGER:
-            return DEF_WORD;
-        case DEF_LONG:
-            return DEF_DWORD;
-        case DEF_INT64:
-            return DEF_QWORD;
-        case DEF_CHAR:
-            if( isUnicode ) return DEF_WORD;
-            return DEF_BYTE;
-    }
-    return type;
-}
-int GetTypeSize(int type,LONG_PTR lpIndex){
-    if(type==DEF_LONG){
-        if(lpIndex==LITERAL_NULL||lpIndex==LITERAL_M128_0||lpIndex==LITERAL_0_255)
-            return sizeof(BYTE);
-        else if(lpIndex==LITERAL_M32768_0||lpIndex==LITERAL_0_65535)
-            return sizeof(WORD);
-
-        return sizeof(DWORD);
-    }
-
-    //整数型
-    if(type==DEF_INT64||type==DEF_QWORD)
-        return sizeof(_int64);
-    else if(type==DEF_LONG||type==DEF_DWORD)
-        return sizeof(DWORD);
-    else if(type==DEF_INTEGER||type==DEF_WORD)
-        return sizeof(WORD);
-    else if(type==DEF_SBYTE||type==DEF_BYTE || type == DEF_BOOLEAN)
-        return sizeof(BYTE);
-
-    //実数型
-    else if(type==DEF_DOUBLE)       return sizeof(double);
-    else if(type==DEF_SINGLE)       return sizeof(float);
-
-    //文字型
-    else if( type == DEF_CHAR ){
-        if( isUnicode ) return sizeof( WORD );
-        return sizeof( BYTE );
-    }
-
-    //ポインタ型
-    else if(IsPtrType(type))        return PTR_SIZE;
-
-    else if( type == DEF_STRUCT ){
-        CClass *pobj_c;
-        pobj_c=(CClass *)lpIndex;
-        if(!pobj_c){
-            SetError(300,NULL,cp);
-            return 0;
-        }
-
-        return pobj_c->GetSize();
-    }
-
-    else if(type==DEF_OBJECT){
-        return PTR_SIZE;
-    }
-    else{
-        SetError(300,NULL,cp);
-    }
-    return 0;
-}
-int GetPtrType(int type,LONG_PTR lpIndex){
-    return MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)+1);
-}
-int GetTypeFixed(const char *TypeName,LONG_PTR *lpNum){
-    int type;
-
-    if(lpNum) *lpNum=-1;
-
-    if(TypeName[0]=='*'){
-        if(TypeName[1]==1&&(TypeName[2]==ESC_FUNCTION||TypeName[2]==ESC_SUB)){
-            //関数ポインタ（*Function）
-            return DEF_PTR_PROC;
-        }
-
-        type=GetTypeFixed(TypeName+1,lpNum);
-        if(type==-1) return -1;
-
-        return GetPtrType(type,*lpNum);
-    }
-
-    //整数型
-    if(lstrcmpi(TypeName,"SByte")==0)           return DEF_SBYTE;
-    else if(lstrcmpi(TypeName,"Byte")==0)       return DEF_BYTE;
-    else if(lstrcmpi(TypeName,"Integer")==0)    return DEF_INTEGER;
-    else if(lstrcmpi(TypeName,"WORD")==0)       return DEF_WORD;
-    else if(lstrcmpi(TypeName,"Long")==0)       return DEF_LONG;
-    else if(lstrcmpi(TypeName,"DWORD")==0)      return DEF_DWORD;
-    else if(lstrcmpi(TypeName,"Int64")==0)      return DEF_INT64;
-    else if(lstrcmpi(TypeName,"QWORD")==0)      return DEF_QWORD;
-
-    //実数型
-    else if(lstrcmpi(TypeName,"Single")==0)     return DEF_SINGLE;
-    else if(lstrcmpi(TypeName,"Double")==0)     return DEF_DOUBLE;
-
-    //文字型
-    //else if( lstrcmpi( TypeName, "Char" ) == 0 ) return DEF_CHAR;
-
-    //bool型
-    else if( lstrcmpi( TypeName, "Boolean" ) == 0 ) return DEF_BOOLEAN;
-
-    //ポインタ型
-    //※VoidPtr型以外のポインタ型はTypeDef宣言により定義される
-    else if(lstrcmpi(TypeName,"VoidPtr")==0)    return DEF_PTR_VOID;
-
-    //その他
-    else if(lstrcmpi(TypeName,"Any")==0)        return DEF_ANY;
-
-
-    ////////////////////
-    // TypeDefされた型
-    ////////////////////
-    int i;
-    i=pobj_DBTypeDef->check(TypeName);
-    if(i!=-1){
-        return GetTypeFixed(pobj_DBTypeDef->ppobj_TypeDef[i]->lpszBaseName,lpNum);
-    }
-
-    if(!lpNum) return -1;
-
-    //クラス
-    CClass *pobj_c;
-    pobj_c=pobj_DBClass->check(TypeName);
-    if(pobj_c){
-        *lpNum=(LONG_PTR)pobj_c;
-
-        if( pobj_c->IsStructure() ){
-            return DEF_STRUCT;
-        }
-        else{
-            return DEF_OBJECT;
-        }
-    }
-
-    return -1;
-}
-void GetOriginalTypeName(char *buffer){
-    // TypeDefされた型に対して、オリジナルの型の名前に変更する
-
-    if(buffer[0]=='*'){
-        if(buffer[1]==1&&(buffer[2]==ESC_FUNCTION||buffer[2]==ESC_SUB)) return;
-
-        GetOriginalTypeName(buffer+1);
-        return;
-    }
-
-    int i;
-    i=pobj_DBTypeDef->check(buffer);
-    if(i!=-1){
-        lstrcpy(buffer,pobj_DBTypeDef->ppobj_TypeDef[i]->lpszBaseName);
-        GetOriginalTypeName(buffer);
-    }
-}
-BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name){
-    if(PTR_LEVEL(type)){
-        //ポインタ型
-        name[0]='*';
-        return GetTypeName(MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)-1),lpIndex,name+1);
-    }
-
-    //整数型
-    if(type==DEF_SBYTE)             lstrcpy(name,"SByte");
-    else if(type==DEF_BYTE)         lstrcpy(name,"Byte");
-    else if(type==DEF_INTEGER)      lstrcpy(name,"Integer");
-    else if(type==DEF_WORD)         lstrcpy(name,"Word");
-    else if(type==DEF_LONG)         lstrcpy(name,"Long");
-    else if(type==DEF_DWORD)        lstrcpy(name,"DWord");
-    else if(type==DEF_INT64)        lstrcpy(name,"Int64");
-    else if(type==DEF_QWORD)        lstrcpy(name,"QWord");
-
-    //実数型
-    else if(type==DEF_SINGLE)       lstrcpy(name,"Single");
-    else if(type==DEF_DOUBLE)       lstrcpy(name,"Double");
-
-    //文字型
-    //else if(type==DEF_CHAR)               lstrcpy(name,"Char");
-
-    //bool型
-    else if(type==DEF_BOOLEAN)      lstrcpy(name,"Boolean");
-
-    //オブジェクト
-    else if(type==DEF_OBJECT || type==DEF_STRUCT){
-        if(lpIndex==0) lstrcpy(name,"non");
-        else{
-            lstrcpy(name,((CClass *)lpIndex)->name);
-        }
-    }
-
-    //ポインタ型
-    else if(type==DEF_PTR_VOID)     lstrcpy(name,"VoidPtr");
-
-    else if(type==DEF_PTR_PROC){
-        if(lpIndex==-1) lstrcpy(name,"VoidPtr");
-        else{
-            extern PROCPTRINFO *pProcPtrInfo;
-            if(pProcPtrInfo[lpIndex].ReturnType==DEF_NON)
-                lstrcpy(name,"*Sub");
-            else lstrcpy(name,"*Function");
-        }
-    }
-
-    else{
-        extern int cp;
-        SetError(1,NULL,cp);
-        return 0;
-    }
-    return 1;
-}
-
-TYPEINFO GetStringTypeInfo(){
-    extern CClass *pobj_StringClass;
-    TYPEINFO TypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
-    return TypeInfo;
-}
-
-bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member ){
-    int p1 = 0, p2 = 0;
-
-    for( int i=0; term[i]!='\0' ; i++ ){
-
-        if( term[i] == '[' ){
-            i = JumpStringInBracket( term, i + 1 );
-            if( term[i] == '\0' ) break;
-            continue;
-        }
-        if( term[i] == '(' ){
-            int temp_p = i;
-            i = JumpStringInPare( term, i + 1 ) + 1;
-            if( term[i] == '\0' ) break;
-            if( term[i] == '.'
-                || term[i] == 1 && term[i] == ESC_PSMEM ){
-                    p1 = temp_p;
-                    p2 = i;
-            }
-            continue;
-        }
-    }
-    if( !p1 ) return false;
-
-    //メソッド名
-    memcpy( procName, term, p1 );
-    procName[p1] = 0;
-
-    //パラメータ
-    memcpy( parameter, term + p1 + 1, p2 - p1 - 2 );
-    parameter[ p2 - p1 - 2 ] = 0;
-
-    //参照タイプ
-    if( term[p2] == '.' ){
-        refType = CClass::Dot;
-    }
-    else{
-        refType = CClass::Pointer;
-        p2++;
-    }
-
-    //メンバ
-    lstrcpy( member, term + p2 + 1 );
-
-    return true;
-}
-
-BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember,CClass::RefType &refType){
-    extern int cp;
-    int i,i2,i3;
-    char cPare_Open,cPare_Close;
-
-    array[0]=0;
-    array2[0]=0;
-    NestMember[0]=0;
-    for(i=0;;i++){
-        if(buffer[i]=='\"'){
-            for(i++;;i++){
-                if(IsDBCSLeadByte(buffer[i])){
-                    i++;
-                    continue;
-                }
-                if(buffer[i]=='\"') break;
-            }
-        }
-        if(buffer[i]=='['||buffer[i]=='('){
-            if(buffer[i]=='['){
-                cPare_Open='[';
-                cPare_Close=']';
-            }
-            else{
-                cPare_Open='(';
-                cPare_Close=')';
-            }
-            buffer[i]=0;
-            for(i++,i2=0;;i++,i2++){
-                if(buffer[i]==cPare_Open){
-                    if(cPare_Open=='[') i3=GetStringInBracket(array+i2,buffer+i);
-                    else i3=GetStringInPare(array+i2,buffer+i);
-                    i+=i3-1;
-                    i2+=i3-1;
-                    continue;
-                }
-                if(buffer[i]==cPare_Close){
-                    array[i2]=0;
-                    break;
-                }
-                array[i2]=buffer[i];
-            }
-            if(buffer[i+1]==cPare_Open){
-                for(i+=2,i2=0;;i++,i2++){
-                    if(buffer[i]==cPare_Open){
-                        if(cPare_Open=='[') i3=GetStringInBracket(array2+i2,buffer+i);
-                        else i3=GetStringInPare(array2+i2,buffer+i);
-                        i+=i3-1;
-                        i2+=i3-1;
-                        continue;
-                    }
-                    if(buffer[i]==cPare_Close){
-                        array2[i2]=0;
-                        break;
-                    }
-                    array2[i2]=buffer[i];
-                }
-                if(buffer[i+1]==cPare_Open){
-                    SetError(14,buffer,cp);
-                    return 0;
-                }
-            }
-            continue;
-        }
-        if(buffer[i]=='.'){
-            lstrcpy(NestMember,buffer+i+1);
-            refType = CClass::Dot;
-            buffer[i]=0;
-            break;
-        }
-        if(buffer[i]==1&&buffer[i+1]==ESC_PSMEM){
-            lstrcpy(NestMember,buffer+i+2);
-            refType = CClass::Pointer;
-            buffer[i]=0;
-            break;
-        }
-        if(buffer[i]=='\0') break;
-    }
-    return 1;
-}
-
-void GetArrayElement(char *buffer,char *variable,char *array_element){
-    array_element[0]=0;
-
-    if(buffer[lstrlen(buffer)-1]!=']'){
-        lstrcpy(variable,buffer);
-        return;
-    }
-
-    int i,i2;
-    for(i=0;;i++){
-        if(buffer[i]=='\0') break;
-        if(buffer[i]=='['){
-            i2=GetStringInBracket(array_element,buffer+i);
-            i+=i2-1;
-            continue;
-        }
-    }
-
-    lstrcpy(variable,buffer);
-    variable[lstrlen(variable)-lstrlen(array_element)]=0;
-
-    RemoveStringBracket(array_element);
-}
-
-BOOL CheckVarNameError(char *name,int NowLine){
-    int i2;
-
-    if(!IsVariableTopChar(name[0])){
-        SetError(1,NULL,NowLine);
-        return 0;
-    }
-    for(i2=1;;i2++){
-        if(name[i2]=='\0') break;
-        if(!IsVariableChar(name[i2])){
-            SetError(1,NULL,NowLine);
-            return 0;
-        }
-    }
-    return 1;
-}
-
-int JumpSubScripts(int *ss){
-    //DIMで定義された並んだ配列の数だけアドレスを進める
-    int i,i2;
-    for(i=0,i2=1;i<255;i++){
-        if(ss[i]==-1) break;
-        i2*=ss[i]+1;
-    }
-    return i2;
-}
-void GetArrange(char *variable,char *variAnswer,int *SubScripts){
-    extern int cp;
-    int i,i2,i3,i4;
-    double dbl;
-    _int64 i64data;
-    BOOL bBracket;
-    char temporary[VN_SIZE];
-
-    for(i=0;;i++){
-        if(variable[i]=='('||variable[i]=='['){
-            if(variable[i]=='[') bBracket=1;
-            else bBracket=0;
-
-            variAnswer[i]=0;
-            for(i++,i2=0,i3=0;;i++,i2++){
-                if(variable[i]==','){
-                    temporary[i2]=0;
-
-                    i2=StaticCalculation(true, temporary,0,&i64data,0);
-                    if(IsRealNumberType(i2)){
-                        memcpy(&dbl,&i64data,sizeof(double));
-                        i64data=(_int64)dbl;
-                    }
-
-                    if(i64data<0){
-                        //error
-                        SubScripts[i3]=0;
-                    }
-                    else SubScripts[i3]=(int)i64data;
-                    i3++;
-                    i2=-1;
-                    continue;
-                }
-                if(variable[i]=='('){
-                    i4=GetStringInPare(temporary+i2,variable+i);
-                    i2+=i4-1;
-                    i+=i4-1;
-                    continue;
-                }
-                if(variable[i]=='['){
-                    i4=GetStringInBracket(temporary+i2,variable+i);
-                    i2+=i4-1;
-                    i+=i4-1;
-                    continue;
-                }
-                if(variable[i]==')'&&bBracket==0||
-                    variable[i]==']'&&bBracket){
-                    temporary[i2]=0;
-                    if(i2==0){
-                        SubScripts[i3]=-2;
-                        break;
-                    }
-
-                    i2=StaticCalculation(true, temporary,0,&i64data,0);
-                    if(IsRealNumberType(i2)){
-                        memcpy(&dbl,&i64data,sizeof(double));
-                        i64data=(_int64)dbl;
-                    }
-
-                    if(i64data<0){
-                        //error
-                        SubScripts[i3]=0;
-                    }
-                    else SubScripts[i3]=(int)i64data;
-                    SubScripts[i3+1]=-1;
-                    break;
-                }
-                if(variable[i]=='\"'){
-                    SetError(1,NULL,cp);
-                    return;
-                }
-                temporary[i2]=variable[i];
-            }
-            break;
-        }
-        variAnswer[i]=variable[i];
-        if(variable[i]=='\0'){
-            SubScripts[0]=-1;
-            break;
-        }
-    }
-}
-
-int GetTypeFromSimpleName(char *variable){
-    extern char DefIntVari[26],DefSngVari[26],DefStrVari[26],divNum,dsvNum,dStrvNum;
-    int i;
-    char name[VN_SIZE];
-
-    //構造体メンバの場合を考慮
-    for(i=lstrlen(variable);i>0;i--){
-        if(variable[i]=='.'){
-            i++;
-            break;
-        }
-    }
-
-    for(;;i++){
-        if(variable[i]=='('||variable[i]=='\0'){
-            name[i]=0;
-            break;
-        }
-        name[i]=variable[i];
-    }
-    //変数名から選択
-    i--;
-    if(name[i]=='#') return DEF_DOUBLE;
-    if(name[i]=='!') return DEF_SINGLE;
-    if(name[i]=='%') return DEF_INTEGER;
-    return DEF_DOUBLE;
-}
-
-
-int GetMemberType(CClass *pobj_c,char *member,LONG_PTR *plpNestIndex,BOOL bPrivateAccess,BOOL bError){
-    extern int cp;
-    int i;
-
-    //クラス、配列の構成要素を解析する
-    char VarName[VN_SIZE];      //変数名
-    char array[VN_SIZE];        //第1次配列
-    char lpPtrOffset[VN_SIZE];      //第2次配列
-    char NestMember[VN_SIZE];   //入れ子メンバ
-    CClass::RefType refType = CClass::Non;
-    lstrcpy(VarName,member);
-    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
-
-    for(i=0;i<pobj_c->iMemberNum;i++){
-        if(lstrcmp(pobj_c->ppobj_Member[i]->name,VarName)==0) break;
-    }
-    if(i==pobj_c->iMemberNum){
-        if(bError) SetError(103,VarName,cp);
-        return -1;
-    }
-
-    //アクセシビリティをチェック
-    if(pobj_c==pobj_CompilingClass){
-        //同一クラスオブジェクトの場合はプライベートアクセスを容認する
-        if(pobj_c->ppobj_Member[i]->dwAccess==ACCESS_NON){
-            if(bError) SetError(107,VarName,cp);
-            return -1;
-        }
-    }
-    else{
-        if((bPrivateAccess==0&&pobj_c->ppobj_Member[i]->dwAccess==ACCESS_PRIVATE)||
-            pobj_c->ppobj_Member[i]->dwAccess==ACCESS_NON){
-            if(bError) SetError(107,VarName,cp);
-            return -1;
-        }
-        else if(bPrivateAccess==0&&pobj_c->ppobj_Member[i]->dwAccess==ACCESS_PROTECTED){
-            if(bError) SetError(108,VarName,cp);
-            return -1;
-        }
-    }
-
-    int type;
-    type=pobj_c->ppobj_Member[i]->TypeInfo.type;
-    *plpNestIndex=pobj_c->ppobj_Member[i]->TypeInfo.u.lpIndex;
-
-    //ポインタ変数の場合
-    if(IsPtrType(type)){
-        if(pobj_c->ppobj_Member[i]->SubScripts[0]==-1){
-            lstrcpy(lpPtrOffset,array);
-            array[0]=0;
-        }
-    }
-    else{
-        if(lpPtrOffset[0]){
-            if(bError) SetError(16,member,cp);
-            return 0;
-        }
-    }
-
-    if( refType != CClass::Non ){
-        //入れ子構造の場合
-
-        return GetMemberType(pobj_c->ppobj_Member[i]->TypeInfo.u.pobj_Class,
-            NestMember,
-            plpNestIndex,
-            0,
-            bError);
-    }
-
-    if(array[0]==0&&pobj_c->ppobj_Member[i]->SubScripts[0]!=-1){
-        return type|FLAG_PTR;
-    }
-
-    if(lpPtrOffset[0]){
-        if(PTR_LEVEL(type)){
-            type=MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)-1);
-        }
-        else{
-            //エラー
-            if(bError) SetError(1,NULL,cp);
-            return -1;
-        }
-    }
-
-    return type;
-}
-int GetVarType(const char *NameBuffer,LONG_PTR *plpIndex,BOOL bError){
-    extern BOOL bCompilingGlobal;
-    int i;
-    LONG_PTR lpIndex;
-    char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
-
-    if(NameBuffer[0]=='.'){
-        GetWithName(variable);
-        lstrcat(variable,NameBuffer);
-    }
-    else lstrcpy(variable,NameBuffer);
-
-
-    CClass::RefType refType;
-    if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){
-        // 戻り値オブジェクトのメンバを直接参照しているとき
-        //例: func().member
-
-        void *pInfo;
-        int idProc=GetProc(VarName,&pInfo);
-
-        if(idProc){
-
-            int type=GetReturnTypeOfProc(idProc,pInfo,VarName,array,&lpIndex);
-
-            return GetMemberType((CClass *)lpIndex,member,plpIndex,1,bError);
-        }
-    }
-
-
-
-    lstrcpy(VarName,variable);
-    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
-
-    int *pSubScripts;
-    int type;
-
-    extern int MaxGlobalVarNum;
-    extern VARIABLE *GlobalVar;
-    extern int MaxLocalVarNum;
-    extern VARIABLE *LocalVar;
-
-    if(bCompilingGlobal==0){
-        /////////////////
-        // ローカル変数
-        /////////////////
-
-        for(i=MaxLocalVarNum-1;i>=0;i--){   //レキシカルスコープを考慮してバックサーチ
-            if( LocalVar[i].bLiving                                         //現在のスコープで有効なもの
-                && LocalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()    //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
-                ){
-                    if(lstrcmp(VarName,LocalVar[i].name)==0) break;
-            }
-        }
-        if(i>=0){
-            //ポインタ変数の場合
-            if(IsPtrType(LocalVar[i].type)){
-                if(LocalVar[i].SubScripts[0]==-1){
-                    lstrcpy(lpPtrOffset,array);
-                    array[0]=0;
-                }
-            }
-            else{
-                if(lpPtrOffset[0]){
-                    if(bError) SetError(16,variable,cp);
-                    return -1;
-                }
-            }
-
-            type=LocalVar[i].type;
-            lpIndex=LocalVar[i].u.index;
-            pSubScripts=LocalVar[i].SubScripts;
-
-            goto ok;
-        }
-    }
-
-    if(pobj_CompilingClass){
-        ///////////////////////
-        // クラスメンバの参照
-        ///////////////////////
-
-        if(lstrcmpi(variable,"This")==0){
-            //Thisオブジェクト
-            *plpIndex=(LONG_PTR)pobj_CompilingClass;
-            return DEF_OBJECT;
-        }
-
-        if(_memicmp(variable,"This.",5)==0){
-            //Thisオブジェクトのメンバを参照するとき
-            SlideString(variable+5,-5);
-            lstrcpy(VarName,variable);
-        }
-        else{
-            //クラス内メンバを参照するとき（通常）
-
-            for(i=0;i<pobj_CompilingClass->iMemberNum;i++){
-                if(lstrcmp(VarName,pobj_CompilingClass->ppobj_Member[i]->name)==0) break;
-            }
-            if(i==pobj_CompilingClass->iMemberNum) goto NonClassMember;
-        }
-
-        return GetMemberType(pobj_CompilingClass,variable,plpIndex,1,bError);
-    }
-
-NonClassMember:
-
-    //////////////////////////
-    // 静的ローカル変数
-    // ※"Static.Object.Method.Variable"
-    //////////////////////////
-
-    char temporary[VN_SIZE];
-    extern SubInfo *pCompilingSubInfo;
-    if(pCompilingSubInfo){
-        GetNowStaticVarFullName(VarName,temporary);
-
-        for(i=0;i<MaxGlobalVarNum;i++){
-            if(lstrcmp(temporary,GlobalVar[i].name)==0) break;
-        }
-        if(i!=MaxGlobalVarNum){
-            goto GlobalOk;
-        }
-    }
-
-
-    //////////////////////////
-    // クラスの静的メンバ
-    //////////////////////////
-
-    if(member[0]){
-        lstrcpy(temporary,member);
-        char tempMember[VN_SIZE];
-        char tempArray[VN_SIZE];
-        {
-            CClass::RefType refType;
-            GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,refType);
-        }
-
-        char temp2[VN_SIZE];
-        sprintf(temp2,"%s.%s",VarName,temporary);
-        for(i=0;i<MaxGlobalVarNum;i++){
-            if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
-        }
-
-        if(i!=MaxGlobalVarNum){
-            lstrcpy(member,tempMember);
-            lstrcpy(array,tempArray);
-            goto GlobalOk;
-        }
-    }
-
-    if(pobj_CompilingClass){
-        //自身のクラスから静的メンバを参照する場合
-        char temp2[VN_SIZE];
-        sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
-        for(i=0;i<MaxGlobalVarNum;i++){
-            if(lstrcmp(temp2,GlobalVar[i].name)==0) break;
-        }
-
-        if(i!=MaxGlobalVarNum){
-            goto GlobalOk;
-        }
-    }
-
-
-    ////////////////////
-    // グローバル変数
-    ////////////////////
-
-    for(i=MaxGlobalVarNum-1;i>=0;i--){  //レキシカルスコープを考慮してバックサーチ
-        if( GlobalVar[i].bLiving                                        //現在のスコープで有効なもの
-            && GlobalVar[i].ScopeLevel <= obj_LexScopes.GetNowLevel()   //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
-            ){
-                if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
-        }
-    }
-
-    if(i>=0){
-        goto GlobalOk;
-    }
-
-    //変数として見つからなかったとき
-    if(bError) SetError(3,variable,cp);
-    return -1;
-
-GlobalOk:
-
-    //ポインタ変数の場合
-    if(IsPtrType(GlobalVar[i].type)){
-        if(GlobalVar[i].SubScripts[0]==-1){
-            lstrcpy(lpPtrOffset,array);
-            array[0]=0;
-        }
-    }
-    else{
-        if(lpPtrOffset[0]){
-            if(bError) SetError(16,variable,cp);
-            return -1;
-        }
-    }
-
-    type=GlobalVar[i].type;
-    lpIndex=GlobalVar[i].u.index;
-    pSubScripts=GlobalVar[i].SubScripts;
-
-ok:
-
-    if(member[0]){
-        if( NATURAL_TYPE(type)==DEF_OBJECT
-            || NATURAL_TYPE(type)==DEF_STRUCT){
-                return GetMemberType((CClass *)lpIndex,member,plpIndex,0,bError);
-        }
-    }
-
-    if(array[0]==0&&pSubScripts[0]!=-1){
-        //配列の先頭ポインタを示す場合
-        type|=FLAG_PTR;
-    }
-
-    if(lpPtrOffset[0]){
-        if(PTR_LEVEL(type)){
-            type=MAKE_PTR_TYPE(NATURAL_TYPE(type),PTR_LEVEL(type)-1);
-        }
-        else{
-            //エラー
-            if(bError) SetError(1,NULL,cp);
-            return -1;
-        }
-    }
-
-    *plpIndex=lpIndex;
-    return type;
-}
-
-BOOL GetVarOffsetReadOnly(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss ){
-    //読み取り専用で変数へアクセス
-    return GetVarOffset(
-        true,       //エラー表示有効
-        false,      //書き込みアクセスは無し
-        NameBuffer,
-        pType,
-        pRelativeVar,
-        plpIndex,
-        pss);
-}
-BOOL GetVarOffsetReadWrite(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss ){
-    //読み書き両用で変数へアクセス
-    return GetVarOffset(
-        true,       //エラー表示有効
-        true,       //書き込みアクセス
-        NameBuffer,
-        pType,
-        pRelativeVar,
-        plpIndex,
-        pss);
-}
-
-
-
-BOOL GetDimentionFormat(const char *buffer, const bool isRef, char *VarName,int *SubScripts,TYPEINFO *pTypeInfo,char *InitBuf,char *ConstractParameter){
-    int i,i2,i3,IsStr;
-    char variable[VN_SIZE],temporary[8192];
-
-    for(i=0;;i++){
-        if((buffer[i]==1&&buffer[i+1]==ESC_AS)||
-            buffer[i]=='='||
-            buffer[i]=='\0'){
-            variable[i]=0;
-            break;
-        }
-        variable[i]=buffer[i];
-    }
-
-    if(buffer[i]=='='){
-        ////////////////////////////////////
-        // 初期化データが指定されいるとき
-        ////////////////////////////////////
-
-        for(i++,i2=0,IsStr=0;;i++,i2++){
-            if(buffer[i]=='\"') IsStr^=1;
-            if(buffer[i]=='('&&IsStr==0){
-                i3=GetStringInPare(InitBuf+i2,buffer+i);
-                i+=i3-1;
-                i2+=i3-1;
-                continue;
-            }
-            if(buffer[i]=='['&&IsStr==0){
-                i3=GetStringInBracket(InitBuf+i2,buffer+i);
-                i+=i3-1;
-                i2+=i3-1;
-                continue;
-            }
-            if((buffer[i]==1&&buffer[i+1]==ESC_AS)||
-                (buffer[i]==','&&IsStr==0)||
-                buffer[i]=='\0'){
-                InitBuf[i2]=0;
-                break;
-            }
-            InitBuf[i2]=buffer[i];
-        }
-    }
-    else{
-        //初期化データなし
-        InitBuf[0]=0;
-    }
-
-    ConstractParameter[0]=0;
-    if(buffer[i]==1&&buffer[i+1]==ESC_AS){
-        /////////////////////////////
-        // "As ～" による型指定あり
-        /////////////////////////////
-
-        for(i+=2,i2=0;;i++,i2++){
-            if(buffer[i]==','||buffer[i]=='('||buffer[i]=='\0'){
-                temporary[i2]=0;
-                break;
-            }
-            temporary[i2]=buffer[i];
-        }
-        pTypeInfo->type=GetTypeFixed(temporary,&pTypeInfo->u.lpIndex);
-        if(pTypeInfo->type==-1){
-            SetError(3,temporary,cp);
-            pTypeInfo->type=DEF_LONG;
-        }
-
-        if(pTypeInfo->type==DEF_PTR_PROC){
-            if(temporary[0]=='*'&&
-                temporary[1]==1&&
-                (temporary[2]==ESC_FUNCTION||temporary[2]==ESC_SUB)){
-                if(buffer[i]!='('){
-                    SetError(10,temporary,cp);
-                    return 0;
-                }
-                i3=GetStringInPare(temporary+3,buffer+i);
-                i+=i3;
-                i2+=i3;
-
-                if(temporary[2]==ESC_FUNCTION&&buffer[i]==1&&buffer[i+1]==ESC_AS){
-                    temporary[i2++]=buffer[i++];
-                    temporary[i2++]=buffer[i++];
-                    for(;;i++,i2++){
-                        if(!IsVariableChar(buffer[i])){
-                            temporary[i2]=0;
-                            break;
-                        }
-                        temporary[i2]=buffer[i];
-                    }
-                }
-            }
-            else{
-                //TypeDefをする前のベース型を取得
-                GetOriginalTypeName(temporary);
-            }
-
-            if(temporary[3]!='('){
-                SetError(10,temporary,cp);
-                return 0;
-            }
-
-            //関数ポインタ
-            pTypeInfo->u.lpIndex=AddProcPtrInfo(temporary+3,temporary[2]);
-        }
-
-        if(buffer[i]=='('){
-            //コンストラクタに渡すパラメータを取得
-            i2=GetStringInPare(ConstractParameter,buffer+i);
-            i+=i2;
-            RemoveStringPare(ConstractParameter);
-
-            if(pTypeInfo->type!=DEF_OBJECT){
-                SetError(112,variable,cp);
-                return 0;
-            }
-        }
-    }
-    else{
-        /////////////////
-        // As指定なし
-        /////////////////
-
-        if( InitBuf[0] == '\0' ){
-            //As指定も、初期値指定もない場合
-            pTypeInfo->type=GetTypeFromSimpleName(variable);
-
-            i2=lstrlen(variable)-1;
-            if(i2>=0){
-                if(!(variable[i2]=='#'||variable[i2]=='!'||variable[i2]=='%'||variable[i2]=='$'))
-                    SetError(-103,variable,cp);
-            }
-        }
-        else{
-            //初期値の型を判別して自動的に型情報を付加する
-            TYPEINFO BaseType = GetStringTypeInfo();
-            int result = NumOpe_GetType_Old( InitBuf, &BaseType, &pTypeInfo->u.lpIndex );
-
-            //エラーの場合
-            if( result == -1 ) return 0;
-
-            pTypeInfo->type = result;
-        }
-
-    }
-
-    if( InitBuf[0] != '\0' && ConstractParameter[0] != '\0' ){
-        //初期値とコンストラクタパラメータが同時に呼び出されているとき
-        SetError(132, NULL, cp);
-    }
-
-    /*
-    TODO: 消す
-    if( pTypeInfo->type == DEF_OBJECT && InitBuf[0] != '\0' && InitBuf[0] != '[' && isRef == false ){
-        if( pTypeInfo->u.pobj_Class->GetCopyConstructorMethod() ){
-            //オブジェクトでコピーコンストラクタが存在するとき
-            lstrcpy( ConstractParameter, InitBuf );
-            InitBuf[0] = 0;
-        }
-    }*/
-
-    GetArrange(variable,VarName,SubScripts);
-    return 1;
-}
-
-BOOL GetNowStaticVarFullName(char *VarName,char *FullName){
-    extern SubInfo *pCompilingSubInfo;
-    if(!pCompilingSubInfo) return 0;
-
-    //Static識別
-    lstrcpy(FullName,"Static%");
-
-    //クラス名
-    if(pobj_CompilingClass){
-        lstrcat(FullName,pobj_CompilingClass->name);
-        lstrcat(FullName,"%");
-    }
-
-    //関数（またはメソッド）名
-    lstrcat(FullName,pCompilingSubInfo->name);
-    lstrcat(FullName,"%");
-
-    //ID
-    char temp[255];
-    sprintf(temp,"%x",pCompilingSubInfo->id);
-    lstrcat(FullName,temp);
-    lstrcat(FullName,"%");
-
-    //変数名
-    lstrcat(FullName,VarName);
-
-    return 1;
-}
-
-
-void AddGlobalVariable(bool isRef, char *name,int *SubScripts,TYPEINFO *pTypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlag){
-    /////////////////////////
-    // グローバル変数を追加
-    /////////////////////////
-    extern VARIABLE *GlobalVar;
-    extern int MaxGlobalVarNum;
-    extern int AllInitGlobalVarSize;
-    extern int AllGlobalVarSize;
-
-    int i2,i3,VarSize;
-
-    for(i2=0;i2<MaxGlobalVarNum;i2++){
-        if(GlobalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==GlobalVar[i2].ScopeLevel){
-            if(lstrcmp(GlobalVar[i2].name,name)==0){
-                //２重定義のエラー
-                SetError(15,name,cp);
-                return;
-            }
-        }
-    }
-
-    GlobalVar=(VARIABLE *)HeapReAlloc(hHeap,0,GlobalVar,(MaxGlobalVarNum+1)*sizeof(VARIABLE));
-    VARIABLE *pVar = &GlobalVar[MaxGlobalVarNum];
-    MaxGlobalVarNum++;
-
-    if( isRef ){
-        //参照型
-        pVar->fRef = REF_VARIABLE;
-        TypeSize = PTR_SIZE;
-    }
-    else pVar->fRef=0;
-
-    for(i2=1,i3=0;i3<255;i3++){
-        //配列要素数
-        pVar->SubScripts[i3]=SubScripts[i3];
-
-        if(SubScripts[i3]==-1) break;
-        i2*=SubScripts[i3]+1;
-    }
-    VarSize=TypeSize*i2;
-    if(VarSize%PTR_SIZE) VarSize+=PTR_SIZE-(VarSize%PTR_SIZE);
-
-    lstrcpy(pVar->name,name);
-    if(dwFlag & DIMFLAG_CONST) pVar->bConst = true;
-    else pVar->bConst = false;
-    if(SubScripts[0]==-1) pVar->bArray=0;
-    else pVar->bArray=1;
-    pVar->type=pTypeInfo->type;
-    pVar->u.index=pTypeInfo->u.lpIndex;
-
-    //コンストラクタ用パラメータ
-    pVar->ConstractParameter=(char *)HeapAlloc(hHeap,0,lstrlen(ConstractParameter)+1);
-    lstrcpy(pVar->ConstractParameter,ConstractParameter);
-
-    //レキシカルスコープ
-    pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
-    pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
-    pVar->bLiving=TRUE;
-
-    //エラー用
-    pVar->source_code_address=cp;
-
-    //アラインメントを考慮
-    int alignment = 0;
-    if( pVar->type==DEF_STRUCT ){
-        alignment = pVar->u.pobj_c->iAlign;
-    }
-
-    if(InitBuf[0]||dwFlag==DIMFLAG_INITDEBUGVAR){
-        //初期バッファがあるとき
-
-        if( alignment ){
-            if( AllInitGlobalVarSize % alignment ){
-                AllInitGlobalVarSize += alignment - (AllInitGlobalVarSize % alignment);
-            }
-        }
-
-        pVar->offset=AllInitGlobalVarSize;
-        AllInitGlobalVarSize+=VarSize;
-    }
-    else{
-        //初期バッファがないとき
-
-        if( alignment ){
-            if( AllGlobalVarSize % alignment ){
-                AllGlobalVarSize += alignment - (AllGlobalVarSize % alignment);
-            }
-        }
-
-        pVar->offset=AllGlobalVarSize | 0x80000000;
-        AllGlobalVarSize+=VarSize;
-    }
-
-    if(InitBuf[0]){
-        int result = 0;
-        if( pVar->type != DEF_OBJECT ){
-            //初期バッファにデータをセット
-            extern BYTE *initGlobalBuf;
-            initGlobalBuf=(BYTE *)HeapReAlloc(hHeap,
-                HEAP_ZERO_MEMORY,
-                initGlobalBuf,
-                AllInitGlobalVarSize);
-
-            result = SetInitGlobalData(pVar->offset,
-                pVar->type,
-                pVar->u.index,
-                pVar->SubScripts,
-                InitBuf);
-        }
-
-        if(!result){
-            //動的な式だった場合は代入演算を行う
-
-            //初期代入時のみ、書き込みアクセスを許可する
-            bool bConstBack = pVar->bConst;
-            pVar->bConst = false;
-
-            //代入
-            char temporary[8192];
-            sprintf(temporary,"%s=%s",name,InitBuf);
-            OpcodeCalc(temporary);
-
-            //アクセス制限を元に戻す
-            pVar->bConst = bConstBack;
-        }
-    }
-
-
-    if( pTypeInfo->type==DEF_OBJECT ){
-        //デストラクタの利用フラグをオンにする
-        CMethod *method = pTypeInfo->u.pobj_Class->GetDestructorMethod();
-        if( method ){
-            method->psi->bUse = 1;
-        }
-    }
-
-/*
-    TODO: 消す
-    if(pTypeInfo->type==DEF_OBJECT){
-        //利用対象のクラスコンストラクタ、デストラクタに使用チェックをつける
-        for(i2=0;i2<pTypeInfo->u.pobj_Class->iMethodNum;i2++){
-            if(lstrcmp(pTypeInfo->u.pobj_Class->ppobj_Method[i2]->psi->name,pTypeInfo->u.pobj_Class->name)==0){
-                //コンストラクタ
-                pTypeInfo->u.pobj_Class->ppobj_Method[i2]->psi->bUse=1;
-            }
-            if(pTypeInfo->u.pobj_Class->ppobj_Method[i2]->psi->name[0]=='~'){
-                //デストラクタ
-                pTypeInfo->u.pobj_Class->ppobj_Method[i2]->psi->bUse=1;
-            }
-        }
-    }*/
-}

BasicCompiler_Common/Variable.h

@@ +1 @@
+
+class Variable : public Type
+{
+    string name;
+    bool isConst;
+    bool isRef;
+    bool isArray;
+    int subScripts[MAX_ARRAYDIM];
+
+    bool isParameter;
+
+public:
+    Variable( const string &name, const Type &type, bool isConst = false, bool isRef = false ):
+        Type( type ),
+        name( name ),
+        isConst( isConst ),
+        isRef( isRef ),
+        isArray( false ),
+        isParameter( false)
+    {
+        subScripts[0] = -1;
+    }
+    Variable( const Variable &var ):
+        Type( var ),
+        name( var.name ),
+        isConst( var.isConst ),
+        isRef( var.isRef ),
+        isArray( false ),
+        isParameter( false )
+    {
+        subScripts[0] = -1;
+        if( var.isArray ){
+            SetArray( var.subScripts );
+        }
+    }
+    ~Variable(){}
+
+    void SetArray( const int *pSubScripts ){
+        isArray = true;
+        memcpy( this->subScripts, pSubScripts, sizeof(int) * MAX_ARRAYDIM );
+    }
+
+    const string &GetName() const
+    {
+        return name;
+    }
+
+    void ConstOff(){
+        isConst = false;
+    }
+    void ConstOn(){
+        isConst = true;
+    }
+    bool IsConst() const
+    {
+        return isConst;
+    }
+    bool IsRef() const
+    {
+        return isRef;
+    }
+    bool IsArray()const
+    {
+        return isArray;
+    }
+    const int *GetSubScriptsPtr() const
+    {
+        return subScripts;
+    }
+
+    void ThisIsParameter(){
+        isParameter = true;
+    }
+    bool IsParameter() const
+    {
+        return isParameter;
+    }
 
 
-BOOL IsVariableTopChar(char c);
-BOOL IsVariableChar(char c);
-BOOL IsPtrType(int type);
-BOOL IsSignedType(int type);
-BOOL IsNaturalWholeNumberType(int type);
-BOOL IsWholeNumberType(int type);
-BOOL IsRealNumberType(int type);
-BOOL Is64Type(int type);
-int GetSignedType(int type);
-int GetUnsignedType(int type);
-int GetTypeSize(int type,LONG_PTR lpIndex);
-int GetPtrType(int type,LONG_PTR lpIndex);
-int GetTypeFixed(const char *TypeName,LONG_PTR *lpNum);
-void GetOriginalTypeName(char *buffer);
-BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name);
-bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member );
-BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember, CClass::RefType &refType );
-void GetArrayElement(char *buffer,char *variable,char *array_element);
-BOOL CheckVarNameError(char *name,int NowLine);
-int JumpSubScripts(int *ss);
-void GetArrange(char *variable,char *variAnswer,int *SubScripts);
-int GetTypeFromSimpleName(char *variable);
-int GetVarType(const char *NameBuffer,LONG_PTR *plpIndex,BOOL bError);
-BOOL GetVarOffsetReadOnly(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss=0);
-BOOL GetVarOffsetReadWrite(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss=0);
-BOOL GetDimentionFormat(const char *buffer, const bool isRef, char *VarName,int *SubScripts,TYPEINFO *pTypeInfo,char *InitBuf,char *ConstractParameter);
-BOOL GetNowStaticVarFullName(char *VarName,char *FullName);
-void AddGlobalVariable(bool isRef, char *name,int *SubScripts,TYPEINFO *pTypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlag);
+    int GetMemorySize() const
+    {
+        if( isRef || isParameter ){
+            return PTR_SIZE;
+        }
 
+        int size = Type::GetSize();
+
+        if( isArray ){
+            int num = 1;
+            for( int i=0; i<MAX_ARRAYDIM; i++){
+                if(subScripts[i]==-1) break;
+                num *= subScripts[i]+1;
+            }
+            size *= num;
+        }
+
+        if( size % PTR_SIZE ){
+            size += PTR_SIZE-(size%PTR_SIZE);
+        }
+
+        return size;
+    }
+
+
+    /* --- オフセット ---
+
+        ※グローバル変数で初期バッファがない場合は最上位ビットに1がセットされ、
+        初期バッファの有無が識別される。
+        （その後、スケジュール実行により、実際の配置に並び替えられる）*/
+    int offset;
+
+    //コンストラクタ用パラメータ
+    string paramStrForConstructor;
+
+    //レキシカルスコープ用
+    int ScopeStartAddress;
+    int ScopeEndAddress;
+    int ScopeLevel;
+    BOOL bLiving;
+
+
+    int source_code_address;
+};
+
+class Variables : public vector<Variable *>
+{
+public:
+    Variables(){}
+    ~Variables(){
+        clear();
+    }
+
+    void clear(){
+        for( int i=0; i<(int)this->size(); i++ ){
+            delete (*this)[i];
+        }
+
+        vector<Variable *>::clear();
+    }
+
+    bool DuplicateCheck( const string &varName ) const
+    {
+        //レキシカルスコープを考慮して重複判定
+        for( int i=(int)this->size()-1; i>=0 ; i-- ){
+            Variable &var = *(*this)[i];
+            if( var.bLiving                                         //現在のスコープで有効なもの
+                && var.ScopeLevel == obj_LexScopes.GetNowLevel()    //現在のスコープと同一レベル
+                ){
+                    if( var.GetName() == varName ){
+                        return true;
+                    }
+            }
+        }
+        return false;
+    }
+
+    const Variable *BackSearch( const string &varName ) const
+    {
+        //レキシカルスコープを考慮してバックサーチ
+        for( int i=(int)this->size()-1; i>=0 ; i-- ){
+            Variable &var = *(*this)[i];
+            if( var.bLiving                                         //現在のスコープで有効なもの
+                && var.ScopeLevel <= obj_LexScopes.GetNowLevel()    //現在のスコープレベルを超さないもの（Returnによる解放処理中を考慮）
+                ){
+                    if( var.GetName() == varName ){
+                        return &var;
+                    }
+            }
+        }
+        return NULL;
+    }
+
+    const Variable *Find( const string &varName )const
+    {
+        int max = (int)this->size();
+        for( int i=0; i<max; i++ ){
+            Variable *pVar = (*this)[i];
+            if( pVar->GetName() == varName ){
+                return pVar;
+            }
+        }
+        return NULL;
+    }
+};
+
+extern Variables globalVars;
+
+

BasicCompiler_Common/calculation.cpp

@@ -390 +390 @@
 }
 
-int StaticCalculation(bool enableerror, const char *Command,int BaseType,_int64 *pi64data,LONG_PTR *plpIndex,BOOL bDebuggingWatchList){
-    extern HANDLE hHeap;
+bool StaticCalculation(bool enableerror, const char *Command,int BaseType,_int64 *pi64data,Type &resultType,BOOL bDebuggingWatchList, bool *pIsMemoryAccessError){
     extern int cp;
     int i,i2,i3,PareNum;
@@ -406 +405 @@
     int sp,pnum;
 
+    if( pIsMemoryAccessError ) *pIsMemoryAccessError = false;
+
     *pi64data=0;
-    if(Command[0]=='\0') return 0;
+    if(Command[0]=='\0') return false;
 
     for(i=0,i2=0,sp=0,pnum=0,PareNum=0;;i++,i2++){
@@ -487 +488 @@
                             extern int cp;
                             if(enableerror) SetError(3,temp2,cp);
-                            return 0;
+                            return false;
                         }
                         i64nums[pnum]=GetTypeSize(i3,lpIndex);
@@ -497 +498 @@
                         if(!GetConstCalcBuffer(temporary,temp2,Parms)){
                             if(enableerror) SetError(3,temporary,cp);
-                            return 0;
+                            return false;
                         }
 
-                        type[pnum]=StaticCalculation(true, Parms,BaseType,&i64data,&before_index[pnum]);
-                        if(IsRealNumberType(type[pnum])){
-                            //整数型
+                        Type tempType;
+                        StaticCalculation(true, Parms,BaseType,&i64data,tempType);
+                        type[pnum] = tempType.GetBasicType();
+                        before_index[pnum] = tempType.GetIndex();
+                        if(tempType.IsReal()){
+                            //実数型
                             memcpy(&nums[pnum],&i64data,sizeof(double));
                         }
@@ -548 +552 @@
 
                             RELATIVE_VAR RelativeVar;
-                            LONG_PTR lpIndex;
                             int ss[MAX_ARRAYDIM];
                             void *offset;
@@ -557 +560 @@
                             extern HANDLE hDebugProcess;
 
-                            i3=Debugging_GetVarOffset(Parms,&i2,&RelativeVar,&lpIndex,ss);
+                            Type tempType;
+                            i3=Debugging_GetVarOffset(Parms,&RelativeVar,tempType,ss);
                             if(i3==0){
                                 //式エラー
-                                return 0;
+                                return false;
                             }
                             if(i3==-1){
                                 //メモリにアクセスできないとき
-                                return -1;
+                                if( pIsMemoryAccessError ) *pIsMemoryAccessError = true;
+                                return false;
                             }
 
@@ -571 +576 @@
                                 offset=(void *)Debugging_GetVarPtr(&RelativeVar);
 
-                                type[pnum]=i2;
-
-                                if(i2==DEF_DOUBLE){
+                                type[pnum]=tempType.GetBasicType();
+
+                                if(tempType.IsDouble()){
                                     i3=ReadProcessMemory(hDebugProcess,offset,&nums[pnum],sizeof(double),&stAccBytes);
                                 }
-                                else if(i2==DEF_SINGLE){
+                                else if(tempType.IsSingle()){
                                     if(i3=ReadProcessMemory(hDebugProcess,offset,&flt,sizeof(float),&stAccBytes)){
                                         nums[pnum]=(double)flt;
                                     }
                                 }
-                                else if(IsPtrType(i2)){
+                                else if(tempType.IsPointer()){
                                     LONG_PTR lpData;
                                     if(i3=ReadProcessMemory(hDebugProcess,offset,&lpData,sizeof(LONG_PTR),&stAccBytes)){
@@ -587 +592 @@
                                     }
                                 }
-                                else if(Is64Type(i2)){
+                                else if(tempType.Is64()){
                                     type[pnum]=DEF_INT64;
 
@@ -593 +598 @@
                                 }
 
-                                else if(i2==DEF_LONG){
+                                else if(tempType.IsLong()){
                                     long lData;
                                     if(i3=ReadProcessMemory(hDebugProcess,offset,&lData,sizeof(long),&stAccBytes)){
@@ -599 +604 @@
                                     }
                                 }
-                                else if(i2==DEF_DWORD){
+                                else if(tempType.IsDWord()){
                                     if(i3=ReadProcessMemory(hDebugProcess,offset,&dwData,sizeof(DWORD),&stAccBytes)){
                                         i64nums[pnum]=(_int64)dwData;
                                     }
                                 }
-                                else if(i2==DEF_INTEGER || (isUnicode&&i2==DEF_CHAR)){
+                                else if(tempType.IsInteger()){
                                     short shortData;
                                     if(i3=ReadProcessMemory(hDebugProcess,offset,&shortData,sizeof(short),&stAccBytes)){
@@ -610 +615 @@
                                     }
                                 }
-                                else if(i2==DEF_WORD){
+                                else if(tempType.IsWord()){
                                     WORD wData;
                                     if(i3=ReadProcessMemory(hDebugProcess,offset,&wData,sizeof(WORD),&stAccBytes)){
@@ -616 +621 @@
                                     }
                                 }
-                                else if(i2==DEF_SBYTE || (isUnicode==false&&i2==DEF_CHAR)){
+                                else if(tempType.IsSByte()){
                                     char charData;
                                     if(i3=ReadProcessMemory(hDebugProcess,offset,&charData,sizeof(char),&stAccBytes)){
@@ -622 +627 @@
                                     }
                                 }
-                                else if(i2==DEF_BYTE){
+                                else if(tempType.IsByte()){
                                     BYTE byteData;
                                     if(i3=ReadProcessMemory(hDebugProcess,offset,&byteData,sizeof(BYTE),&stAccBytes)){
@@ -628 +633 @@
                                     }
                                 }
-                                else if(i2==DEF_BOOLEAN){
+                                else if(tempType.IsBoolean()){
                                     BYTE byteData;
                                     if(i3=ReadProcessMemory(hDebugProcess,offset,&byteData,sizeof(BYTE),&stAccBytes)){
@@ -634 +639 @@
                                     }
                                 }
-                                else return 0;
+                                else return false;
 
                                 if(!i3){
                                     //読み込みに失敗
-                                    return -1;
+                                    if( pIsMemoryAccessError ) *pIsMemoryAccessError = true;
+                                    return false;
                                 }
                                 goto JumpConst;
@@ -672 +678 @@
                                 //エラー
                                 if(enableerror) SetError(300,NULL,cp);
-                                return -1;
+                                return 0;
                             }
                             goto JumpConst;
@@ -685 +691 @@
 
                         if(type[pnum]==-1){
-                            if(bDebuggingWatchList) return -1;
+                            if(bDebuggingWatchList){
+                                if( pIsMemoryAccessError ) *pIsMemoryAccessError = true;
+                                return false;
+                            }
                             //エラー
                             if(enableerror) SetError(3,Parms,cp);
-                            return 0;
+                            return false;
                         }
 JumpConst:;
@@ -713 +722 @@
                 if(!(Command[i]=='+'||Command[i]=='-'||(Command[i]==1&&Command[i+1]==ESC_NOT))){
                     if(enableerror) SetError(1,NULL,cp);
-                    return 0;
+                    return false;
                 }
                 if(Command[i]=='+'){
@@ -898 +907 @@
         //文字列ポインタ
         *pi64data=(_int64)stack[0];
-        *plpIndex=index_stack[0];
-        return type_stack[0];
+        resultType.SetType( type_stack[0], index_stack[0] );
+        return true;
     }
 
@@ -905 +914 @@
         //実数
         memcpy(pi64data,&dbl_stack[0],sizeof(double));
-        return type_stack[0];
+        resultType.SetType( type_stack[0], index_stack[0] );
+        return true;
     }
 
@@ -911 +921 @@
     *pi64data=i64stack[0];
 
-    if(plpIndex){
-        *plpIndex=index_stack[0];
-        if(*plpIndex==-1){
-            if(Is64Type(type_stack[0])==0&&IsRealNumberType(type_stack[0])==0){
-                //整数（符号有り/無し）
-                i64data=*pi64data;
-
-                *plpIndex=GetLiteralIndex(i64data);
-            }
-        }
-    }
-
-    return type_stack[0];
+    if(index_stack[0]==-1){
+        if(Is64Type(type_stack[0])==0&&IsRealNumberType(type_stack[0])==0){
+            //整数（符号有り/無し）
+            i64data=*pi64data;
+
+            resultType.SetIndex( GetLiteralIndex(i64data) );
+        }
+    }
+    else{
+        resultType.SetIndex( index_stack[0] );
+    }
+
+    resultType.SetBasicType( type_stack[0] );
+    return true;
 }
 
@@ -1187 +1198 @@
     return -1;
 }
-bool IsStringObjectType(const TYPEINFO &TypeInfo){
-    if(TypeInfo.type==DEF_OBJECT){
-        if(lstrcmp(TypeInfo.u.pobj_Class->name,"String")==0){
-            return 1;
-        }
-    }
-    return 0;
-}
 int IsStrCalculation(char *Command){
-    int i,i2,i3,i4,type,PareNum;
+    int i,i2,i3,i4,PareNum;
     char temporary[VN_SIZE],temp2[8192];
 
@@ -1245 +1248 @@
                 }
                 if(Command[i2+i3]=='('){
-                    TYPEINFO TypeInfo;
 
                     //DLL関数の場合
-                    DECLAREINFO *pdi;
-                    pdi=GetDeclareHash(temporary);
-                    if(pdi){
-                        TypeInfo.type=pdi->ReturnType;
-                        TypeInfo.u.lpIndex=pdi->u.ReturnIndex;
-                        if(IsStringObjectType( TypeInfo )) return 1;
+                    DllProc *pDllProc;
+                    pDllProc=GetDeclareHash(temporary);
+                    if(pDllProc){
+                        if( pDllProc->ReturnType().IsStringObject() ){
+                            return 1;
+                        }
                         return 0;
                     }
 
                     //ユーザー定義関数
-                    SubInfo *psi;
-                    psi=GetSubHash(temporary);
-                    if(psi){
-                        TypeInfo.type=psi->ReturnType;
-                        TypeInfo.u.lpIndex=psi->u.ReturnIndex;
-                        if(IsStringObjectType(TypeInfo)) return 1;
+                    UserProc *pUserProc;
+                    pUserProc=GetSubHash(temporary);
+                    if(pUserProc){
+                        if( pUserProc->ReturnType().IsStringObject() ){
+                            return 1;
+                        }
                         return 0;
                     }
@@ -1297 +1299 @@
 
                 //変数
-                CClass *pobj_Class;
-                type = GetVarType(Command+i2,(LONG_PTR *)&pobj_Class,1);
-                if(type==-1 || type ==0){
+                Type varType;
+                if( !GetVarType(Command+i2,varType,1) ){
                     //エラー
                     return -1;
                 }
-                if(type==DEF_OBJECT){
-                    if(lstrcmp(pobj_Class->name,"String")==0){
-                        return 1;
-                    }
-                    return 0;
+                if( varType.IsStringObject() ){
+                    return 1;
                 }
             }

BasicCompiler_Common/common.h

@@ -37 +37 @@
 #include "../BasicCompiler_Common/psapi.h"
 #include "../BasicCompiler_Common/BreakPoint.h"
+#include "../BasicCompiler_Common/LexicalScoping.h"
 
 
@@ -152 +153 @@
 #include "Const.h"
 
+// 変数管理用のクラス
+#include "Variable.h"
+
 // パラメータ管理用のクラス
 #include "Parameter.h"
@@ -172 +176 @@
 
 //変数
-#define REF_PARAMETER 1
-#define OBJECT_PARAMETER 2
-#define REF_VARIABLE 4
 struct VARIABLE{
     char name[255];
@@ -219 +220 @@
 };
 
-struct PARAMETER_INFO{
-    char *name;
-    int type;
-    union{
-        LONG_PTR index;
-        CClass *pobj_c;
-    }u;
-
-    BOOL bByVal;
-    BOOL bArray;
-    int SubScripts[MAX_ARRAYDIM];
-};
-
-#define DECLARE_DYNAMIC 1
-#define DECLARE_STATIC  2
-struct DECLAREINFO{
-    DWORD dwType;
-
-    char *file;
-    char *name;
-    char *alias;
-    BOOL bCdecl;
-
-    //パラメータ
-    PARAMETER_INFO *pParmInfo;
-    int ParmNum;
-
-    //戻り値
-    int ReturnType;
-    union{
-        LONG_PTR ReturnIndex;
-        CClass *Return_pobj_c;
-    }u;
-
-    union{
-        int LookupAddress;
-        int StaticProc_CodeAddress;
-    };
-
-    BOOL bUse;
-
-    int pos;
-
-    DECLAREINFO *pNextData;
-};
-struct PROCPTRINFO{
-    PARAMETER_INFO *pParmInfo;
-    int ParmNum;
-
-    int ReturnType;
-    union{
-        LONG_PTR ReturnIndex;
-        CClass *Return_pobj_c;
-    }u;
-};
 struct CONSTINFO{
     char *name;
@@ -361 +307 @@
 #include "../BasicCompiler_Common/PESchedule.h"
 #include "../BasicCompiler_Common/DebugSection.h"
-#include "../BasicCompiler_Common/LexicalScoping.h"
-#include "../BasicCompiler_Common/Variable.h"
+#include "../BasicCompiler_Common/VariableOpe.h"
 #include "../BasicCompiler_Common/Exception.h"
 
 
 
-int StaticCalculation(bool enableerror, const char *Command,int BaseType,_int64 *pi64data,LONG_PTR *plpIndex,BOOL bDebuggingWatchList=0);
+bool StaticCalculation(bool enableerror, const char *Command,int BaseType,_int64 *pi64data,Type &resultType,BOOL bDebuggingWatchList=0, bool *pIsMemoryAccessError=NULL);
 
 
@@ -384 +329 @@
 
 //hash.cpp
-int hash_default(char *name);
+int hash_default(const char *name);
 CONSTINFO *GetConstHash(char *name);
-DECLAREINFO *GetDeclareHash(char *name);
-SubInfo *GetSubHash(const char *name,BOOL bError=0);
-SubInfo *GetMethodHash(char *ObjectName,char *MethodName,char *Parameter,BOOL bError=0);
-void GetOverloadSubHash( const char *lpszName, std::vector<SubInfo *> &subs );
+DllProc *GetDeclareHash(char *name);
+UserProc *GetSubHash(const char *name,BOOL bError=0);
+UserProc *GetMethodHash(const char *ObjectName,const char *MethodName,const char *Parameter,BOOL bError=0);
+void GetOverloadSubHash( const char *lpszName, std::vector<UserProc *> &subs );
 
 //Object.cpp
-void AddClassName(char *Parameter,int NowLine);
-void CallConstructor(char *VarName,int *SubScripts,TYPEINFO &TypeInfo,char *Parameter);
+void CallConstructor( const char *ObjectName,const int *SubScripts, const Type &type,const char *Parameter);
+bool Operator_New( const char *expression, const Type &baseType, Type &resultType );
 
 //Overload.sbp
-SubInfo *OverloadSolutionWithStrParam(
+UserProc *OverloadSolutionWithStrParam(
     const char *name,
-    std::vector<SubInfo *> &subs,
+    std::vector<UserProc *> &subs,
     const char *Parameter,
-    const char *ObjectName,
-    TYPEINFO *pReturnTypeInfo);
-SubInfo *OverloadSolution(
+    const char *ObjectName);
+UserProc *OverloadSolution(
     const char *name,
-    std::vector<SubInfo *> &subs,
-    const PARAMETER_INFO *ppi,
-    const int ParmNum,
-    TYPEINFO *pReturnTypeInfo);
+    std::vector<UserProc *> &subs,
+    const Parameters &params,
+    const Type &returnType );
 
 //Debug.cpp
@@ -416 +359 @@
 void Debugger_Pause(void);
 ULONG_PTR rva_to_real(DWORD p);
-SubInfo *GetSubFromObp(ULONG_PTR pos);
+UserProc *GetSubFromObp(ULONG_PTR pos);
 void ReadOpBuffer();
 void DebugProgram(void);
@@ -428 +371 @@
 ULONG_PTR Debugging_GetVarPtr(RELATIVE_VAR *pRelativeVar);
 ULONG_PTR Debugging_GetThisPtrOffset(LONG_PTR obp_Rip);
-int Debugging_GetVarOffset(char *variable,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss);
+int Debugging_GetVarOffset( char *variable,RELATIVE_VAR *pRelativeVar, Type &resultType, int *pss);
 
 //MakeExe.cpp
@@ -462 +405 @@
 
 //CommandFormat.cpp
-void ComOpen(char *Parameter,char *buffer,int NowLine);
+void ComOpen(char *Parameter,char *buffer,int nowLine);
 void ComClose(char *Parameter,char *buffer);
 void ComField(char *Parameter,char *buffer);
-void ComLine(char *Parameter,char *buffer,int NowLine);
-void ComCircle(char *Parameter,char *buffer,int NowLine);
-void ComPSet(char *Parameter,char *buffer,int NowLine);
-void ComPaint(char *Parameter,char *buffer,int NowLine);
+void ComLine(char *Parameter,char *buffer,int nowLine);
+void ComCircle(char *Parameter,char *buffer,int nowLine);
+void ComPSet(char *Parameter,char *buffer,int nowLine);
+void ComPaint(char *Parameter,char *buffer,int nowLine);
 
 // StrOperation.cpp
@@ -512 +455 @@
 BOOL GetConstCalcBuffer(char *name,char *Parameter,char *pCalcBuffer);
 DWORD GetConstValue(char *name,double *dbl,char *buffer,LONG_PTR *plpIndex);
-bool IsStringObjectType(const TYPEINFO &TypeInfo);
+bool IsStringObjectType(const Type &TypeInfo);
 int IsStrCalculation(char *Command);
 BYTE GetCalcId(const char *Command,int *pi);
@@ -518 +461 @@
                        char *values[255],long calc[255],long stack[255]);
 
-//NumOpe_GetType_Old.cpp
+//NumOpe_GetType.cpp
 int AutoBigCast(int BaseType,int CalcType);
 BOOL CheckCalcType(int idCalc,int *type,int sp);
-int NumOpe_GetType_Old( const char *Command, TYPEINFO *pBaseTypeInfo, LONG_PTR *plpIndex );
 bool NumOpe_GetType( const char *expression, const Type &baseType, Type &resultType );
 
@@ -529 +471 @@
 void SplitObjectName(const char *name,char *ObjectName,int *pRefType);
 bool SplitMemberName( const char *desc, char *object, char *member );
-int CallProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex);
-BOOL CallPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo);
-int GetReturnTypeOfProc(int idProc,void *pInfo,char *name,char *Parameter,LONG_PTR *plpRetIndex);
-BOOL GetReturnTypeOfPropertyMethod(char *variable,char *RightSide,TYPEINFO *pRetTypeInfo);
-bool GetReturnTypeOfIndexerGetterProc(CClass *pobj_Class,TYPEINFO &RetTypeInfo);
-BOOL CompareParameter(PARAMETER_INFO *ppi1,int pi_num1,PARAMETER_INFO *ppi2,int pi_num2);
-SubInfo *AddSubData(char *buffer,int NowLine,BOOL bVirtual,CClass *pobj_c,BOOL bStatic=0);
+bool CallProc( int kind, const void *pProc, const char *fullCallName, const char *lpszParms, Type &resultType, bool isCallOn = true );
+bool CallPropertyMethod( const char *variable, const char *rightSide, Type &resultType);
+bool GetReturnTypeOfPropertyMethod( const char *variable, const char *rightSide, Type &resultType );
+bool GetReturnTypeOfIndexerGetterProc( const CClass &objClass, Type &resultType );
+UserProc *AddSubData(char *buffer,int nowLine,BOOL bVirtual,CClass *pobj_c, bool isStatic = false );
 void GetSubInfo(void);
-void DeleteSubInfo(SubInfo **ppSubHash,char **ppMacroNames,int MacroNum);
+void DeleteSubInfo(UserProc **ppSubHash,char **ppMacroNames,int MacroNum);
 void DeleteDeclareInfo(void);
-int AddProcPtrInfo(char *buffer,DWORD dwProcType);
+int AddProcPtrInfo( char *buffer, DWORD dwProcType, int nowLine );
 void DeleteProcPtrInfo(void);
 
@@ -581 +521 @@
 //error.cpp
 void SetError(int ErrorNum,const char *KeyWord,int pos);
+void SetError(int ErrorNum,const string &keyWord,int pos);
 void SetError();
 void CompileMessage(char *buffer);
 bool CheckDifferentType(const int VarType,const LONG_PTR lpVarIndex,const int CalcType,const LONG_PTR lpCalcIndex,const char *pszFuncName,const int ParmNum);
+bool CheckDifferentType( const Type &varType,const Type &calcType,const char *pszFuncName,const int ParmNum);
 
 //Compile.cpp

BasicCompiler_Common/error.cpp

@@ -93 +93 @@
     //日本語
     ////////////////////
-    if(num==1) lstrcpy(msg,"文法が間違っています");
-    if(num==2) sprintf(msg,"左のオペランドが、左辺値になっていません");
+    if(num==1) lstrcpy(msg,"文法が間違っています。");
+    if(num==2) sprintf(msg,"左のオペランドが、左辺値になっていません。");
     //num==3は予約されています
-    if(num==4) sprintf(msg,"%sの相互関係が一致しません",tempKeyWord);
-    if(num==5) sprintf(msg,"ダブルクォートの数が一致しません");
-    if(num==6) sprintf(msg,"\"%s\" ジャンプ先が不正です",tempKeyWord);
-    if(num==7) lstrcpy(msg,"DLL名が長すぎます（拡張子を含め、16文字以下にして下さい）");
-    if(num==8) lstrcpy(msg,"コンパイラが認識できない文字コードが含まれています");
-    if(num==9) sprintf(msg,"型が違います");
-    if(num==10) sprintf(msg,"\"%s\" のパラメータ指定が間違っています",tempKeyWord);
-    if(num==11) sprintf(msg,"\"%s\" 型が違います",tempKeyWord);
-    if(num==12) sprintf(msg,"\"%s\" の使い方が不正です",tempKeyWord);
-    if(num==13) sprintf(msg,"\"%s\" を参照できません",tempKeyWord);
-    if(num==14) sprintf(msg,"\"%s\" 配列指定が不正です",tempKeyWord);
-    if(num==15) sprintf(msg,"\"%s\" はすでに定義されています",tempKeyWord);
-    if(num==16) sprintf(msg,"\"%s\" 配列、またはポインタ以外の変数に添え字が指定されています",tempKeyWord);
-    if(num==17) sprintf(msg,"リソース データが不正です");
-    if(num==18) sprintf(msg,"\"%s\"はポインタ変数型です。文字列演算を指定することはできません",tempKeyWord);
-    if(num==19) sprintf(msg,"\"%s\"は値参照型です。ByVal指定することはできません",tempKeyWord);
-    if(num==20) lstrcpy(msg,"全角スペースが含まれています（全角スペースはコンパイラが認識できないので、半角スペースまたはタブ文字にしてください）");
-    if(num==21) sprintf(msg,"If制御のブロック指定が不正です");
-    if(num==22) sprintf(msg,"\"%s\" に対する \"End %s\" が見つかりません",tempKeyWord,tempKeyWord);
-    if(num==23) sprintf(msg,"リソース ファイル \"%s\" の読み込みに失敗",tempKeyWord);
-    if(num==24) lstrcpy(msg,"Export指定の関数のパラメータには実体オブジェクトを利用することはできません（BytePtr型などを利用して下さい）");
-    if(num==27) sprintf(msg,"\"%s\" は定義されていません",tempKeyWord);
-    if(num==28) sprintf(msg,"構造体パラメータはポインタ参照にしてください(%s)",tempKeyWord);
-    if(num==29) sprintf(msg,"配列ポインタを要素と同時に引渡すときは、ポインタ参照（ByRef）にしてください");
+    if(num==4) sprintf(msg,"%sの相互関係が一致しません。",tempKeyWord);
+    if(num==5) sprintf(msg,"ダブルクォートの数が一致しません。");
+    if(num==6) sprintf(msg,"\"%s\" ジャンプ先が不正です。",tempKeyWord);
+    if(num==7) lstrcpy(msg,"DLL名が長すぎます（拡張子を含め、16文字以下にして下さい）。");
+    if(num==8) lstrcpy(msg,"コンパイラが認識できない文字コードが含まれています。");
+    if(num==9) sprintf(msg,"型が違います。");
+    if(num==10) sprintf(msg,"\"%s\" のパラメータ指定が間違っています。",tempKeyWord);
+    if(num==11) sprintf(msg,"\"%s\" 型が違います。",tempKeyWord);
+    if(num==12) sprintf(msg,"\"%s\" の使い方が不正です。",tempKeyWord);
+    if(num==13) sprintf(msg,"\"%s\" を参照できません。",tempKeyWord);
+    if(num==14) sprintf(msg,"\"%s\" 配列指定が不正です。",tempKeyWord);
+    if(num==15) sprintf(msg,"\"%s\" はすでに定義されています。",tempKeyWord);
+    if(num==16) sprintf(msg,"\"%s\" 配列、またはポインタ以外の変数に添え字が指定されています。",tempKeyWord);
+    if(num==17) sprintf(msg,"リソース データが不正です。");
+    if(num==18) sprintf(msg,"\"%s\"はポインタ変数型です。文字列演算を指定することはできません。",tempKeyWord);
+    if(num==19) sprintf(msg,"\"%s\"は値参照型です。ByVal指定することはできません。",tempKeyWord);
+    if(num==20) lstrcpy(msg,"全角スペースが含まれています（全角スペースはコンパイラが認識できないので、半角スペースまたはタブ文字にしてください）。");
+    if(num==21) sprintf(msg,"If制御のブロック指定が不正です。");
+    if(num==22) sprintf(msg,"\"%s\" に対する \"End %s\" が見つかりません。",tempKeyWord,tempKeyWord);
+    if(num==23) sprintf(msg,"リソース ファイル \"%s\" の読み込みに失敗。",tempKeyWord);
+    if(num==24) lstrcpy(msg,"Export指定の関数のパラメータには実体オブジェクトを利用することはできません（BytePtr型などを利用して下さい）。");
+    if(num==25) sprintf(msg,"DLL関数にオブジェクトを引き渡すことはできません(%s)。",tempKeyWord);
+    if(num==26) sprintf(msg,"\"%s\" 戻り値の型が指定されていません。",tempKeyWord);
+    if(num==27) sprintf(msg,"\"%s\" は定義されていません。",tempKeyWord);
+    if(num==28) sprintf(msg,"構造体パラメータは参照渡しにしてください(%s)。",tempKeyWord);
+    if(num==29) sprintf(msg,"配列ポインタを要素と同時に引渡すときは、ポインタ参照（ByRef）にしてください。");
     //num==30は予約されています
-    if(num==31) sprintf(msg,"\"%s\" は構造体です（メンバの参照はピリオド \".\" で区切ってください）",tempKeyWord);
-    if(num==32) sprintf(msg,"\"%s\" は構造体ポインタです（メンバの参照は \"->\" で区切ってください）",tempKeyWord);
-    if(num==33) sprintf(msg,"定数式にリテラル値、または定数以外のものが含まれています");
-    if(num==34) sprintf(msg,"定数はモジュールレベルで宣言して下さい");
-    if(num==38) sprintf(msg,"\"%s\" 戻り値が存在しないプロシージャです",tempKeyWord);
-    if(num==39) sprintf(msg,"\"%s\" はオブジェクトポインタではありません（\"->\" 参照はできません）",tempKeyWord);
-    if(num==40) lstrcpy(msg,"関数の戻り値にオブジェクトを指定することはできません");
-    if(num==41) lstrcpy(msg,"初期データが不正です");
-    if(num==42) lstrcpy(msg,"閉じカッコ \")\" の後に不正な文字が含まれています");
-    if(num==43) lstrcpy(msg,"ダブルクォートの後に不正な文字が含まれています");
-    if(num==45) sprintf(msg,"実数に対して \"%s\" 演算子は利用できません",tempKeyWord);
-    if(num==46) lstrcpy(msg,"配列の添え字に整数以外の値が与えられています");
-    if(num==47) lstrcpy(msg,"As演算子の右辺値に型名以外の識別子が指定されています");
-    if(num==48) sprintf(msg,"%s演算子に対して型名が指定されています",tempKeyWord);
-    if(num==49) lstrcpy(msg,"添え字に整数以外の型が指定されています");
-    if(num==50) sprintf(msg,"%sに変換できません",tempKeyWord);
-    if(num==51) lstrcpy(msg,"オブジェクト、構造体のアラインメント値は1,2,4,8,16のいずれかでなければなりません");
-    if(num==52) sprintf(msg,"\"%s\" オーバーロードを解決できません",tempKeyWord);
-    if(num==53) sprintf(msg,"\"%s\" 出力ファイルの書き込みに失敗しました。実行されている可能性があります",tempKeyWord);
+    if(num==31) sprintf(msg,"\"%s\" は構造体です（メンバの参照はピリオド \".\" で区切ってください）。",tempKeyWord);
+    if(num==32) sprintf(msg,"\"%s\" は構造体ポインタです（メンバの参照は \"->\" で区切ってください）。",tempKeyWord);
+    if(num==33) sprintf(msg,"定数式にリテラル値、または定数以外のものが含まれています。");
+    if(num==34) sprintf(msg,"定数はモジュールレベルで宣言して下さい。");
+    if(num==38) sprintf(msg,"\"%s\" 戻り値が存在しないプロシージャです。",tempKeyWord);
+    if(num==39) sprintf(msg,"\"%s\" はオブジェクトポインタではありません（\"->\" 参照はできません）。",tempKeyWord);
+    if(num==40) lstrcpy(msg,"DLL関数の戻り値としてオブジェクトを受け取ることはできません。");
+    if(num==41) lstrcpy(msg,"初期データが不正です。");
+    if(num==42) lstrcpy(msg,"閉じカッコ \")\" の後に不正な文字が含まれています。");
+    if(num==43) lstrcpy(msg,"ダブルクォートの後に不正な文字が含まれています。");
+    if(num==45) sprintf(msg,"実数に対して \"%s\" 演算子は利用できません。",tempKeyWord);
+    if(num==46) lstrcpy(msg,"配列の添え字に整数以外の値が与えられています。");
+    if(num==47) lstrcpy(msg,"As演算子の右辺値に型名以外の識別子が指定されています。");
+    if(num==48) sprintf(msg,"%s演算子に対して型名が指定されています。",tempKeyWord);
+    if(num==49) lstrcpy(msg,"添え字に整数以外の型が指定されています。");
+    if(num==50) sprintf(msg,"%sに変換できません。",tempKeyWord);
+    if(num==51) lstrcpy(msg,"オブジェクト、構造体のアラインメント値は1,2,4,8,16のいずれかでなければなりません。");
+    if(num==52) sprintf(msg,"\"%s\" オーバーロードを解決できません。",tempKeyWord);
+    if(num==53) sprintf(msg,"\"%s\" 出力ファイルの書き込みに失敗しました。実行されている可能性があります。",tempKeyWord);
     if(num==54) sprintf(msg,"対応する%sが存在しません。",tempKeyWord);
     if(num==55) sprintf(msg,"\"%s\" は対応するForステートメントで利用されるカウンタ変数ではありません。",tempKeyWord);
@@ -152 +154 @@
 
     //オブジェクト関連
-    if(num==102) sprintf(msg,"\"%s\" オブジェクトは定義されていません",tempKeyWord);
-    if(num==103) sprintf(msg,"\"%s\" メンバは定義されていません",tempKeyWord);
-    if(num==104) sprintf(msg,"\"%s\" 参照方法が違います",tempKeyWord);
-    if(num==105) sprintf(msg,"\"%s\" 自身のクラスを継承することはできません",tempKeyWord);
-    if(num==106) sprintf(msg,"\"%s\" クラスは定義されていません",tempKeyWord);
-    if(num==107) sprintf(msg,"Privateメンバ \"%s\" にアクセスすることはできません",tempKeyWord);
-    if(num==108) sprintf(msg,"Protectedメンバ \"%s\" にアクセスすることはできません",tempKeyWord);
-    if(num==109) sprintf(msg,"Privateメンバ関数 \"%s\" を呼び出すことはできません",tempKeyWord);
-    if(num==110) sprintf(msg,"Protectedメンバ関数 \"%s\" を呼び出すことはできません",tempKeyWord);
-    if(num==111) lstrcpy(msg,"InheritsはClass定義内の先頭に記述する必要があります");
-    if(num==112) sprintf(msg,"\"%s\" はクラス型ではないため、初期パラメータを指定することはできません",tempKeyWord);
-    if(num==113) sprintf(msg,"\"%s\" コンストラクタへ渡すパラメータが不正です",tempKeyWord);
-    if(num==114) lstrcpy(msg,"デストラクタはパラメータを持てません");
-    if(num==115) lstrcpy(msg,"コンストラクタ及びデストラクタは戻り値を持てません");
-    if(num==116) lstrcpy(msg,"コンストラクタ及びデストラクタはパブリックアクセスにしなければなりません");
-    if(num==117) lstrcpy(msg,"デストラクタの名前が \"~クラス名\" になっていません");
-    if(num==118) lstrcpy(msg,"参照する基底クラスが存在しません");
-    if(num==119) sprintf(msg,"\"%s\" メンバは基底クラスで定義されていません",tempKeyWord);
-    if(num==120) lstrcpy(msg,"デストラクトするオブジェクトの型が不明です");
-    if(num==121) lstrcpy(msg,"New演算子にはクラス以外の型を指定できません");
-    if(num==122) lstrcpy(msg,"Delete演算子にポインタ以外の型が指定されています");
-    if(num==123) lstrcpy(msg,"ループ継承が行われました");
-    if(num==124) lstrcpy(msg,"循環参照が行われました");
+    if(num==102) sprintf(msg,"\"%s\" オブジェクトは定義されていません。",tempKeyWord);
+    if(num==103) sprintf(msg,"\"%s\" メンバは定義されていません。",tempKeyWord);
+    if(num==104) sprintf(msg,"\"%s\" 参照方法が違います。",tempKeyWord);
+    if(num==105) sprintf(msg,"\"%s\" 自身のクラスを継承することはできません。",tempKeyWord);
+    if(num==106) sprintf(msg,"\"%s\" クラスは定義されていません。",tempKeyWord);
+    if(num==107) sprintf(msg,"Privateメンバ \"%s\" にアクセスすることはできません。",tempKeyWord);
+    if(num==108) sprintf(msg,"Protectedメンバ \"%s\" にアクセスすることはできません。",tempKeyWord);
+    if(num==109) sprintf(msg,"Privateメンバ関数 \"%s\" を呼び出すことはできません。",tempKeyWord);
+    if(num==110) sprintf(msg,"Protectedメンバ関数 \"%s\" を呼び出すことはできません。",tempKeyWord);
+    if(num==111) lstrcpy(msg,"InheritsはClass定義内の先頭に記述する必要があります。");
+    if(num==112) sprintf(msg,"\"%s\" はクラス型ではないため、初期パラメータを指定することはできません。",tempKeyWord);
+    if(num==113) sprintf(msg,"\"%s\" コンストラクタへ渡すパラメータが不正です。",tempKeyWord);
+    if(num==114) lstrcpy(msg,"デストラクタはパラメータを持てません。");
+    if(num==115) lstrcpy(msg,"コンストラクタ及びデストラクタは戻り値を持てません。");
+    if(num==116) lstrcpy(msg,"コンストラクタ及びデストラクタはパブリックアクセスにしなければなりません。");
+    if(num==117) lstrcpy(msg,"デストラクタの名前が \"~クラス名\" になっていません。");
+    if(num==118) lstrcpy(msg,"参照する基底クラスが存在しません。");
+    if(num==119) sprintf(msg,"\"%s\" メンバは基底クラスで定義されていません。",tempKeyWord);
+    if(num==120) lstrcpy(msg,"デストラクトするオブジェクトの型が不明です。");
+    if(num==121) lstrcpy(msg,"New演算子にはクラス以外の型を指定できません。");
+    if(num==122) lstrcpy(msg,"Delete演算子にポインタ以外の型が指定されています。");
+    if(num==123) lstrcpy(msg,"ループ継承が行われました。");
+    if(num==124) lstrcpy(msg,"循環参照が行われました。");
     if(num==125) sprintf(msg,"\"%s\" は抽象クラスです。インスタンス化することはできません。",tempKeyWord);
     if(num==126) lstrcpy(msg,"オペレータのオーバーロードをクラスの外で行うことはできません。");
@@ -186 +188 @@
 
     //Enum関連
-    if(num==150) sprintf(msg,"\"%s\" 値が定義されていません",tempKeyWord);
-    if(num==151) sprintf(msg,"\"%s\" 列挙リストに登録されていません",tempKeyWord);
+    if(num==150) sprintf(msg,"\"%s\" 値が定義されていません。",tempKeyWord);
+    if(num==151) sprintf(msg,"\"%s\" 列挙リストに登録されていません。",tempKeyWord);
 
     //リンカ
-    if(num==200) sprintf(msg,"\"%s\" 未解決です (リンク エラー)",tempKeyWord);
-    if(num==201) sprintf(msg,"\"%s\" の読み込みに失敗",tempKeyWord);
+    if(num==200) sprintf(msg,"\"%s\" 未解決です (リンク エラー)。",tempKeyWord);
+    if(num==201) sprintf(msg,"\"%s\" の読み込みに失敗。",tempKeyWord);
 
     //原因不明
@@ -268 +270 @@
     return 1;
 }
+void SetError(int ErrorNum,const string &keyWord,int pos){
+    SetError( ErrorNum, keyWord.c_str(), pos );
+}
 void SetError(int num,const char *KeyWord,int pos){
     extern HANDLE hHeap;
@@ -523 +528 @@
     return true;
 }
+bool CheckDifferentType( const Type &varType,const Type &calcType,const char *pszFuncName,const int ParmNum){
+    return CheckDifferentType(
+        varType.GetBasicType(),
+        varType.GetIndex(),
+        calcType.GetBasicType(),
+        calcType.GetIndex(),
+        pszFuncName,
+        ParmNum );
+}

BasicCompiler_Common/gc.cpp

@@ -12 +12 @@
 void InitGCVariables(void){
     char temporary[255];
-    int type;
-    RELATIVE_VAR RelativeVar;
-    LONG_PTR lpIndex;
 
 
@@ -24 +21 @@
     OpcodeDim(temporary,0);
 
-    GetVarOffsetReadWrite("_System_gc_GlobalRoot_StartPtr",&type,&RelativeVar,&lpIndex);
+    Type type;
+    RELATIVE_VAR RelativeVar;
+    GetVarOffsetReadWrite("_System_gc_GlobalRoot_StartPtr",&RelativeVar,type);
 
     //mov rax,ptr
@@ -44 +43 @@
     OpcodeDim(temporary,0);
 
-    GetVarOffsetReadWrite("_System_gc_GlobalRoot_Size",&type,&RelativeVar,&lpIndex);
+    GetVarOffsetReadWrite("_System_gc_GlobalRoot_Size",&RelativeVar,type);
 
     //mov rax,ptr
@@ -65 +64 @@
     OpcodeDim(temporary,0);
 
-    GetVarOffsetReadWrite("_System_gc_StackRoot_StartPtr",&type,&RelativeVar,&lpIndex);
+    GetVarOffsetReadWrite("_System_gc_StackRoot_StartPtr",&RelativeVar,type);
 
     //mov rax,rsp

BasicCompiler_Common/hash.cpp

@@ -7 +7 @@
 #endif
 
-int hash_default(char *name){
+int hash_default(const char *name){
     int key;
 
@@ -35 +35 @@
 }
 
-DECLAREINFO *GetDeclareHash(char *name){
+DllProc *GetDeclareHash(char *name){
     //ハッシュ値を取得
     int key;
@@ -41 +41 @@
 
     //格納位置を取得
-    extern DECLAREINFO **ppDeclareHash;
-    DECLAREINFO *pdi;
-    pdi=ppDeclareHash[key];
-    while(pdi){
-        if(lstrcmp(pdi->name,name)==0) break;
+    extern DllProc **ppDeclareHash;
+    DllProc *pDllProc;
+    pDllProc=ppDeclareHash[key];
+    while(pDllProc){
+        if( pDllProc->GetName() == name ){
+            break;
+        }
 
-        pdi=pdi->pNextData;
+        pDllProc=pDllProc->pNextData;
     }
 
-    return pdi;
+    return pDllProc;
 }
 
-void GetOverloadSubHash( const char *lpszName, std::vector<SubInfo *> &subs ){
+void GetOverloadSubHash( const char *lpszName, std::vector<UserProc *> &subs ){
     char name[VN_SIZE];
 
@@ -72 +74 @@
 
         bool isStatic = false;
-        CClass *pobj_c;
+        const CClass *pobj_c = NULL;
         if(lstrcmpi(ObjName,"Super")==0){
             //クラスメンバ関数内から基底クラスの呼び出し
@@ -79 +81 @@
         else{
             //"->"によってオブジェクトを指定する通常のメンバ関数呼び出し
-            int type = GetVarType(ObjName,(LONG_PTR *)&pobj_c,0);
-            if(!(NATURAL_TYPE(type)==DEF_OBJECT)){
+            Type type;
+            GetVarType(ObjName,type,0);
+            pobj_c = &type.GetClass();
+            if((NATURAL_TYPE(type.GetBasicType())!=DEF_OBJECT)){
                 pobj_c=pobj_DBClass->check(ObjName);
                 if( pobj_c ){
@@ -123 +127 @@
 
         //格納位置を取得
-        extern SubInfo **ppSubHash;
-        SubInfo *psi;
-        psi=ppSubHash[key];
-        while(psi){
-            if(!psi->pobj_ParentClass){
-                if(lstrcmp(psi->name,name)==0){
-                    subs.push_back( psi );
+        extern UserProc **ppSubHash;
+        UserProc *pUserProc;
+        pUserProc=ppSubHash[key];
+        while(pUserProc){
+            if(!pUserProc->GetParentClassPtr()){
+                if( pUserProc->GetName() == name ){
+                    subs.push_back( pUserProc );
                 }
             }
 
-            psi=psi->pNextData;
+            pUserProc=pUserProc->pNextData;
         }
 
@@ -140 +144 @@
 
 //オーバーロードされていない関数を取得（昔のコンパイラソースコードとの互換性保持）
-SubInfo *GetSubHash(const char *lpszName,BOOL bError){
-    std::vector<SubInfo *> subs;
+UserProc *GetSubHash(const char *lpszName,BOOL bError){
+    std::vector<UserProc *> subs;
     GetOverloadSubHash(lpszName,subs);
 
     //関数が存在しないとき
     if(subs.size() == 0){
+        if(bError){
+            SetError(3,lpszName,cp);
+        }
         return 0;
     }
@@ -154 +161 @@
     }
 
-    SubInfo *psi;
-    psi = subs[0];
+    UserProc *pUserProc;
+    pUserProc = subs[0];
 
-    return psi;
+    return pUserProc;
 }
-SubInfo *GetMethodHash(char *ObjectName,char *MethodName,char *Parameter,BOOL bError){
+UserProc *GetMethodHash(const char *ObjectName,const char *MethodName,const char *Parameter,BOOL bError){
     char temporary[VN_SIZE];
     sprintf(temporary,"%s.%s",ObjectName,MethodName);
 
-    std::vector<SubInfo *> subs;
-    SubInfo *psi;
+    std::vector<UserProc *> subs;
+    UserProc *pUserProc;
     GetOverloadSubHash(temporary,subs);
 
@@ -173 +180 @@
 
     //オーバーロードを解決
-    psi=OverloadSolutionWithStrParam(temporary,subs,Parameter,ObjectName,NULL);
+    pUserProc=OverloadSolutionWithStrParam(temporary,subs,Parameter,ObjectName);
 
-    return psi;
+    return pUserProc;
 }