Changeset 75 in dev for BasicCompiler64

Timestamp:

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

Author:

dai_9181

Message:

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

Location:

BasicCompiler64

Files:

• BasicCompiler.vcproj (modified) (8 diffs)
• CParameter.cpp (modified) (26 diffs)
• Compile_Calc.cpp (modified) (8 diffs)
• Compile_CallProc.cpp (modified) (25 diffs)
• Compile_Func.cpp (modified) (15 diffs)
• Compile_Object.cpp (modified) (8 diffs)
• Compile_ProcOp.cpp (modified) (35 diffs)
• Compile_Set_Var.cpp (modified) (6 diffs)
• Compile_Statement.cpp (modified) (34 diffs)
• Compile_Var.cpp (modified) (63 diffs)
• MakePeHdr.cpp (modified) (23 diffs)
• NumOpe.cpp (modified) (39 diffs)
• NumOpe_Arithmetic.cpp (modified) (1 diff)
• Opcode.h (modified) (10 diffs)
• OperatorProc.cpp (modified) (21 diffs)
• WatchList.cpp (modified) (30 diffs)
• amd64_main.cpp (modified) (1 diff)
• increment.cpp (modified) (11 diffs)
• varlist.cpp (modified) (37 diffs)

BasicCompiler64/BasicCompiler.vcproj

@@ -22 +22 @@
             UseOfMFC="0"
             ATLMinimizesCRunTimeLibraryUsage="false"
-            CharacterSet="0"
+            CharacterSet="2"
             >
             <Tool
@@ -52 +52 @@
                 MinimalRebuild="true"
                 BasicRuntimeChecks="0"
-                RuntimeLibrary="3"
+                RuntimeLibrary="1"
                 UsePrecompiledHeader="0"
                 PrecompiledHeaderFile=".\Debug/BasicCompiler.pch"
@@ -125 +125 @@
             UseOfMFC="0"
             ATLMinimizesCRunTimeLibraryUsage="false"
-            CharacterSet="0"
+            CharacterSet="2"
             >
             <Tool
@@ -322 +322 @@
             UseOfMFC="0"
             ATLMinimizesCRunTimeLibraryUsage="false"
-            CharacterSet="0"
+            CharacterSet="2"
             >
             <Tool
@@ -473 +473 @@
                 >
                 <File
+                    RelativePath="..\BasicCompiler_Common\Parameter.h"
+                    >
+                </File>
+                <File
+                    RelativePath="..\BasicCompiler_Common\Procedure.h"
+                    >
+                </File>
+                <File
                     RelativePath="..\BasicCompiler_Common\Type.h"
+                    >
+                </File>
+                <File
+                    RelativePath="..\BasicCompiler_Common\Variable.h"
                     >
                 </File>
@@ -1522 +1534 @@
                     >
                     <File
-                        RelativePath="..\BasicCompiler_Common\Variable.cpp"
-                        >
-                    </File>
-                    <File
-                        RelativePath="..\BasicCompiler_Common\Variable.h"
+                        RelativePath="..\BasicCompiler_Common\VariableOpe.cpp"
+                        >
+                    </File>
+                    <File
+                        RelativePath="..\BasicCompiler_Common\VariableOpe.h"
                         >
                     </File>
@@ -1545 +1557 @@
                     Name="Procedure"
                     >
-                    <File
-                        RelativePath="..\BasicCompiler_Common\Parameter.h"
-                        >
-                    </File>
                     <File
                         RelativePath="..\BasicCompiler_Common\ParamImpl.cpp"
@@ -1563 +1571 @@
                 >
                 <File
+                    RelativePath="..\BasicCompiler_Common\Procedure.cpp"
+                    >
+                </File>
+                <File
                     RelativePath="..\BasicCompiler_Common\Type.cpp"
+                    >
+                </File>
+                <File
+                    RelativePath="..\BasicCompiler_Common\Variable.cpp"
                     >
                 </File>

BasicCompiler64/CParameter.cpp

@@ -2 +2 @@
 #include "opcode.h"
 
-int ParamImpl::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
+int ParamImpl::NewTempParameters( const string &procName, const Parameters &params, int SecondParmNum ){
+    if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
+
     ///////////////////////////////////////////////////////
     // 一時オブジェクトをあらかじめスタックに積んでおく
@@ -12 +14 @@
 
     BOOL bEllipse;
-    if(pi_num){
-        if(ppi[pi_num-1].type==DEF_ELLIPSE) bEllipse=1;
+    if(params.size()){
+        if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
         else bEllipse=0;
     }
@@ -21 +23 @@
         useTempParameters[i2] = false;
 
-        if(bEllipse&&i2<=pi_num-2) bEllipse=0;
-
-        if(i2==0&&ppi[i2].name){
-            if(lstrcmp(ppi[i2].name,"_System_LocalThis")==0){
+        if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
+
+        if(i2==0){
+            if( params[i2]->GetVarName() == "_System_LocalThis" ){
                 //オブジェクトメンバの第一パラメータのThisポインタ
                 continue;
             }
         }
-        if((i2==0||i2==1)&&ppi[i2].name){
-            if(lstrcmp(ppi[i2].name,FuncName)==0){
+        if( i2==0||i2==1 ){
+            if( params[i2]->GetVarName() == procName ){
                 //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
                 continue;
@@ -36 +38 @@
         }
 
-        TYPEINFO DummyTypeInfo;
+        Type dummyType;
         BOOL bByVal;
         if(bEllipse){
-            DummyTypeInfo.type=NumOpe_GetType(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
+            NumOpe_GetType( Parms[i2], Type(), dummyType );
             bByVal=1;
         }
         else{
-            DummyTypeInfo.type=ppi[i2].type;
-            DummyTypeInfo.u.lpIndex=ppi[i2].u.index;
-            bByVal=ppi[i2].bByVal;
+            dummyType = *params[i2];
+            bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
         }
 
@@ -56 +57 @@
             }
 
-            LONG_PTR lpVarIndex;
-            if( GetVarType( Parms[i2], &lpVarIndex, FALSE ) == -1 ){
+            if( !GetVarType( Parms[i2], Type(), FALSE ) ){
                 //変数ではないとき
                 int reg = REG_RAX;
-                int type = NumOpe( &reg, Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
-
-                if( type != DEF_STRUCT ){
+                Type calcType;
+                NumOpe( &reg, Parms[i2], dummyType, calcType );
+
+                if( !calcType.IsStruct() ){
                     //一時参照を作成
                     pobj_sf->push( reg );
@@ -76 +77 @@
 
                 bool result = CheckDifferentType(
-                    DummyTypeInfo.type,
-                    DummyTypeInfo.u.lpIndex,
-                    type,
-                    lpVarIndex,
-                    FuncName,
+                    dummyType,
+                    calcType,
+                    procName.c_str(),
                     i2);
 
@@ -87 +86 @@
                     useTempObject = true;
 
-                    types[i2].type = type;
-                    types[i2].u.lpIndex = lpVarIndex;
+                    types[i2] = calcType;
                 }
             }
@@ -104 +102 @@
     for(int i2=ParmsNum-1;i2>=0;i2--){
         if( useTempParameters[i2] ){
-            if( types[i2].type == DEF_STRUCT ){
+            if( types[i2].IsStruct() ){
                 // 構造体の一時メモリ
 
@@ -112 +110 @@
 
                 //call free
-                extern SubInfo *pSub_free;
+                extern UserProc *pSub_free;
                 op_call(pSub_free);
             }
@@ -123 +121 @@
 }
 
-void ParamImpl::SetStructParameter(int reg,CClass *pobj_Class,LPSTR Parameter){
+void ParamImpl::SetStructParameter( int reg, const Type &baseType, const char *expression ){
     //////////////////////////////////////////////////////
     /////    レジスタ資源のバックアップ
@@ -129 +127 @@
     //////////////////////////////////////////////////////
 
-        int object_size = pobj_Class->GetSize();
+        int object_size = baseType.GetClass().GetSize();
 
         //mov rcx,object_size
@@ -135 +133 @@
 
         //call calloc
-        extern SubInfo *pSub_calloc;
+        extern UserProc *pSub_calloc;
         op_call(pSub_calloc);
 
@@ -144 +142 @@
         pobj_sf->push(REG_R11);
 
-        TYPEINFO BaseType={DEF_STRUCT,(LONG_PTR)pobj_Class};
-        TYPEINFO CalcType;
-        CalcType.type=NumOpe_GetType(Parameter,&BaseType,&CalcType.u.lpIndex);
-
-        /*
-        TODO: 消す
-        if( pobj_Class->GetCopyConstructorMethod()
-            && CalcType.type==DEF_OBJECT&&CalcType.u.pobj_Class==pobj_Class){
-            ////////////////////////////////////
-            // コピーコンストラクタを呼び出す
-            ////////////////////////////////////
-
-            BOOL bUseHeap;
-            int temp_reg=REG_RDX;
-            CalcType.type=NumOpe(&temp_reg,Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
-
-            if(bUseHeap){
-                //mov r14,rdx
-                op_mov_RR(REG_R14,REG_RDX);
-            }
-
-            //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
-            pobj_sf->ref(REG_R11);
-
-            //mov rcx,this
-            op_mov_RR(REG_RCX,REG_R11);
-
-            //call constructor
-            op_call(pobj_Class->GetCopyConstructorMethod()->psi);
-
-
-            if(bUseHeap){
-                FreeTempObject(REG_R14,pobj_Class);
-            }
-        }
-        else{
-            if( pobj_Class->GetConstructorMethod() ){
-                ////////////////////////////////
-                // コンストラクタを呼び出す
-                ////////////////////////////////
-
-                //mov rcx,this
-                op_mov_RR(REG_RCX,REG_R11);
-
-                //call constructor
-                op_call(pobj_Class->GetConstructorMethod()->psi);
-            }
-            */
-
-
-            BOOL bUseHeap;
-            int temp_reg=REG_RAX;
-            CalcType.type=NumOpe(&temp_reg,Parameter,DEF_STRUCT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
-
-
-            //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
-            pobj_sf->ref(REG_R11);
-
-
-            RELATIVE_VAR RelativeVar;
-            RelativeVar.bOffsetOffset=0;
-            RelativeVar.offset=0;
-            RelativeVar.dwKind=VAR_DIRECTMEM;
-
-            SetStructVariableFromRax((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,&RelativeVar,bUseHeap);
-
-        //}
+
+        Type calcType;
+        BOOL bUseHeap;
+        int temp_reg=REG_RAX;
+        NumOpe( &temp_reg,
+            expression,
+            baseType,
+            calcType,
+            &bUseHeap );
+
+
+        //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
+        pobj_sf->ref(REG_R11);
+
+
+        RELATIVE_VAR RelativeVar;
+        RelativeVar.bOffsetOffset=0;
+        RelativeVar.offset=0;
+        RelativeVar.dwKind=VAR_DIRECTMEM;
+
+        SetStructVariableFromRax(
+            baseType,
+            calcType,
+            &RelativeVar,bUseHeap);
+
 
         //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
@@ -225 +181 @@
 
 
-void ParamImpl::SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
+void ParamImpl::SetParameter( const string &procName, const Parameters &params, int SecondParmNum ){
+    if( SecondParmNum == -1 ) SecondParmNum = (int)params.size();
+
     ///////////////////////////////////////////////////////////
     // パラメータをレジスタ及びスタックフレームにセット
@@ -232 +190 @@
 
     BOOL bEllipse;
-    if(pi_num){
-        if(ppi[pi_num-1].type==DEF_ELLIPSE) bEllipse=1;
+    if( params.size() ){
+        if(params[params.size()-1]->GetBasicType()==DEF_ELLIPSE) bEllipse=1;
         else bEllipse=0;
     }
@@ -240 +198 @@
     BOOL bHas_System_LocalThis=0;
     if(ParmsNum>=1){
-        if(lstrcmp(ppi[0].name,"_System_LocalThis")==0)
+        if( params[0]->GetVarName() == "_System_LocalThis" ){
             bHas_System_LocalThis=1;
+        }
     }
 
     //戻り値用の変数名を取得
-    const char *lpszVarNameToReturn = (FuncName[0]==1&&FuncName[1]==ESC_OPERATOR)?"_System_ReturnValue":FuncName;
+    const char *lpszVarNameToReturn = (procName[0]==1&&procName[1]==ESC_OPERATOR)?"_System_ReturnValue":procName.c_str();
 
     //パラメータをレジスタとスタックに格納
-    int CalcType;
-    LONG_PTR lpCalcIndex;
-    BOOL bCalcUseHeap;
     int ParmSize=0;
     int reg,temp_reg;
     RELATIVE_VAR RelativeVar;
     for(i2=ParmsNum-1;i2>=0;i2--){
-        if(bEllipse&&i2<=pi_num-2) bEllipse=0;
-
-        if(i2==0&&ppi[i2].name){
-            if(lstrcmp(ppi[i2].name,"_System_LocalThis")==0){
+        if(bEllipse&&i2<=(int)params.size()-2) bEllipse=0;
+
+        if(i2==0){
+            if( params[i2]->GetVarName() == "_System_LocalThis" ){
                 //オブジェクトメンバの第一パラメータのThisポインタ
                 continue;
             }
         }
-        if((i2==0||i2==1)&&ppi[i2].name){
-            if(lstrcmp(ppi[i2].name,lpszVarNameToReturn)==0){
+        if(i2==0||i2==1){
+            if( params[i2]->GetVarName() == lpszVarNameToReturn ){
                 //オブジェクトメンバの第一または第二パラメータの戻り値用オブジェクト
                 continue;
@@ -270 +226 @@
         }
 
-        TYPEINFO DummyTypeInfo;
+        Type dummyType;
         BOOL bByVal;
         if(bEllipse){
-            DummyTypeInfo.type=NumOpe_GetType(Parms[i2],NULL,&DummyTypeInfo.u.lpIndex);
+            NumOpe_GetType( Parms[i2], Type(), dummyType );
             bByVal=1;
         }
         else{
-            DummyTypeInfo.type=ppi[i2].type;
-            DummyTypeInfo.u.lpIndex=ppi[i2].u.index;
-            bByVal=ppi[i2].bByVal;
+            dummyType = *params[i2];
+            bByVal = ( params[i2]->IsRef() == false ) ? TRUE:FALSE;
         }
 
         int xmm_temp_sw=0;
-        if(IsRealNumberType(DummyTypeInfo.type)&&bByVal){
+        if(dummyType.IsReal()&&bByVal){
             //実数型
             if(i2==0) reg=REG_XMM0;
@@ -308 +263 @@
             if(Parms[i2][0]==1&&Parms[i2][1]==ESC_BYVAL){
                 char temp2[255];
-                sprintf(temp2,"%s関数の第%dパラメータ",FuncName,i2+1);
+                sprintf(temp2,"%s関数の第%dパラメータ",procName,i2+1);
                 SetError(19,temp2,cp);
                 continue;
             }
 
-            if(DummyTypeInfo.type==DEF_STRUCT){
-                SetStructParameter(reg,DummyTypeInfo.u.pobj_Class,Parms[i2]);
+            if( dummyType.IsStruct() ){
+                SetStructParameter( reg, dummyType, Parms[i2] );
                 goto next;
             }
@@ -321 +276 @@
 
             extern LONG_PTR ProcPtr_BaseIndex;
-            LONG_PTR back_ProcPtr_BaseIndex;
-            back_ProcPtr_BaseIndex=ProcPtr_BaseIndex;
-            if(DummyTypeInfo.type==DEF_PTR_PROC) ProcPtr_BaseIndex=DummyTypeInfo.u.lpIndex;
-            else ProcPtr_BaseIndex=-1;
-
-            CalcType=NumOpe(&temp_reg,Parms[i2],DummyTypeInfo.type,DummyTypeInfo.u.lpIndex,&lpCalcIndex,&bCalcUseHeap);
+            LONG_PTR back_ProcPtr_BaseIndex = ProcPtr_BaseIndex;
+            if( dummyType.IsProcPtr() ){
+                ProcPtr_BaseIndex = dummyType.GetIndex();
+            }
+            else{
+                ProcPtr_BaseIndex=-1;
+            }
+
+            BOOL bCalcUseHeap;
+            Type calcType;
+            if( !NumOpe( &temp_reg, Parms[i2], dummyType, calcType, &bCalcUseHeap ) ){
+                break;
+            }
 
             ProcPtr_BaseIndex=back_ProcPtr_BaseIndex;
 
-            if(CalcType==-1) break;
-
-            if(CalcType==DEF_OBJECT){
-                if( DummyTypeInfo.type != DEF_OBJECT
+            if( calcType.IsObject() ){
+                if( !dummyType.IsObject()
                     ||
-                    DummyTypeInfo.type == DEF_OBJECT &&
-                    !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpCalcIndex ) ){
+                    dummyType.IsObject() &&
+                    !dummyType.GetClass().IsEqualsOrSubClass( &calcType.GetClass() ) ){
                         //キャスト演算子のオーバーロードに対応する
-                        CallCastOperatorProc(reg,CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
+                        CallCastOperatorProc( reg, calcType, bCalcUseHeap,dummyType );
                 }
             }
@@ -344 +304 @@
 
             if(bEllipse){
-                if(IsRealNumberType(CalcType)){
+                if( calcType.IsReal() ){
                     //整数レジスタへコピー
                     //※cdeclの拡張パラメータは実数の場合も汎用レジスタで引渡し
@@ -358 +318 @@
                     }
                 }
-                else if(IsWholeNumberType(CalcType)){
+                else if( calcType.IsWhole() ){
                     //整数型の場合は、64ビットへ拡張する
-                    ExtendTypeTo64(CalcType,temp_reg);
+                    ExtendTypeTo64( calcType.GetBasicType(), temp_reg );
                 }
             }
@@ -369 +329 @@
                 else i3=i2;
                 CheckDifferentType(
-                    DummyTypeInfo.type,
-                    DummyTypeInfo.u.lpIndex,
-                    CalcType,
-                    lpCalcIndex,
-                    FuncName,
+                    dummyType,
+                    calcType,
+                    procName.c_str(),
                     i3);
 
-
-                if(DummyTypeInfo.type==DEF_DOUBLE){
+                if( dummyType.IsDouble() ){
                     //Double型へ変換
-                    ChangeTypeToXmm_Double(CalcType,reg,temp_reg);
-                }
-                else if(DummyTypeInfo.type==DEF_SINGLE){
+                    ChangeTypeToXmm_Double(calcType.GetBasicType(),reg,temp_reg);
+                }
+                else if( dummyType.IsSingle() ){
                     //Single型へ変換
-                    ChangeTypeToXmm_Single(CalcType,reg,temp_reg);
-                }
-                else if(IsWholeNumberType(DummyTypeInfo.type)){
+                    ChangeTypeToXmm_Single(calcType.GetBasicType(),reg,temp_reg);
+                }
+                else if( dummyType.IsWhole() ){
                     //実数型 → 整数型
-                    ChangeTypeToWhole(CalcType,DummyTypeInfo.type,reg,temp_reg);
+                    ChangeTypeToWhole(calcType.GetBasicType(),dummyType.GetBasicType(),reg,temp_reg);
                 }
             }
@@ -397 +354 @@
 
                 temp_reg=reg;
-                CalcType=NumOpe(&temp_reg,Parms[i2]+2,0,0,&lpCalcIndex);
-                if(CalcType==-1) break;
-
-                int ptr_type;
-                ptr_type=GetPtrType(DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
+                Type calcType;
+                if( !NumOpe(&temp_reg, Parms[i2]+2, dummyType, calcType) ){
+                    break;
+                }
+
+                dummyType.PtrLevelUp();
 
                 //型チェック
@@ -407 +365 @@
                 else i3=i2;
                 CheckDifferentType(
-                    ptr_type,
-                    DummyTypeInfo.u.lpIndex,
-                    CalcType,
-                    lpCalcIndex,
-                    FuncName,
+                    dummyType,
+                    calcType,
+                    procName.c_str(),
                     i3);
 
-                if(IsRealNumberType(CalcType)){
+                if( calcType.IsReal() ){
                     //実数型 → 整数型
-                    ChangeTypeToWhole(CalcType,DEF_QWORD,reg,temp_reg);
+                    ChangeTypeToWhole( calcType.GetBasicType(), DEF_QWORD,reg,temp_reg);
                 }
             }
@@ -428 +384 @@
                 else{
                     //変数のアドレスを取得
-                    int VarType;
-                    LONG_PTR lpVarIndex;
+                    Type varType;
                     if(GetVarOffset(
                         false,
                         false,
                         Parms[i2],
-                        &VarType,
                         &RelativeVar,
-                        &lpVarIndex)){
-
-                            if(DummyTypeInfo.type!=DEF_ANY){
+                        varType)){
+
+                            if( !dummyType.IsAny() ){
                                 //型チェックを行う
-                                if(DummyTypeInfo.type==VarType){
-                                    if(DummyTypeInfo.type==DEF_OBJECT){
-                                        if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
+                                if( dummyType.GetBasicType() == varType.GetBasicType() ){
+                                    if( dummyType.IsObject() ){
+                                        if( !dummyType.GetClass().IsEqualsOrSubClass( &varType.GetClass() ) ){
                                             SetError(11,Parms[i2],cp);
                                         }
                                     }
-                                    else if(DummyTypeInfo.type==DEF_STRUCT){
-                                        if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
+                                    else if( dummyType.IsStruct() ){
+                                        if( !dummyType.GetClass().IsEquals( &varType.GetClass() ) ){
                                             SetError(11,Parms[i2],cp);
                                         }
                                     }
                                 }
-                                else if((VarType&FLAG_PTR)&&((VarType^FLAG_PTR)==DummyTypeInfo.type)){
+                                else if( (varType.GetBasicType()&FLAG_PTR)
+                                    &&((varType.GetBasicType()^FLAG_PTR)==dummyType.GetBasicType())){
                                     //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
                                 }
@@ -494 +449 @@
 
     //パラメータが収まるだけのスタックフレームを確保
-    pobj_sf->parameter_allocate(pi_num*sizeof(_int64)+   sizeof(_int64)/*ret用*/  );
+    pobj_sf->parameter_allocate((int)params.size()*sizeof(_int64)+   sizeof(_int64)/*ret用*/  );
 }
 void ParamImpl::BackupParameter(int pi_num){

BasicCompiler64/Compile_Calc.cpp

@@ -84 +84 @@
             }
 
-            LONG_PTR lp;
-            if(GetVarType(variable,&lp,0)!=-1){
+            if(GetVarType(variable,Type(),0)){
                 //変数リストに該当したとき
                 SetError(1,NULL,cp);
@@ -129 +128 @@
 
     char ObjName[VN_SIZE],array_element[VN_SIZE];
-    CClass *pobj_c;
     GetArrayElement(variable,ObjName,array_element);
     if(array_element[0]){
-        i2=GetVarType(ObjName,(LONG_PTR *)&pobj_c,0);
-        if(i2==DEF_OBJECT){
+        Type varType;
+        if( GetVarType(ObjName,varType,0) && varType.IsObject() ){
             char temporary[VN_SIZE];
             sprintf(temporary,"%s.%c%c%c",ObjName,1,ESC_OPERATOR,CALC_ARRAY_SET);
@@ -141 +139 @@
 
             int idProc;
-            void *pInfo;
-            idProc=GetProc(temporary,&pInfo);
+            void *pProc;
+            idProc=GetProc(temporary,(void **)&pProc);
             if(idProc){
-                CallProc(idProc,pInfo,temporary,temp2,NULL);
+                CallProc(idProc,pProc,temporary,temp2,Type());
                 return;
             }
@@ -161 +159 @@
     ////////////////////////////////////////
 
-    int VarType,CalcType;
-    LONG_PTR lpVarIndex,lpCalcIndex;
-    BOOL bCalcUseHeap;
+    Type varType;
 
     //型を識別
-    VarType=GetVarType(variable,&lpVarIndex,0);
-    if(VarType==-1){
+    if( !GetVarType(variable,varType,false) ){
 
         // プロパティ用のメソッドを呼び出す
-        if(!CallPropertyMethod(variable,Command+i+1,NULL)){
+        if(!CallPropertyMethod( variable, Command+i+1, Type() )){
             //エラーを表示
-            GetVarType(variable,&lpVarIndex,1);
+            GetVarType(variable,varType,true);
         }
 
@@ -179 +174 @@
 
     extern LONG_PTR ProcPtr_BaseIndex;
-    if(VarType==DEF_PTR_PROC) ProcPtr_BaseIndex=lpVarIndex;
+    if(varType.IsProcPtr()) ProcPtr_BaseIndex=varType.GetIndex();
     else ProcPtr_BaseIndex=-1;
 
     //NumOpe...（rax、またはxmm0に答えが格納される）
     int reg=REG_RAX;
-    CalcType=NumOpe(&reg,Command+i+1,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
-
-    if(reg!=REG_RAX&&IsWholeNumberType(CalcType)){
+    BOOL bCalcUseHeap;
+    Type calcType;
+    if( !NumOpe(&reg,Command+i+1,varType,calcType,&bCalcUseHeap) ){
+        return;
+    }
+
+    if(reg!=REG_RAX&&calcType.IsWhole()||
+        varType.IsNull()||calcType.IsNull()){
         SetError(300,NULL,cp);
     }
-
-    if(VarType==-1||CalcType==-1) return;
 
     //結果を格納しているレジスタをブロッキング
@@ -199 +197 @@
     if(!GetVarOffsetReadWrite(
         variable,
-        &VarType,
         &VarRelativeVar,
-        &lpVarIndex,
-        NULL)) return;
+        varType)) return;
 
     //レジスタのブロッキングを解除
     pobj_BlockReg->clear();
 
-    if(VarType&FLAG_PTR){
+    if(varType.GetBasicType()&FLAG_PTR){
         SetError(14,variable,cp);
         return;
     }
 
-    if(VarType==DEF_STRUCT ){
+    if( varType.IsStruct() ){
         //構造体インスタンスへの代入
-        SetStructVariableFromRax(lpVarIndex,CalcType,lpCalcIndex,&VarRelativeVar,bCalcUseHeap);
-        return;
-    }
-
-    if(CalcType==DEF_OBJECT && (CalcType!=VarType || lpCalcIndex!=lpVarIndex) ){
+        SetStructVariableFromRax(varType,calcType,&VarRelativeVar,bCalcUseHeap);
+        return;
+    }
+
+    if( calcType.IsObject() && !calcType.Equals( varType ) ){
         //キャスト演算子のオーバーロードに対応する
-        CallCastOperatorProc(REG_RAX,CalcType,lpCalcIndex,bCalcUseHeap,VarType,lpVarIndex);
+        CallCastOperatorProc(REG_RAX,calcType,bCalcUseHeap,varType);
     }
 
@@ -228 +224 @@
     /////////////////////////////////
 
-    CheckDifferentType(VarType,lpVarIndex,CalcType,lpCalcIndex,0,0);
+    CheckDifferentType(varType,calcType,0,0);
 
 
@@ -234 +230 @@
     // rax（実数はxmm0）の内容を変数にコピー
     /////////////////////////////////////////////////
-    SetVariableFromRax(VarType,CalcType,&VarRelativeVar);
+    SetVariableFromRax(varType.GetBasicType(),calcType.GetBasicType(),&VarRelativeVar);
 }
-
-// TODO: 消す
-/*
-void SetRefVariable( const char *varname, const char *expression ){
-    ////////////////////////////////////////
-    // 変数のタイプ型を識別して、演算を行う
-    ////////////////////////////////////////
-
-    int VarType,CalcType;
-    LONG_PTR lpVarIndex,lpCalcIndex;
-    BOOL bCalcUseHeap;
-
-    //型を識別
-    VarType=GetVarType(varname,&lpVarIndex,0);
-    if(VarType==-1){
-        SetError(300,NULL,cp);
-        return;
-    }
-
-    extern LONG_PTR ProcPtr_BaseIndex;
-    if(VarType==DEF_PTR_PROC) ProcPtr_BaseIndex=lpVarIndex;
-    else ProcPtr_BaseIndex=-1;
-
-    //NumOpe...（rax、またはxmm0に答えが格納される）
-    int reg=REG_RAX;
-    CalcType=NumOpe(&reg,expression,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
-
-    //結果を格納しているレジスタをブロッキング
-    pobj_BlockReg->lock(reg);
-
-    if(VarType==-1||CalcType==-1) return;
-
-    //変数アドレスを取得
-    RELATIVE_VAR VarRelativeVar;
-    if(!GetVarOffsetReadWrite(
-        varname,
-        &VarType,
-        &VarRelativeVar,
-        &lpVarIndex)) return;
-
-    //レジスタのブロッキングを解除
-    pobj_BlockReg->clear();
-
-    if(VarType&FLAG_PTR){
-        SetError(14,varname,cp);
-        return;
-    }
-
-    if( VarType == DEF_OBJECT
-        && (VarRelativeVar.dwKind == VAR_REFLOCAL || VarRelativeVar.dwKind == VAR_REFGLOBAL ) ){
-        // 参照型オブジェクトへの代入（初期化）はポインタ変数と同様の処理に値する
-        PTR_LEVEL_UP( VarType );
-
-        if( VarRelativeVar.dwKind == VAR_REFGLOBAL ){
-            VarRelativeVar.dwKind = VAR_GLOBAL;
-        }
-        else if( VarRelativeVar.dwKind == VAR_REFLOCAL ){
-            VarRelativeVar.dwKind = VAR_LOCAL;
-        }
-
-        if( CalcType == DEF_OBJECT ){
-            //右辺値が実体オブジェクトのときは、参照をコピー
-            PTR_LEVEL_UP( CalcType );
-        }
-    }
-    else{
-        SetError(300,NULL,cp);
-    }
-
-
-    /////////////////////////////////
-    // 右辺、左辺の型チェックを行う
-    /////////////////////////////////
-
-    CheckDifferentType(VarType,lpVarIndex,CalcType,lpCalcIndex,0,0);
-
-
-    /////////////////////////////////////////////////
-    // rax（実数はxmm0）の内容を変数にコピー
-    /////////////////////////////////////////////////
-    SetVariableFromRax(VarType,CalcType,&VarRelativeVar);
-}
-*/

BasicCompiler64/Compile_CallProc.cpp

@@ -8 +8 @@
 void Call_DebugSys_SaveContext(){
     //call _System_GetEip
-    extern SubInfo *pSub_System_GetEip;
+    extern UserProc *pSub_System_GetEip;
     op_call(pSub_System_GetEip);
 
@@ -18 +18 @@
 
     //call _DebugSys_SaveContext
-    extern SubInfo *pSub_DebugSys_SaveContext;
+    extern UserProc *pSub_DebugSys_SaveContext;
     op_call(pSub_DebugSys_SaveContext);
 }
@@ -32 +32 @@
 
 
-int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex){
-    extern HANDLE hHeap;
-    int i;
-
+bool Opcode_CallProcPtr( const char *variable, const char *lpszParms,ProcPointer *pProcPointer){
 
     extern BOOL bDebugCompile;
@@ -49 +46 @@
     //パラメータオブジェクトを生成
     ParamImpl *pobj_parameter=0;
-    pobj_parameter=new ParamImpl(Parameter);
+    pobj_parameter=new ParamImpl(lpszParms);
 
     //エラーチェック
-    if( !pobj_parameter->ErrorCheck(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum) ){
+    if( !pobj_parameter->ErrorCheck(variable,pProcPointer->Params() ) ){
         //パラメータにエラーがあるときは処理を終える
-        return pi->ReturnType;
+        return false;
     }
 
     //スタックフレームに存在する既存のパラメータをバックアップ
-    pobj_parameter->BackupParameter(pi->ParmNum);
+    pobj_parameter->BackupParameter( (int)pProcPointer->Params().size() );
 
     //一時オブジェクトを生成
-    pobj_parameter->NewTempParameters( variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum );
+    pobj_parameter->NewTempParameters( variable,pProcPointer->Params() );
 
     //レジスタ、スタックフレームにセット
-    pobj_parameter->SetParameter(variable,pi->pParmInfo,pi->ParmNum,pi->ParmNum);
+    pobj_parameter->SetParameter(variable,pProcPointer->Params() );
 
 
 
     RELATIVE_VAR RelativeVar;
-    LONG_PTR lp;
-    GetVarOffsetReadOnly(variable,&i,&RelativeVar,&lp);
+    GetVarOffsetReadOnly(variable,&RelativeVar,Type());
     SetVarPtrToReg(REG_RAX,&RelativeVar);
 
@@ -88 +84 @@
 
     //スタックフレームに存在する既存のパラメータを復元
-    pobj_parameter->RestoreParameter(pi->ParmNum);
+    pobj_parameter->RestoreParameter( (int)pProcPointer->Params().size() );
 
     //パラメータオブジェクトを破棄
     delete pobj_parameter;
 
-    return pi->ReturnType;
+    return true;
 }
 
-void Opcode_CallProc(const char *Parameter,SubInfo *psi,DWORD dwFlags,char *ObjectName,int RefType){
+bool Opcode_CallProc(const char *Parameter,UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType){
     int i2;
 
-    if(psi->dwType==SUBTYPE_MACRO){
-        if(lstrcmpi(psi->name,"Print")==0){
+    if( pUserProc->IsMacro() ){
+        if( lstrcmpi( pUserProc->GetName().c_str(), "Print" ) == 0 ){
             Opcode_Print(Parameter,0);
-            return;
-        }
-        if(lstrcmpi(psi->name,"Input")==0){
+            return true;
+        }
+        if( lstrcmpi( pUserProc->GetName().c_str(), "Input" ) == 0 ){
             Opcode_Input(Parameter);
-            return;
-        }
-        if(lstrcmpi(psi->name,"Write")==0){
+            return true;
+        }
+        if( lstrcmpi( pUserProc->GetName().c_str(), "Write" ) == 0 ){
             Opcode_Print(Parameter,1);
-            return;
-        }
-    }
-
-    psi->bUse=1;
+            return true;
+        }
+    }
+
+    pUserProc->Using();
 
     bool isStatic = false;
-    CClass *pobj_c = NULL;
+    const CClass *pobj_c = NULL;
     CMethod *pMethod = NULL;
-    if(psi->pobj_ParentClass){
+    if( pUserProc->GetParentClassPtr() ){
         //クラスのメンバ関数を呼び出す場合はアクセスチェックを行う
         if(ObjectName[0]){
@@ -128 +124 @@
             else{
                 //"->"によってオブジェクトを指定する通常のメンバ関数呼び出し
-                int type = GetVarType(ObjectName,(LONG_PTR *)&pobj_c,0);
-                if(!(NATURAL_TYPE(type)==DEF_OBJECT)){
+                Type varType;
+                GetVarType( ObjectName, varType, false );
+                pobj_c = &varType.GetClass();
+                if( NATURAL_TYPE( varType.GetBasicType() ) != DEF_OBJECT ){
                     pobj_c=pobj_DBClass->check(ObjectName);
                     if( pobj_c ){
@@ -143 +141 @@
             if(dwFlags&PROCFLAG_NEW){
                 //New演算子によるコンストラクタ呼び出し
-                pobj_c=psi->pobj_ParentClass;
+                pobj_c=pUserProc->GetParentClassPtr();
             }
             else{
@@ -156 +154 @@
         /////////////////////////////////
         pMethod = NULL;
-        if( ! isStatic ) pMethod = pobj_c->GetMethodInfo( psi );
+        if( ! isStatic ) pMethod = pobj_c->GetMethodInfo( pUserProc );
         if( ! pMethod ){
             //動的メソッドが取得できなかったときは静的メソッドを当たる
-            pMethod = pobj_c->GetStaticMethodInfo( psi );
+            pMethod = pobj_c->GetStaticMethodInfo( pUserProc );
             if( !pMethod ){
                 SetError(300,NULL,cp);
-                return;
+                return false;
             }
 
@@ -180 +178 @@
                 //同一クラスオブジェクトの場合はプライベートアクセスを容認する
                 if(dwAccess==ACCESS_NON){
-                    SetError(109,psi->name,cp);
-                    return;
+                    SetError(109,pUserProc->GetName(),cp);
+                    return false;
                 }
             }
@@ -187 +185 @@
                 if(dwAccess==ACCESS_PRIVATE||
                     dwAccess==ACCESS_NON){
-                    SetError(109,psi->name,cp);
-                    return;
+                    SetError(109,pUserProc->GetName(),cp);
+                    return false;
                 }
                 if(dwAccess==ACCESS_PROTECTED){
-                    SetError(110,psi->name,cp);
-                    return;
+                    SetError(110,pUserProc->GetName(),cp);
+                    return false;
                 }
             }
@@ -199 +197 @@
             //クラス内部からの呼び出し（継承によるACCESS_NONのみをエラーとする）
             if(dwAccess==ACCESS_NON){
-                SetError(109,psi->name,cp);
-                return;
+                SetError(109,pUserProc->GetName(),cp);
+                return false;
             }
         }
@@ -211 +209 @@
 
     char temporary[VN_SIZE]={0};
-    if( psi->pobj_ParentClass && isStatic == false ){
+    if( pUserProc->GetParentClassPtr() && isStatic == false ){
         //_System_LocalThis（第一パラメータ）のダミーを作成
         lstrcpy(temporary,"0,");
@@ -234 +232 @@
 
     //エラーチェック
-    if( !pobj_parameter->ErrorCheck(psi->name,psi->realParams,psi->SecondParmNum) ){
+    if( !pobj_parameter->ErrorCheck(pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetSecondParmNum() ) ){
         //パラメータにエラーがあるときは処理を終える
-        return;
-    }
-
-    if(psi->dwType==SUBTYPE_MACRO){
+        return false;
+    }
+
+    if(pUserProc->IsMacro()){
         //マクロ関数の場合は、パラメータ省略を考慮する
-        pobj_parameter->MacroParameterSupport(psi->realParams);
+        pobj_parameter->MacroParameterSupport( pUserProc->RealParams() );
     }
 
     //スタックフレームに存在する既存のパラメータをバックアップ
-    pobj_parameter->BackupParameter(psi->RealParmNum);
+    pobj_parameter->BackupParameter( (int)pUserProc->RealParams().size() );
 
     //一時オブジェクトを生成
-    pobj_parameter->NewTempParameters( psi->name,psi->realParams,psi->RealSecondParmNum );
+    pobj_parameter->NewTempParameters( pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetRealSecondParmNum() );
 
     //レジスタ、スタックフレームにセット
-    pobj_parameter->SetParameter(psi->name,psi->realParams,psi->RealSecondParmNum);
-
-    if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
+    pobj_parameter->SetParameter(pUserProc->GetName(),pUserProc->RealParams(),pUserProc->GetRealSecondParmNum() );
+
+    if(pUserProc->ReturnType().IsStruct() ){
         //////////////////////////////////////////////////////
         // 戻り値に構造体インスタンスを持つ場合
@@ -265 +263 @@
         //////////////////////////////////////////////////////
 
-            int object_size = psi->u.Return_pobj_c->GetSize();
+            int object_size = pUserProc->ReturnType().GetClass().GetSize();
 
             //mov rcx,object_size
@@ -271 +269 @@
 
             //call calloc
-            extern SubInfo *pSub_calloc;
+            extern UserProc *pSub_calloc;
             op_call(pSub_calloc);
 
@@ -282 +280 @@
         }////////////////////////////////////////////
 
-        if( psi->pobj_ParentClass && isStatic == false ){
+        if( pUserProc->GetParentClassPtr() && isStatic == false ){
             //mov rdx,r13
             op_mov_RR(REG_RDX,REG_R13);
@@ -293 +291 @@
 
 
-    if( psi->pobj_ParentClass && isStatic == false ){
+    if( pUserProc->GetParentClassPtr() && isStatic == false ){
         ///////////////////////////////
         // メンバ関数の場合
@@ -305 +303 @@
                 if( pMethod->isConst ){
                     //Constアクセスが可能なメソッドの場合
-                    if( !GetVarOffsetReadOnly( ObjectName, &i2, &RelativeVar, 0 ) ) return;
+                    if( !GetVarOffsetReadOnly( ObjectName, &RelativeVar, Type() ) ){
+                        return false;
+                    }
                 }
                 else{
                     //Constアクセスが不可能なメソッドの場合
-                    if( !GetVarOffsetReadWrite( ObjectName, &i2, &RelativeVar, 0 ) ) return;
+                    if( !GetVarOffsetReadWrite( ObjectName, &RelativeVar, Type() ) ){
+                        return false;
+                    }
                 }
 
@@ -334 +336 @@
     }
 
-    if(psi->bVirtual){
+    if( pUserProc->IsVirtual() ){
         //仮想関数（オブジェクトメソッド）呼び出し
         //pObj->func_table->func1
@@ -343 +345 @@
         op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
 
-        i2 = pobj_c->GetFuncNumInVtbl( psi );
+        i2 = pobj_c->GetFuncNumInVtbl( pUserProc );
 
         //call qword ptr[r11+func_index]
@@ -364 +366 @@
 
         //call ProcAddr
-        op_call(psi);
+        op_call(pUserProc);
     }
 
     /* 64コンパイラでは不要
-    if(pdi->bCdecl){
+    if(pDllProc->bCdecl){
         //add esp,ParmSize
     }*/
@@ -380 +382 @@
 
     //スタックフレームに存在する既存のパラメータを復元
-    pobj_parameter->RestoreParameter(psi->RealParmNum);
+    pobj_parameter->RestoreParameter( (int)pUserProc->RealParams().size() );
 
     //パラメータオブジェクトを破棄
     delete pobj_parameter;
+
+    return true;
 }
 
-int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex){
-    char *temporary;
-
-    temporary=(char *)HeapAlloc(hHeap,0,lstrlen(Parameter)+1);
+bool Opcode_CallDllProc( const char *lpszParms, DllProc *pDllProc ){
 
     extern BOOL bDebugCompile;
     extern BOOL bDebugSupportProc;
-    if(bDebugCompile&&bDebugSupportProc==0&&lstrcmp(pdi->name,"DebugBreak")!=0)
+    if(bDebugCompile&&bDebugSupportProc==0&& pDllProc->GetName() != "DebugBreak" ){
         Call_DebugSys_SaveContext();
-
+    }
 
 
@@ -404 +405 @@
     //パラメータオブジェクトを生成
     ParamImpl *pobj_parameter=0;
-    pobj_parameter=new ParamImpl(Parameter);
+    pobj_parameter=new ParamImpl(lpszParms);
 
     //エラーチェック
-    if( !pobj_parameter->ErrorCheck(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum) ){
+    if( !pobj_parameter->ErrorCheck( pDllProc->GetName(), pDllProc->Params() ) ){
         //パラメータにエラーがあるときは処理を終える
-        return pdi->ReturnType;
+        return false;
     }
 
     //スタックフレームに存在する既存のパラメータをバックアップ
-    pobj_parameter->BackupParameter(pdi->ParmNum);
+    pobj_parameter->BackupParameter( (int)pDllProc->Params().size() );
 
     //一時オブジェクトを生成
-    pobj_parameter->NewTempParameters( pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum );
+    pobj_parameter->NewTempParameters( pDllProc->GetName(), pDllProc->Params() );
 
     //レジスタ、スタックフレームにセット
-    pobj_parameter->SetParameter(pdi->name,pdi->pParmInfo,pdi->ParmNum,pdi->ParmNum);
+    pobj_parameter->SetParameter(pDllProc->GetName(), pDllProc->Params() );
 
 
@@ -429 +430 @@
 
     //call dword ptr[ImportTable]
-    op_call( pdi );
+    op_call( pDllProc );
 
     /* 64コンパイラでは不要
-    if(pdi->bCdecl){
+    if(pDllProc->bCdecl){
         //add esp,ParmSize
     }*/
@@ -440 +441 @@
 
     //スタックフレームに存在する既存のパラメータを復元
-    pobj_parameter->RestoreParameter(pdi->ParmNum);
+    pobj_parameter->RestoreParameter( (int)pDllProc->Params().size() );
 
     //パラメータオブジェクトを破棄
     delete pobj_parameter;
 
-    if(plpIndex) *plpIndex=pdi->u.ReturnIndex;
-
-    HeapDefaultFree(temporary);
-
-    return pdi->ReturnType;
+    return true;
 }

BasicCompiler64/Compile_Func.cpp

@@ -40 +40 @@
 }
 void Opcode_Func_Len( const char *Parameter ){
-    int type,TypeSize;
-    LONG_PTR lpIndex;
     BOOL bArrayHead;
-
-    type=GetVarType(Parameter,&lpIndex,0);
 
     const char *tempParm=Parameter;
     char temporary[VN_SIZE];
     char temp2[32];
-    if(type==-1){
+    Type type;
+    if( !GetVarType(Parameter,type,0) ){
         sprintf(temporary,"_System_DummyStr2=%s",Parameter);
         OpcodeCalc(temporary);
@@ -57 +54 @@
 
         extern CClass *pobj_StringClass;
-        type=DEF_OBJECT;
-        lpIndex=(LONG_PTR)pobj_StringClass;
-    }
-
-    TYPEINFO TypeInfo={type,lpIndex};
-    if(IsStringObjectType(TypeInfo)){
+        type.SetType( DEF_OBJECT, pobj_StringClass );
+    }
+
+    if( type.IsStringObject() ){
         //Stringオブジェクトの場合
         sprintf(temporary,"%s.Length",tempParm);
 
         int reg=REG_RAX;
-        NumOpe(&reg,temporary,0,0,NULL,NULL);
+        NumOpe(&reg,temporary,Type(),Type(),NULL);
         return;
     }
@@ -74 +69 @@
     int SubScripts[MAX_ARRAYDIM];
     RELATIVE_VAR RelativeVar;
-    if(!GetVarOffsetReadOnly(tempParm,&type,&RelativeVar,&lpIndex,SubScripts)) return;
-
-
-    if(type&FLAG_PTR){
-        type&=~FLAG_PTR;
+    if(!GetVarOffsetReadOnly(tempParm,&RelativeVar,type,SubScripts)) return;
+
+
+    if(type.GetBasicType()&FLAG_PTR){
+        type.SetBasicType( type.GetBasicType() & ( ~FLAG_PTR ) );
 
         bArrayHead=1;
@@ -84 +79 @@
     else bArrayHead=0;
 
-    TypeSize=GetTypeSize(type,lpIndex);
-
-    if(bArrayHead) TypeSize*=JumpSubScripts(SubScripts);
+    int typeSize = type.GetSize();
+
+    if(bArrayHead) typeSize*=JumpSubScripts(SubScripts);
 
     //mov rax,TypeSize
-    op_mov_RV(sizeof(_int64),REG_RAX,TypeSize);
+    op_mov_RV(sizeof(_int64),REG_RAX,typeSize);
 
     return;
@@ -95 +90 @@
 void Opcode_Func_AddressOf( const char *name ){
     extern int cp;
-    SubInfo *psi;
+    UserProc *pUserProc;
 
     extern LONG_PTR ProcPtr_BaseIndex;
@@ -101 +96 @@
         //左辺の型にのっとり、オーバーロードを解決
 
-        std::vector<SubInfo *> subs;
+        std::vector<UserProc *> subs;
         GetOverloadSubHash( name, subs );
         if( subs.size() == 0 ){
@@ -109 +104 @@
 
         //オーバーロードを解決
-        extern PROCPTRINFO *pProcPtrInfo;
-        psi=OverloadSolution(name,subs,pProcPtrInfo[ProcPtr_BaseIndex].pParmInfo,pProcPtrInfo[ProcPtr_BaseIndex].ParmNum,NULL);
-
-        if(!psi){
+        extern ProcPointer **ppProcPointer;
+        pUserProc=OverloadSolution(name,subs,ppProcPointer[ProcPtr_BaseIndex]->Params(), Type() );
+
+        if(!pUserProc){
             SetError(27,name,cp);
             return;
@@ -118 +113 @@
     }
     else{
-        psi=GetSubHash(name);
-        if(!psi){
+        pUserProc=GetSubHash(name);
+        if(!pUserProc){
             SetError(27,name,cp);
             return;
@@ -125 +120 @@
     }
 
-
-    if(psi->bVirtual){
+    if( pUserProc->IsVirtual() ){
         ///////////////////////////////
         // 仮想関数の場合
@@ -142 +136 @@
             else{
                 RELATIVE_VAR RelativeVar;
-                int type;
-                if(!GetVarOffsetReadOnly(ObjectName,&type,&RelativeVar,(LONG_PTR *)&pobj_c)) return;
+                Type type;
+                if(!GetVarOffsetReadOnly(ObjectName,&RelativeVar,type)) return;
                 SetVarPtrToReg(REG_RCX,&RelativeVar);
 
                 //参照タイプが整合しているかをチェック
-                if(type!=RefType) SetError(104,ObjectName,cp);
-
-                if(type==DEF_PTR_OBJECT){
+                if(type.GetBasicType()!=RefType) SetError(104,ObjectName,cp);
+
+                if(type.IsObjectPtr()){
                     //mov rcx,qword ptr[rcx]
                     op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
@@ -172 +166 @@
         op_mov_RM(sizeof(_int64),REG_R11,REG_RCX,0,MOD_BASE);
 
-        int i2 = pobj_c->GetFuncNumInVtbl( psi );
+        int i2 = pobj_c->GetFuncNumInVtbl( pUserProc );
 
         //mov rax,qword ptr[r11+func_index]
@@ -188 +182 @@
         op_mov_RV(sizeof(_int64),REG_RAX,0);
         obp-=sizeof(long);
-        pobj_SubAddrSchedule->add(psi,0);
+        pobj_SubAddrSchedule->add(pUserProc,0);
         obp+=sizeof(long);
     }
 
-    psi->bUse=1;
+    pUserProc->Using();
 }
 void Opcode_Func_SizeOf( const char *Parameter ){
@@ -210 +204 @@
     op_mov_RV(sizeof(_int64),REG_RAX,size);
 }
-void Opcode_Func_VarPtr( const char *Parameter, TYPEINFO &ReturnTypeInfo ){
+void Opcode_Func_VarPtr( const char *Parameter, Type &resultType, bool isCallOn ){
+    if( isCallOn == false ){
+        // 戻り値の型を取得するだけ
+
+        //変数のアドレスを取得
+        if(!GetVarType( Parameter, resultType, true )) return;
+
+        resultType.PtrLevelUp();
+
+        return;
+    }
+
     RELATIVE_VAR RelativeVar;
 
     //変数のアドレスを取得
-    if(!GetVarOffsetReadOnly( Parameter, &ReturnTypeInfo.type, &RelativeVar, &ReturnTypeInfo.u.lpIndex )) return;
-
-    int beforeType = ReturnTypeInfo.type;
-
-    PTR_LEVEL_UP( ReturnTypeInfo.type );
+    if(!GetVarOffsetReadOnly( Parameter, &RelativeVar, resultType )) return;
+
+    int beforeType = resultType.GetBasicType();
+
+    resultType.PtrLevelUp();
 
     SetVarPtrToReg(REG_RAX,&RelativeVar);
@@ -230 +235 @@
 }
 void Opcode_Func_GetPtrData( const char *Parameter, const int type ){
-    int i2;
-
     int reg=REG_RAX;
-    i2=NumOpe(&reg,Parameter,0,0,0);
-    if(!IsWholeNumberType(i2)){
-        extern int cp;
+    Type tempType;
+    if( !NumOpe(&reg,Parameter,Type(),tempType) ){
+        return;
+    }
+    if(!tempType.IsWhole()){
         SetError(11,Parameter,cp);
         return;
@@ -254 +259 @@
 }
 
-void Opcode_CallFunc( const char *Parameter, const int FuncNum, TYPEINFO &ReturnTypeInfo ){
+bool Opcode_CallFunc( const char *Parameter, const int FuncNum, Type &resultType, bool isCallOn ){
     switch(FuncNum){
         case FUNC_LEN:
-            Opcode_Func_Len(Parameter);
-            ReturnTypeInfo.type = DEF_LONG;
+            if( isCallOn ) Opcode_Func_Len(Parameter);
+            resultType.SetBasicType( DEF_LONG );
             break;
         case FUNC_ADDRESSOF:
-            Opcode_Func_AddressOf(Parameter);
-            ReturnTypeInfo.type = DEF_PTR_VOID;
+            if( isCallOn ) Opcode_Func_AddressOf(Parameter);
+            resultType.SetBasicType( DEF_PTR_VOID );
             break;
         case FUNC_SIZEOF:
-            Opcode_Func_SizeOf(Parameter);
-            ReturnTypeInfo.type = DEF_LONG;
+            if( isCallOn ) Opcode_Func_SizeOf(Parameter);
+            resultType.SetBasicType( DEF_LONG );
             break;
         case FUNC_VARPTR:
-            Opcode_Func_VarPtr( Parameter, ReturnTypeInfo );
+            Opcode_Func_VarPtr( Parameter, resultType, isCallOn );
             break;
 
         case FUNC_GETDOUBLE:
-            Opcode_Func_GetPtrData(Parameter,DEF_DOUBLE);
-            ReturnTypeInfo.type = DEF_DOUBLE;
+            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DOUBLE);
+            resultType.SetBasicType( DEF_DOUBLE );
             break;
         case FUNC_GETSINGLE:
-            Opcode_Func_GetPtrData(Parameter,DEF_SINGLE);
-            ReturnTypeInfo.type = DEF_SINGLE;
+            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_SINGLE);
+            resultType.SetBasicType( DEF_SINGLE );
             break;
         case FUNC_GETQWORD:
-            Opcode_Func_GetPtrData(Parameter,DEF_QWORD);
-            ReturnTypeInfo.type = DEF_QWORD;
+            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_QWORD);
+            resultType.SetBasicType( DEF_QWORD );
             break;
         case FUNC_GETDWORD:
-            Opcode_Func_GetPtrData(Parameter,DEF_DWORD);
-            ReturnTypeInfo.type = DEF_DWORD;
+            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_DWORD);
+            resultType.SetBasicType( DEF_DWORD );
             break;
         case FUNC_GETWORD:
-            Opcode_Func_GetPtrData(Parameter,DEF_WORD);
-            ReturnTypeInfo.type = DEF_WORD;
+            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_WORD);
+            resultType.SetBasicType( DEF_WORD );
             break;
         case FUNC_GETBYTE:
-            Opcode_Func_GetPtrData(Parameter,DEF_BYTE);
-            ReturnTypeInfo.type = DEF_BYTE;
-            break;
-    }
-}
+            if( isCallOn ) Opcode_Func_GetPtrData(Parameter,DEF_BYTE);
+            resultType.SetBasicType( DEF_BYTE );
+            break;
+        default:
+            return false;
+    }
+    return true;
+}

BasicCompiler64/Compile_Object.cpp

@@ -2 +2 @@
 #include "opcode.h"
 
-void _call_constructor(CClass *pobj_c,const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
+void _call_constructor( const CClass *pobj_c,const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
     ////////////////////////////
     // コンストラクタの呼び出し
@@ -32 +32 @@
     ////////////////////////
 
-    std::vector<SubInfo *> subs;
+    std::vector<UserProc *> subs;
     pobj_c->EnumMethod( pobj_c->name, subs );
 
-    SubInfo *psi;
+    UserProc *pUserProc;
     if( subs.size() > 0 ){
         //オーバーロードを解決
-        psi=OverloadSolutionWithStrParam(pobj_c->name,
-            subs,CreateParameter,"",NULL);
-
-        if(!psi) return;
+        pUserProc=OverloadSolutionWithStrParam(pobj_c->name,
+            subs,CreateParameter,"");
+
+        if(!pUserProc) return;
     }
 
     //コンストラクタを呼び出す
     Opcode_CallProc(CreateParameter,
-        psi,
+        pUserProc,
         PROCFLAG_NEW,"",0);
 
@@ -73 +73 @@
     }
 }
-void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter, const TYPEINFO &baseTypeInfo ){
+void Operator_New( const CClass &classObj, const char *objectSizeStr, const char *parameter, const Type &baseType ){
     int typeSize = classObj.GetSize();
 
@@ -86 +86 @@
 
         int reg=REG_RAX;
-        int type = NumOpe(&reg,objectSizeStr,0,0,0);
-        if(!IsWholeNumberType(type)) SetError(49,NULL,cp);
+        Type tempType;
+        NumOpe(&reg,objectSizeStr,Type(),tempType);
+        if( !tempType.IsWhole() ) SetError(49,NULL,cp);
 
         //※添え字上限値であることを考慮
@@ -117 +118 @@
     }
 
-    if( baseTypeInfo.type == DEF_OBJECT ){
-        //DeleteはGCで処理
+    if( baseType.IsObject() ){
+        // オブジェクト インスタンス
+        // ※DeleteはGCで処理
 
         //call _System_GC_malloc_ForObject
-        extern SubInfo *pSub_System_GC_malloc_ForObject;
+        extern UserProc *pSub_System_GC_malloc_ForObject;
         op_call(pSub_System_GC_malloc_ForObject);
     }
     else{
-        //明示的なDeleteが必要
+        // オブジェクトポインタ
+        // ※明示的なDeleteが必要
 
         //call _System_GC_malloc_ForObjectPtr
-        extern SubInfo *pSub_System_GC_malloc_ForObjectPtr;
+        extern UserProc *pSub_System_GC_malloc_ForObjectPtr;
         op_call(pSub_System_GC_malloc_ForObjectPtr);
     }
@@ -162 +165 @@
     op_mov_RV(sizeof(_int64),REG_RCX,0);
     obp-=sizeof(long);
-    pobj_SubAddrSchedule->add(method->psi,0);
-    method->psi->bUse=1;
+    pobj_SubAddrSchedule->add(method->pUserProc,0);
+    method->pUserProc->Using();
     obp+=sizeof(long);
 
@@ -190 +193 @@
     pobj_sf->pop(REG_RAX);
 }
-int Operator_New(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo ){
-    char TypeName[VN_SIZE],CreateParameter[VN_SIZE],objectSizeStr[VN_SIZE];
-    int i,i2;
-
-    i=0;
-
-    if(Parameter[0]=='['){
-        i=GetStringInBracket(objectSizeStr,Parameter);
-
-        SlideString(objectSizeStr+1,-1);
-        objectSizeStr[i-2]=0;
-    }
-    else objectSizeStr[0]=0;
-
-    for(i2=0;;i++,i2++){
-        if(Parameter[i]=='('){
-            TypeName[i2]=0;
-
-            //コンストラクタに渡すパラメータを取得
-            i2=GetStringInPare(CreateParameter,Parameter+i);
-            RemoveStringPare(CreateParameter);
-            i+=i2;
-            if(Parameter[i]!='\0'){
-                SetError(42,NULL,cp);
-                return 0;
-            }
-            break;
-        }
-        TypeName[i2]=Parameter[i];
-        if(Parameter[i]=='\0'){
-            CreateParameter[0]=0;
-            break;
-        }
-    }
-
-    int type;
-    type=GetTypeFixed(TypeName,plpIndex);
-    if(type==-1){
-        SetError(3,TypeName,cp);
-        return 0;
-    }
-
-    if(type!=DEF_OBJECT){
-        ////////////////////////
-        // 通常のデータ型の場合
-        ////////////////////////
-
-        SetError(121,NULL,cp);
-        return 0;
-    }
-
-    CClass *pobj_c;
-    pobj_c=(CClass *)*plpIndex;
-
-    Operator_New( *pobj_c, objectSizeStr, CreateParameter, baseTypeInfo );
-
-    if( baseTypeInfo.type == DEF_OBJECT ){
-        return DEF_OBJECT;
-    }
-    return DEF_PTR_OBJECT;
-}
-
 void OpcodeDelete(const char *Parameter, bool isSweeping){
-    int type;
-
     int reg=REG_RAX;
-    type=NumOpe(&reg,Parameter,0,0,0);
-    if(type==-1) return;
-    if(!(type==DEF_PTR_OBJECT||type==DEF_PTR_VOID)) SetError(122,NULL,cp);
+    Type tempType;
+    if( !NumOpe(&reg,Parameter,Type(),tempType) ){
+        return;
+    }
+    if(!( tempType.IsObjectPtr() || tempType.IsVoidPtr() )) SetError(122,NULL,cp);
 
     //sub rax,PTR_SIZE*3
@@ -328 +269 @@
     if( isSweeping ){
         //call _System_GC_free_for_SweepingDelete
-        extern SubInfo *pSub_System_GC_free_for_SweepingDelete;
+        extern UserProc *pSub_System_GC_free_for_SweepingDelete;
         op_call(pSub_System_GC_free_for_SweepingDelete);
     }
     else{
         //call free
-        extern SubInfo *pSub_free;
+        extern UserProc *pSub_free;
         op_call(pSub_free);
     }

BasicCompiler64/Compile_ProcOp.cpp

@@ -2 +2 @@
 #include "Opcode.h"
 
-void SystemProc(char *name){
+void SystemProc( const char *name ){
     if(lstrcmp(name,"_System_GetEip")==0){
         //mov rax,qword ptr[rsp]
@@ -22 +22 @@
         }
 
-        extern BOOL bCompilingGlobal;
-        BOOL bBackCompilingGlobal;
-        bBackCompilingGlobal=bCompilingGlobal;
-        bCompilingGlobal=1;
+        UserProc *pBackUserProc;
+        pBackUserProc = &UserProc::CompilingUserProc();
+        UserProc::CompileStartForGlobalArea();
 
         int BackCp;
@@ -56 +55 @@
         *((long *)(OpBuffer+StackFrameSchedule))=pobj_sf->GetFrameSize();
 
-        bCompilingGlobal=bBackCompilingGlobal;
+        UserProc::CompileStartForUserProc( pBackUserProc );
         cp=BackCp;
 
@@ -70 +69 @@
         StackFrameSchedule=obp-sizeof(long);
 
-        extern int MaxGlobalVarNum;
-        extern VARIABLE *GlobalVar;
-        int i;
-        for(i=0;i<MaxGlobalVarNum;i++){
-            if(memicmp(GlobalVar[i].name,"Static%",7)==0){
+        foreach( Variable *pVar, globalVars ){
+            if(memicmp(pVar->GetName().c_str(),"Static%",7)==0){
                 //コンストラクタ呼び出し
-                if(GlobalVar[i].type==DEF_OBJECT){
+                if( pVar->IsObject() ){
 
                     //エラー用
-                    cp=GlobalVar[i].source_code_address;
-
-                    TYPEINFO TypeInfo;
-                    TypeInfo.type=GlobalVar[i].type;
-                    TypeInfo.u.lpIndex=GlobalVar[i].u.index;
+                    cp=pVar->source_code_address;
+
                     CallConstructor(
-                        GlobalVar[i].name,
-                        GlobalVar[i].SubScripts,
-                        TypeInfo,
-                        GlobalVar[i].ConstractParameter);
+                        pVar->GetName().c_str(),
+                        pVar->GetSubScriptsPtr(),
+                        *pVar,
+                        pVar->paramStrForConstructor.c_str());
                 }
             }
@@ -107 +100 @@
 
 
-        extern BOOL bCompilingGlobal;
-        BOOL bBackCompilingGlobal;
-        bBackCompilingGlobal=bCompilingGlobal;
-        bCompilingGlobal=1;
+        UserProc *pBackUserProc;
+        pBackUserProc = &UserProc::CompilingUserProc();
+        UserProc::CompileStartForGlobalArea();
 
         obj_LexScopes.CallDestructorsOfScopeEnd();
 
-        bCompilingGlobal=bBackCompilingGlobal;
+        UserProc::CompileStartForUserProc( pBackUserProc );
 
 
@@ -204 +196 @@
     }
 }
-void CompileBufferInProcedure(SubInfo *psi){
+void CompileBufferInProcedure(UserProc *pUserProc){
     extern char *basbuf;
     extern HANDLE hHeap;
-    extern SubInfo **ppSubHash;
+    extern UserProc **ppSubHash;
     extern BOOL bDebugCompile;
-    int i3,i4,VarSize,BufferSize;
+    int i3,i4,BufferSize;
     char temporary[VN_SIZE];
 
     BufferSize=128;
 
-    if(psi->bUse==0||psi->bCompile) return;
-
-
-    psi->bCompile=1;
+    if( pUserProc->IsUsing() == false || pUserProc->IsCompiled() ) return;
+
+    pUserProc->CompleteCompile();
 
     extern BOOL bSystemProc;
-    if(memcmp(psi->name,"_System_",8)==0) bSystemProc=1;
+    if(memcmp(pUserProc->GetName().c_str(),"_System_",8)==0) bSystemProc=1;
     else bSystemProc=0;
 
     extern BOOL bDebugSupportProc;
-    if(memcmp(psi->name,"_DebugSys_",10)==0){
+    if(memcmp(pUserProc->GetName().c_str(),"_DebugSys_",10)==0){
         if(!bDebugCompile){
-            psi->pVar=(VARIABLE *)HeapAlloc(hHeap,0,1);
-            psi->VarNum=0;
+            pUserProc->localVars.clear();
             return;
         }
@@ -234 +224 @@
     else bDebugSupportProc=0;
 
-    psi->CompileAddress=obp;
-
-    if(psi->bSystem){
+    pUserProc->beginOpAddress=obp;
+
+    if(pUserProc->IsSystem()){
         ////////////////////
         // 特殊関数
@@ -250 +240 @@
         pobj_sf=new CStackFrame();
 
-        SystemProc(psi->name);
+        SystemProc(pUserProc->GetName().c_str());
 
         //スタックフレーム管理用オブジェクトを破棄
@@ -256 +246 @@
         pobj_sf=0;
 
-        psi->EndOpAddr=obp;
-        psi->pVar=(VARIABLE *)HeapAlloc(hHeap,0,1);
-        psi->VarNum=0;
+        pUserProc->endOpAddress=obp;
+        pUserProc->localVars.clear();
         return;
     }
 
-    cp=psi->address;
+    cp=pUserProc->GetCodePos();
     for(;;cp++){
         if(IsCommandDelimitation(basbuf[cp])) break;
@@ -303 +292 @@
 
     //ローカル変数に関する情報
-    extern VARIABLE *LocalVar;
-    extern int MaxLocalVarNum;
     extern int AllLocalVarSize;
-    LocalVar=(VARIABLE *)HeapAlloc(hHeap,0,sizeof(VARIABLE));
-    MaxLocalVarNum=0;
     AllLocalVarSize=0;
+    pUserProc->localVars.clear();
 
     //ローカル変数アドレススケジュール
@@ -324 +310 @@
     /////////////////////////////////////
 
-    for(i3=psi->RealParmNum-1;i3>=0;i3--){
-        //変数データを追加
-        LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
-
-        lstrcpy(LocalVar[MaxLocalVarNum].name,psi->realParams[i3].GetVarName.c_str());
-
-        // TODO: パラメータのConst定義の指定が未完成
-        LocalVar[MaxLocalVarNum].bConst=false;
-
-        LocalVar[MaxLocalVarNum].bArray=psi->realParams[i3].IsArray()?TRUE:FALSE;
-        memcpy(LocalVar[MaxLocalVarNum].SubScripts,psi->realParams[i3].GetSubScriptsPtr(),MAX_ARRAYDIM*sizeof(int));
-
-        LocalVar[MaxLocalVarNum].type=psi->realParams[i3].GetBasicType();
-        if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT
-            ||LocalVar[MaxLocalVarNum].type==DEF_STRUCT){
-                if(psi->bExport)
-                    SetError(24,NULL,cp);
-        }
-
-        LocalVar[MaxLocalVarNum].u.index=psi->realParams[i3].GetIndex();
-
-        if(psi->realParams[i3].IsRef() == false&&psi->realParams[i3].IsStruct()){
+    //パラメータ用の変数データを考慮
+    for(i3=(int)pUserProc->RealParams().size()-1;i3>=0;i3--){
+        Parameter &param = *pUserProc->RealParams()[i3];
+
+        Variable *pVar = new Variable( param.GetVarName(), param, false, param.IsRef() );
+
+        if( param.IsArray() ){
+            pVar->SetArray( param.GetSubScriptsPtr() );
+        }
+
+        int varSize;
+        if( param.IsRef() == false && param.IsStruct() ){
             //構造体のByValパラメータ
-            LocalVar[MaxLocalVarNum].fRef=REF_PARAMETER | OBJECT_PARAMETER;
-            VarSize=PTR_SIZE;
+            pVar->ThisIsParameter();
+            varSize=PTR_SIZE;
         }
         else{
-            if(psi->realParams[i3].IsRef() == false&&psi->realParams[i3].IsArray()){
-                LocalVar[MaxLocalVarNum].fRef=0;
-                VarSize=GetTypeSize(LocalVar[MaxLocalVarNum].type,LocalVar[MaxLocalVarNum].u.index);
-                if(VarSize%PTR_SIZE) VarSize+=PTR_SIZE-(VarSize%PTR_SIZE);
+            if( param.IsArray() == false ){
+                varSize = pVar->GetMemorySize();
             }
             else{
-                LocalVar[MaxLocalVarNum].fRef=REF_PARAMETER;
-                VarSize=PTR_SIZE;
-            }
-        }
-        AllLocalVarSize+=VarSize;
-        LocalVar[MaxLocalVarNum].offset=AllLocalVarSize;
+                varSize=PTR_SIZE;
+            }
+        }
+        AllLocalVarSize+=varSize;
+        pVar->offset=AllLocalVarSize;
 
         //レキシカルスコープ情報
-        LocalVar[MaxLocalVarNum].ScopeLevel=obj_LexScopes.GetNowLevel();
-        LocalVar[MaxLocalVarNum].ScopeStartAddress=obj_LexScopes.GetStartAddress();
-        LocalVar[MaxLocalVarNum].bLiving=TRUE;
-
-        MaxLocalVarNum++;
+        pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
+        pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
+        pVar->bLiving=TRUE;
+
+        pUserProc->localVars.push_back( pVar );
     }
 
@@ -377 +350 @@
 
     //コンパイル中の関数が属するクラス
-    pobj_CompilingClass=psi->pobj_ParentClass;
-    
+    pobj_CompilingClass=pUserProc->GetParentClassPtr();
+
     //コンパイルスタートをクラス管理クラスに追加
-    pobj_DBClass->StartCompile( psi );
+    pobj_DBClass->StartCompile( pUserProc );
 
     //コンパイル中の関数
-    extern SubInfo *pCompilingSubInfo;
-    pCompilingSubInfo=psi;
+    UserProc::CompileStartForUserProc( pUserProc );
 
     //スタックフレーム管理用クラスを初期化
@@ -394 +366 @@
     // ここからコード生成
 
-    for(i3=psi->RealParmNum-1;i3>=0;i3--){
+    for(i3=(int)pUserProc->RealParams().size()-1;i3>=0;i3--){
+        Parameter &param = *pUserProc->RealParams()[i3];
         if(i3==3){
-            if(psi->realParams[i3].IsReal()&&psi->realParams[i3].IsRef() == false){
+            if(param.IsReal()&&param.IsRef() == false){
                 //movsd qword ptr[rsp+0x20],xmm3
                 op_movsd_MR(REG_XMM3,REG_RSP,0x20,MOD_BASE_DISP32);
@@ -406 +379 @@
         }
         if(i3==2){
-            if(psi->realParams[i3].IsReal()&&psi->realParams[i3].IsRef() == false){
+            if(param.IsReal()&&param.IsRef() == false){
                 //movsd qword ptr[rsp+0x18],xmm2
                 op_movsd_MR(REG_XMM2,REG_RSP,0x18,MOD_BASE_DISP32);
@@ -416 +389 @@
         }
         if(i3==1){
-            if(psi->realParams[i3].IsReal()&&psi->realParams[i3].IsRef() == false){
+            if(param.IsReal()&&param.IsRef() == false){
                 //movsd qword ptr[rsp+0x10],xmm1
                 op_movsd_MR(REG_XMM1,REG_RSP,0x10,MOD_BASE_DISP32);
@@ -426 +399 @@
         }
         if(i3==0){
-            if(psi->realParams[i3].IsReal()&&psi->realParams[i3].IsRef() == false){
+            if(param.IsReal()&&param.IsRef() == false){
                 //movsd qword ptr[rsp+0x8],xmm0
                 op_movsd_MR(REG_XMM0,REG_RSP,0x8,MOD_BASE_DISP32);
@@ -458 +431 @@
     BaseLocalVar=AllLocalVarSize;
 
-    if(psi->ReturnType!=DEF_NON){
+    if( !pUserProc->ReturnType().IsNull() ){
         //戻り値が存在するとき
 
-        char *temp;
-        if(psi->name[0]==1&&psi->name[1]==ESC_OPERATOR) temp="_System_ReturnValue";
-        else temp=psi->name;
-
-        if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
+        const char *temp = pUserProc->GetName().c_str();
+        if( temp[0]==1&&temp[1]==ESC_OPERATOR ){
+            temp = "_System_ReturnValue";
+        }
+
+        if( pUserProc->ReturnType().IsStruct() ){
             //戻り値用の構造体（値型）はパラメータで引き渡される
         }
         else{
             //戻り値用の変数の定義
-            if( psi->isReturnRef ){
-                sprintf(temporary,"%c%c",1,ESC_BYREF);
-            }
-            else temporary[0]=0;
-
-            sprintf(temporary+lstrlen(temporary),"%s%c%c",temp,1,ESC_AS);
-            GetTypeName(psi->ReturnType,psi->u.ReturnIndex,temporary+lstrlen(temporary));
+            sprintf(temporary,"%s%c%c%s",temp,1,ESC_AS, pUserProc->ReturnType().ToString().c_str() );
 
             OpcodeDim(temporary,0);
@@ -497 +465 @@
 
         //call _DebugSys_StartProc
-        extern SubInfo *pSub_DebugSys_StartProc;
+        extern UserProc *pSub_DebugSys_StartProc;
         op_call(pSub_DebugSys_StartProc);
     }
 
     if(pobj_CompilingClass){
-        if(lstrcmp(psi->name,pobj_CompilingClass->name)==0){
+        if( pUserProc->GetName() == pobj_CompilingClass->name ){
             ////////////////////////////////////
             // コンストラクタをコンパイルするとき
@@ -550 +518 @@
 
                     Opcode_CallProc(temporary,
-                        pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->psi,
+                        pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc,
                         0,
                         "",
@@ -558 +526 @@
                     //基底クラスのコンストラクタを暗黙的に呼び出す
                     Opcode_CallProc("",
-                        pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->psi,
+                        pobj_CompilingClass->pobj_InheritsClass->GetConstructorMethod()->pUserProc,
                         0,
                         "",
@@ -568 +536 @@
             for(i3=0;i3<pobj_CompilingClass->iMemberNum;i3++){
                 CMember *pMember = pobj_CompilingClass->ppobj_Member[i3];
-                if(pMember->TypeInfo.type==DEF_OBJECT){
+                if(pMember->IsObject()){
                     // オブジェクトメンバを発見したとき
 
@@ -574 +542 @@
                         pMember->name,
                         1, ESC_NEW,
-                        pMember->TypeInfo.u.pobj_Class->name );
+                        pMember->GetClass().name );
                     OpcodeCalc( temporary );
                 }
@@ -598 +566 @@
             }
         }
-        else if(psi->name[0]=='~'){
+        else if( pUserProc->IsDestructor() ){
             //デストラクタをコンパイルしたとき
 
@@ -609 +577 @@
     //////////////////////////////////////////
     ////// プロシージャ内をコンパイル ////////
-    if(psi->dwType==SUBTYPE_SUB) CompileBuffer(ESC_ENDSUB,0);
-    else if(psi->dwType==SUBTYPE_FUNCTION) CompileBuffer(ESC_ENDFUNCTION,0);
-    else if(psi->dwType==SUBTYPE_MACRO) CompileBuffer(ESC_ENDMACRO,0);
+    if(pUserProc->IsMacro()) CompileBuffer(ESC_ENDMACRO,0);
+    else{
+        if(pUserProc->IsSub()) CompileBuffer(ESC_ENDSUB,0);
+        else if(pUserProc->IsFunction()) CompileBuffer(ESC_ENDFUNCTION,0);
+    }
     //////////////////////////////////////////
     //////////////////////////////////////////
@@ -623 +593 @@
             pobj_CompilingClass->NotifyFinishConstructorCompile();
         }
-        else if(psi->name[0]=='~'){
+        else if( pUserProc->IsDestructor() ){
             ////////////////////////////////////
             //デストラクタをコンパイルしたとき
@@ -638 +608 @@
                 if( method ){
                     Opcode_CallProc("",
-                        method->psi,
+                        method->pUserProc,
                         0,
                         "",
@@ -659 +629 @@
                 int offset = pobj_CompilingClass->GetMemberOffset( pMember->name, NULL );
 
-                if(pMember->TypeInfo.type==DEF_OBJECT){
-                    CMethod *method = pMember->TypeInfo.u.pobj_Class->GetDestructorMethod();
+                if(pMember->IsObject()){
+                    CMethod *method = pMember->GetClass().GetDestructorMethod();
                     if( method ){
                         for(i4=MemberObjectNum-1;i4>=0;i4--){
@@ -670 +640 @@
 
                             //call destructor
-                            op_call(method->psi);
+                            op_call(method->pUserProc);
                         }
                     }
@@ -705 +675 @@
     HeapDefaultFree(WithInfo.pWithCp);
 
-    //重複エラー情報管理のメモリを解放
-    for(i3=0;i3<SynonymErrorNum;i3++) HeapDefaultFree(SynonymErrorWords[i3]);
-    HeapDefaultFree(SynonymErrorWords);
-
     //ローカルオブジェクト（レキシカルスコープレベル=0）の解放処理
     obj_LexScopes.CallDestructorsOfScopeEnd();
@@ -720 +686 @@
     if(bDebugCompile&&bDebugSupportProc==0){
         //call _DebugSys_EndProc
-        extern SubInfo *pSub_DebugSys_EndProc;
+        extern UserProc *pSub_DebugSys_EndProc;
         op_call(pSub_DebugSys_EndProc);
     }
 
-    if(psi->ReturnType!=DEF_NON){
+    if( !pUserProc->ReturnType().IsNull() ){
         //////////////////////////////////
         // 戻り値をraxまたはxmm0に設定
@@ -730 +696 @@
 
         RELATIVE_VAR RelativeVar;
-        LONG_PTR lpIndex;
-
-        char *temp;
-        if(psi->name[0]==1&&psi->name[1]==ESC_OPERATOR)
+
+        const char *temp = pUserProc->GetName().c_str();
+        if( temp[0]==1 && temp[1]==ESC_OPERATOR ){
             temp="_System_ReturnValue";
-        else temp=psi->name;
-        GetVarOffsetReadWrite(temp,&i3,&RelativeVar,&lpIndex);
-
-        i3=psi->ReturnType;
+        }
+        GetVarOffsetReadWrite(temp,&RelativeVar,Type());
+
+        i3=pUserProc->ReturnType().GetBasicType();
 
         if(i3==DEF_OBJECT || i3==DEF_STRUCT){
@@ -772 +737 @@
     }
     HeapDefaultFree(pLocalVarAddrSchedule);
-    for(i3=0;i3<MaxLocalVarNum;i3++){
+    foreach( Variable *pVar, pUserProc->localVars ){
         //後にデバッグで利用する
-        LocalVar[i3].offset=AllLocalVarSize+pobj_sf->GetFrameSize()-LocalVar[i3].offset;
+        pVar->offset = AllLocalVarSize + pobj_sf->GetFrameSize() - pVar->offset;
     }
 
@@ -812 +777 @@
 
 
-    psi->EndOpAddr=obp;
-    psi->pVar=LocalVar;
-    psi->VarNum=MaxLocalVarNum;
-
-    //ローカル変数のネーム情報は後に解放する
+    pUserProc->endOpAddress=obp;
+
+
+    //重複エラー情報管理のメモリを解放
+    for(i3=0;i3<SynonymErrorNum;i3++) HeapDefaultFree(SynonymErrorWords[i3]);
+    HeapDefaultFree(SynonymErrorWords);
 }
 void CompileLocal(){
-    extern SubInfo **ppSubHash;
+    extern UserProc **ppSubHash;
     int i2;
-    SubInfo *psi;
+    UserProc *pUserProc;
 
     extern BOOL bDll;
     if(bDll){
         //DLLの場合はグローバル変数を初期化するための関数を一番初めにコンパイルする
-        psi=GetSubHash("_System_InitDllGlobalVariables");
-        if(psi){
-            CompileBufferInProcedure(psi);
+        pUserProc=GetSubHash("_System_InitDllGlobalVariables");
+        if(pUserProc){
+            CompileBufferInProcedure(pUserProc);
         }
         else SetError(300,NULL,cp);
@@ -835 +801 @@
     //_System_InitStaticLocalVariablesは一番最後にコンパイル
     //※一般関数内の静的変数オブジェクトをすべて収集しなければならない
-    extern SubInfo *pSub_System_InitStaticLocalVariables;
-    pSub_System_InitStaticLocalVariables->bCompile=1;
+    extern UserProc *pSub_System_InitStaticLocalVariables;
+    pSub_System_InitStaticLocalVariables->CompleteCompile();
 
     //_System_Call_Destructor_of_GlobalObjectは一番最後にコンパイル
-    extern SubInfo *pSub_System_Call_Destructor_of_GlobalObject;
-    pSub_System_Call_Destructor_of_GlobalObject->bCompile=1;
+    extern UserProc *pSub_System_Call_Destructor_of_GlobalObject;
+    pSub_System_Call_Destructor_of_GlobalObject->CompleteCompile();
 
 Repeat:
     for(i2=0;i2<MAX_HASH;i2++){
-        psi=ppSubHash[i2];
-        while(psi){
-            CompileBufferInProcedure(psi);
-            psi=psi->pNextData;
+        pUserProc=ppSubHash[i2];
+        while(pUserProc){
+            CompileBufferInProcedure(pUserProc);
+            pUserProc=pUserProc->pNextData;
         }
     }
@@ -853 +819 @@
     //プロシージャコンパイルによって、プロシージャコンパイルが必要になる場合
     for(i2=0;i2<MAX_HASH;i2++){
-        psi=ppSubHash[i2];
-        while(psi){
-            if(psi->bUse&&psi->bCompile==0&&psi->bVirtual==0){
+        pUserProc=ppSubHash[i2];
+        while(pUserProc){
+            if( pUserProc->IsUsing() && pUserProc->IsCompiled() == false ){
                 goto Repeat;
             }
 
-            psi=psi->pNextData;
+            pUserProc=pUserProc->pNextData;
         }
     }
 
     //_System_InitStaticLocalVariablesは一番最後にコンパイル
-    pSub_System_InitStaticLocalVariables->bCompile=0;
+    pSub_System_InitStaticLocalVariables->KillCompileStatus();
     CompileBufferInProcedure(pSub_System_InitStaticLocalVariables);
 
     //_System_Call_Destructor_of_GlobalObjectは一番最後にコンパイル
-    pSub_System_Call_Destructor_of_GlobalObject->bCompile=0;
+    pSub_System_Call_Destructor_of_GlobalObject->KillCompileStatus();
     CompileBufferInProcedure(pSub_System_Call_Destructor_of_GlobalObject);
 }

BasicCompiler64/Compile_Set_Var.cpp

@@ -7 +7 @@
 }
 
-void SetStructVariableFromRax(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,RELATIVE_VAR *pRelativeVar,BOOL bUseHeap){
+void SetStructVariableFromRax( const Type &varType, const Type &calcType, RELATIVE_VAR *pRelativeVar,BOOL bUseHeap){
     int RightTermReg;
     pobj_reg=new CRegister(REG_RCX);
@@ -17 +17 @@
 
     //右辺
-    if(IsRealNumberType(CalcType)){
+    if( calcType.IsReal() ){
         RightTermReg=pobj_reg->LockXmmReg();
 
-        if(CalcType==DEF_DOUBLE){
+        if( calcType.IsDouble() ){
             //movlsd RightTermReg,xmm0
             op_movsd_RR(RightTermReg,REG_XMM0);
         }
-        else if(CalcType==DEF_SINGLE){
+        else if( calcType.IsSingle() ){
             //movlss RightTermReg,xmm0
             op_movss_RR(RightTermReg,REG_XMM0);
@@ -62 +62 @@
 */
     //右辺用レジスタを解除
-    if(IsRealNumberType(CalcType)) pobj_reg->UnlockXmmReg();
+    if( calcType.IsReal() ) pobj_reg->UnlockXmmReg();
     else pobj_reg->UnlockReg();
 
@@ -73 +73 @@
 
 
-    if( CalcType == DEF_STRUCT ){
-        CClass *pVarClass = (CClass *)lpVarIndex;
-        CClass *pCalcClass = (CClass *)lpCalcIndex;
-
-        if( pVarClass->IsEquals( pCalcClass ) ){            //等しい
+    if( calcType.IsStruct() ){
+        if( varType.GetClass().IsEquals( &calcType.GetClass() ) ){          //等しい
 
                 //双方のオブジェクト型が一致、または派生・継承関係にあるとき
@@ -88 +85 @@
                 op_mov_RR(REG_RDI,VarReg);
 
-                CClass *pClass = (CClass *)lpVarIndex;
-                int object_size = pClass->GetSize();
+                int object_size = varType.GetClass().GetSize();
 
                 //mov rcx,object_size
@@ -107 +103 @@
 
                     //call free
-                    extern SubInfo *pSub_free;
+                    extern UserProc *pSub_free;
                     op_call(pSub_free);
                 }

BasicCompiler64/Compile_Statement.cpp

@@ -5 +5 @@
     int i,i2;
     char buffer[8192];
-    SubInfo *psi;
+    UserProc *pUserProc;
 
     for(i=0;;i++){
@@ -41 +41 @@
         //////////////////////////////
 
-        psi=GetSubHash(Command);
+        pUserProc=GetSubHash(Command);
 
         //GetSubHash内でエラー提示が行われた場合
-        if(psi==(SubInfo *)-1) return;
-
-        if(psi==0){
+        if(pUserProc==(UserProc *)-1) return;
+
+        if(pUserProc==0){
             char temporary[VN_SIZE];
             lstrcpy(temporary,Command);
 
             CharUpper(temporary);
-            psi=GetSubHash(temporary);
+            pUserProc=GetSubHash(temporary);
 
             //GetSubHash内でエラー提示が行われた場合
-            if(psi==(SubInfo *)-1) return;
-        }
-
-        if(psi){
-            if(psi->dwType!=SUBTYPE_MACRO) SetError(10,Command,cp);
-
-            Opcode_CallProc("",psi,0,"",0);
+            if(pUserProc==(UserProc *)-1) return;
+        }
+
+        if(pUserProc){
+            if( !pUserProc->IsMacro() ) SetError(10,Command,cp);
+
+            Opcode_CallProc("",pUserProc,0,"",0);
 
             return;
@@ -72 +72 @@
 
     int idProc;
-    void *pInfo;
-    idProc=GetProc(buffer,&pInfo);
+    void *pProc;
+    idProc=GetProc(buffer,(void **)&pProc);
 
     int i4;
@@ -91 +91 @@
         ////////////////
 
-        LONG_PTR lp;
-        i2=CallProc(idProc,pInfo,buffer,temp2,&lp);
+        Type resultType;
+        CallProc(idProc,pProc,buffer,temp2,resultType);
 
 
@@ -99 +99 @@
         /////////////////////
 
-        if(i2==DEF_STRUCT){
+        if( resultType.IsStruct() ){
             //mov r14,rax
             op_mov_RR(REG_R14,REG_RAX);
 
-            FreeTempObject(REG_R14,(CClass *)lp);
+            FreeTempObject(REG_R14,&resultType.GetClass());
         }
         return;
@@ -116 +116 @@
 
 void Judgment(char *buffer){
-    int reg=REG_RAX,type;
-    type=NumOpe(&reg,buffer,0,0,0);
+    int reg=REG_RAX;
+    Type resultType;
+    if( !NumOpe(&reg,buffer,Type(),resultType) ){
+        return;
+    }
 
     int offset;
 
-    if(type==DEF_DOUBLE){
+    if(resultType.IsDouble()){
         double dbl=0;
         offset=dataTable.Add( dbl );
@@ -135 +138 @@
         obp+=sizeof(long);
     }
-    else if(type==DEF_SINGLE){
+    else if(resultType.IsSingle()){
         float flt=0;
         offset=dataTable.Add( flt );
@@ -152 +155 @@
 
         //cmp rax,0
-        op_cmp_value(GetTypeSize(type,-1),REG_RAX,0);
+        op_cmp_value(resultType.GetSize(),REG_RAX,0);
     }
 }
@@ -340 +343 @@
 void OpcodeFor(char *Parameter){
     extern HANDLE hHeap;
+    Type resultType;
     int i,i2,i3;
     char temporary[VN_SIZE],variable[VN_SIZE],JudgeNum[VN_SIZE],StepNum[VN_SIZE];
@@ -400 +404 @@
     sprintf(temporary,"(%s)>=0",StepNum);
 
-    int reg,type;
+    int reg;
     reg=REG_RAX;
-    type=NumOpe(&reg,temporary,0,0,0);
+    if( !NumOpe(&reg,temporary,Type(),resultType) ){
+        return;
+    }
 
     //cmp rax,0
-    op_cmp_value(GetTypeSize(type,-1),REG_RAX,0);
+    op_cmp_value(resultType.GetSize(),REG_RAX,0);
 
     //je [カウンタ減少の場合の判定]
@@ -417 +423 @@
 
     reg=REG_RAX;
-    type=NumOpe(&reg,temporary,0,0,0);
+    NumOpe(&reg,temporary,Type(),Type());
 
     //jmp [カウンタ減少の場合の判定を飛び越す]
@@ -430 +436 @@
 
     reg=REG_RAX;
-    type=NumOpe(&reg,temporary,0,0,0);
+    NumOpe(&reg,temporary,Type(),resultType);
 
     *((long *)(OpBuffer+i3))=obp-(i3+sizeof(long)); //jmpジャンプ先のオフセット値
 
     //cmp rax,0
-    op_cmp_value(GetTypeSize(type,-1),REG_RAX,0);
+    op_cmp_value(resultType.GetSize(),REG_RAX,0);
 
 ErrorStep:
@@ -583 +589 @@
     extern HANDLE hHeap;
 
-    extern BOOL bCompilingGlobal;
-    if(bCompilingGlobal){
+    if( UserProc::IsGlobalAreaCompiling() ){
         SetError(12,"Exit Sub/Function",cp);
         return;
@@ -611 +616 @@
     CaseScheduleNum++;
 }
-void OpcodeSelect(char *Parameter){
+void OpcodeSelect( const char *lpszParms ){
     extern DWORD *pCaseSchedule;
     extern int CaseScheduleNum;
@@ -631 +636 @@
     NowCaseSchedule=0;
 
-    int reg1=REG_RAX,type1;
-    LONG_PTR lpIndex;
-    type1=NumOpe(&reg1,Parameter,0,0,&lpIndex);
-
-    if(type1==DEF_DOUBLE){
+    int reg1=REG_RAX;
+    Type type1;
+    if( !NumOpe(&reg1,lpszParms,Type(), type1 ) ){
+        return;
+    }
+
+    if(type1.IsDouble()){
         //movsd qword ptr[rsp+offset],xmm_reg       ※スタックフレームを利用
         pobj_sf->push(reg1,sizeof(double));
     }
-    else if(type1==DEF_SINGLE){
+    else if(type1.IsSingle()){
         //movss dword ptr[rsp+offset],xmm_reg       ※スタックフレームを利用
         pobj_sf->push(reg1,sizeof(float));
     }
     else{
-        ExtendTypeTo64(type1,reg1);
+        ExtendTypeTo64(type1.GetBasicType(),reg1);
 
         //mov qword ptr[rsp+offset],reg     ※スタックフレームを利用
@@ -712 +719 @@
                 cp=NowCaseCp;
 
-                int reg2=REG_RDX,type2;
-                LONG_PTR lpIndex2;
-                type2=NumOpe(&reg2,temporary,type1,lpIndex,&lpIndex2);
+                int reg2=REG_RDX;
+                Type type2;
+                if( !NumOpe(&reg2,temporary,type1,type2) ){
+                    return;
+                }
 
                 cp=i2;
 
-                if(type1==DEF_OBJECT){
-                    CClass *pobj_c;
-                    pobj_c=(CClass *)lpIndex;
-
-                    std::vector<SubInfo *> subs;
-                    pobj_c->EnumMethod( CALC_EQUAL, subs );
+                if(type1.IsObject()){
+                    std::vector<UserProc *> subs;
+                    type1.GetClass().EnumMethod( CALC_EQUAL, subs );
                     if( subs.size() == 0 ){
                         return;
                     }
 
-                    PARAMETER_INFO *ppi = (PARAMETER_INFO *)HeapAlloc(hHeap,0,sizeof(PARAMETER_INFO)*3);
-                    int iParmNum=0;
-                    ppi[iParmNum].bArray=0;
-                    ppi[iParmNum].bByVal=0;
-                    ppi[iParmNum].name=0;
-                    ppi[iParmNum].type=type2;
-                    ppi[iParmNum].u.index=lpIndex2;
-                    ppi[iParmNum].SubScripts[0]=-1;
-                    iParmNum++;
+                    Parameters params;
+                    params.push_back( new Parameter( "", Type( type2 ) ) );
 
                     //オーバーロードを解決
-                    SubInfo *psi;
-                    psi=OverloadSolution("==",subs,ppi,iParmNum,NULL);
-                    HeapDefaultFree(ppi);
-
-                    if(!psi){
+                    UserProc *pUserProc;
+                    pUserProc=OverloadSolution("==",subs, params, NULL);
+
+                    delete params[0];
+
+                    if(!pUserProc){
                         //エラー
                         return;
@@ -759 +759 @@
 
                     //call operator_proc    ※ ==演算子
-                    op_call(psi);
+                    op_call(pUserProc);
 
                     //test rax,rax
@@ -769 +769 @@
                 }
                 else{
-                    if(type1==DEF_DOUBLE){
+                    if(type1.IsDouble()){
                         int xmm_reg;
                         if(IsXmmReg(reg2)) xmm_reg=reg2;
                         else xmm_reg=REG_XMM5;
-                        ChangeTypeToXmm_Double(type2,xmm_reg,reg2);
+                        ChangeTypeToXmm_Double(type2.GetBasicType(),xmm_reg,reg2);
 
                         //movsd xmm4,qword ptr[rsp+offset]  ※スタックフレームから参照
@@ -781 +781 @@
                         op_comisd(xmm_reg,REG_XMM4);
                     }
-                    else if(type1==DEF_SINGLE){
+                    else if(type1.IsSingle()){
                         int xmm_reg;
                         if(IsXmmReg(reg2)) xmm_reg=reg2;
                         else xmm_reg=REG_XMM5;
-                        ChangeTypeToXmm_Single(type2,xmm_reg,reg2);
+                        ChangeTypeToXmm_Single(type2.GetBasicType(),xmm_reg,reg2);
 
                         //movss xmm4,dword ptr[rsp+offset]  ※スタックフレームから参照
@@ -796 +796 @@
                         //その他整数型
 
-                        i2=NeutralizationType(type1,-1,type2,-1);
+                        i2=NeutralizationType(type1.GetBasicType(),-1,type2.GetBasicType(),-1);
 
                         //mov r14,qword ptr[rsp+offset]     ※スタックフレームから参照
@@ -883 +883 @@
 
     //call _System_GetEip
-    extern SubInfo *pSub_System_GetEip;
+    extern UserProc *pSub_System_GetEip;
     op_call(pSub_System_GetEip);
 
@@ -938 +938 @@
 }
 void OpcodeReturn(char *Parameter){
-    extern BOOL bCompilingGlobal;
-    if(bCompilingGlobal){
+    if( UserProc::IsGlobalAreaCompiling() ){
         SetError(62,NULL,cp);
     }
@@ -945 +944 @@
         //戻り値をセット
         if(Parameter[0]){
-            extern SubInfo *pCompilingSubInfo;
-            char *temp;
-            if(pCompilingSubInfo->name[0]==1&&pCompilingSubInfo->name[1]==ESC_OPERATOR)
-                temp="_System_ReturnValue";
-            else temp=pCompilingSubInfo->name;
-
-            /*
-            TODO: 消す
-            if( pCompilingSubInfo->isReturnRef ){
-                //参照型
-                SetRefVariable( temp, Parameter );
+            UserProc &proc = UserProc::CompilingUserProc();
+
+            const char *temp = "_System_ReturnValue";
+            if(proc.GetName()[0]==1&&proc.GetName()[1]==ESC_OPERATOR)
+            {
             }
             else{
-                //値型*/
-                char temporary[VN_SIZE];
-                sprintf(temporary,"%s=%s",temp,Parameter);
-                OpcodeCalc(temporary);
-            //}
+                temp=proc.GetName().c_str();
+            }
+
+            char temporary[VN_SIZE];
+            sprintf(temporary,"%s=%s",temp,Parameter);
+            OpcodeCalc(temporary);
         }
 
@@ -972 +966 @@
 void Opcode_Input(const char *Parameter){
     extern int cp;
-    int i2,i3,i4,i5,type;
+    int i2,i3,i4,i5;
     BOOL bFile;
     char temporary[VN_SIZE],temp2[VN_SIZE],buffer[VN_SIZE];
@@ -1054 +1048 @@
         }
 
-        LONG_PTR lpIndex;
-        type = GetVarType(temporary, &lpIndex, 1);
+        Type varType;
+        if( !GetVarType(temporary, varType, 1) ){
+            return;
+        }
 
         sprintf(temp2,"_System_InputDataPtr[%d]=VarPtr(%s)",i4,temporary);
         OpcodeCalc(temp2);
 
-        if(type==DEF_LONG) type=DEF_DWORD;
-        else if(type==DEF_INTEGER) type=DEF_WORD;
-        else if(type==DEF_OBJECT){
-            CClass *pobj_Class=(CClass *)lpIndex;
-            if(lstrcmp(pobj_Class->name,"String")==0) type=DEF_STRING;
-        }
-        sprintf(temp2,"_System_InputDataType[%d]=%d",i4,type);
+        if(varType.IsLong()) varType.SetBasicType( DEF_DWORD );
+        else if(varType.IsInteger()) varType.SetBasicType( DEF_WORD );
+        else if(varType.IsObject()){
+            varType.SetBasicType( DEF_OBJECT );
+            if( varType.IsStringObject() ){
+                varType.SetBasicType( DEF_STRING );
+            }
+        }
+        sprintf(temp2,"_System_InputDataType[%d]=%d",i4,varType.GetBasicType());
         OpcodeCalc(temp2);
 
@@ -1075 +1073 @@
     OpcodeCalc(temp2);
 
-    SubInfo *psi;
-    if(bFile) psi=GetSubHash("INPUT_FromFile");
-    else psi=GetSubHash("INPUT_FromPrompt");
-    if(!psi){
+    UserProc *pUserProc;
+    if(bFile) pUserProc=GetSubHash("INPUT_FromFile");
+    else pUserProc=GetSubHash("INPUT_FromPrompt");
+    if(!pUserProc){
         SetError(3,"Input",cp);
         return;
     }
-    Opcode_CallProc(buffer,psi,0,"",0);
+    Opcode_CallProc(buffer,pUserProc,0,"",0);
 }
 void Opcode_PrintUsing(const char *Parameter,char *buffer,BOOL bFile){
@@ -1177 +1175 @@
     OpcodeCalc(temp2);
 
-    SubInfo *psi;
-    if(bFile) psi=GetSubHash("PRINTUSING_ToFile");
-    else psi=GetSubHash("PRINTUSING_ToPrompt");
-    if(!psi){
+    UserProc *pUserProc;
+    if(bFile) pUserProc=GetSubHash("PRINTUSING_ToFile");
+    else pUserProc=GetSubHash("PRINTUSING_ToPrompt");
+    if(!pUserProc){
         SetError(3,"Print",cp);
         return;
     }
-    Opcode_CallProc(buffer,psi,0,"",0);
+    Opcode_CallProc(buffer,pUserProc,0,"",0);
 }
 void Opcode_Print(const char *Parameter,BOOL bWrite){
@@ -1281 +1279 @@
     if(sw) lstrcat(buffer,"+Ex\"\\r\\n\"");
 
-    SubInfo *psi;
-    if(bFile) psi=GetSubHash("PRINT_ToFile");
-    else psi=GetSubHash("PRINT_ToPrompt");
-    if(!psi){
+    UserProc *pUserProc;
+    if(bFile) pUserProc=GetSubHash("PRINT_ToFile");
+    else pUserProc=GetSubHash("PRINT_ToPrompt");
+    if(!pUserProc){
         SetError(3,"Print",cp);
         return;
     }
-    Opcode_CallProc(buffer,psi,0,"",0);
+    Opcode_CallProc(buffer,pUserProc,0,"",0);
 }
 
@@ -1299 +1297 @@
 
 void OpcodeSetPtrData(char *Parameter,int type){
-    int i,i2;
+    int i;
     char temporary[VN_SIZE];
 
@@ -1321 +1319 @@
 
     int reg_ptr=REG_RAX;
-    i2=NumOpe(&reg_ptr,temporary,0,0,0);
-    if(!IsWholeNumberType(i2)){
+    Type resultType;
+    if( !NumOpe(&reg_ptr,temporary,Type(),resultType) ){
+        return;
+    }
+    if(!resultType.IsWhole()){
         SetError(11,Parameter,cp);
         return;
@@ -1338 +1339 @@
 
     int temp_reg=REG_NON;
-    i2=NumOpe(&temp_reg,temporary,0,0,0);
+    if( !NumOpe(&temp_reg,temporary,Type(),resultType) ){
+        return;
+    }
 
     //レジスタのブロッキングを解除
@@ -1344 +1347 @@
 
     if(type==DEF_DOUBLE){
-        ChangeTypeToXmm_Double(i2,REG_XMM0,temp_reg);
+        ChangeTypeToXmm_Double(resultType.GetBasicType(),REG_XMM0,temp_reg);
 
         //movsd qword ptr[reg_ptr],xmm0
@@ -1350 +1353 @@
     }
     else if(type==DEF_SINGLE){
-        ChangeTypeToXmm_Single(i2,REG_XMM0,temp_reg);
+        ChangeTypeToXmm_Single(resultType.GetBasicType(),REG_XMM0,temp_reg);
 
         //movss dword ptr[reg_ptr],xmm0
@@ -1356 +1359 @@
     }
     else{
-        ChangeTypeToWhole(i2,type,REG_RCX,temp_reg);
+        ChangeTypeToWhole(resultType.GetBasicType(),type,REG_RCX,temp_reg);
 
         //mov ptr[reg_ptr],rcx

BasicCompiler64/Compile_Var.cpp

@@ -3 +3 @@
 
 //変数
-VARIABLE *GlobalVar;
+Variables globalVars;
 int MaxGlobalVarNum;
 int AllGlobalVarSize;
 int AllInitGlobalVarSize;
-VARIABLE *LocalVar;
+
 int MaxLocalVarNum;
 int AllLocalVarSize;
 
 
-void SetRelativeOffset(int *pType,LONG_PTR lpIndex,RELATIVE_VAR *pRelativeVar,char *lpPtrOffset){
-    int i2;
-
-
+void SetRelativeOffset( Type &resultType, RELATIVE_VAR *pRelativeVar,const char *lpPtrOffset){
     /////////////////////////////////////////////
     // 先頭ポインタをr12に取得してメモリへ退避
@@ -31 +28 @@
 
     int reg=REG_NON;
-    i2=NumOpe(&reg,lpPtrOffset,0,0,0);
-    if(!IsWholeNumberType(i2)) SetError(46,NULL,cp);
-    ExtendTypeTo64(i2,reg);
+    Type type;
+    NumOpe( &reg, lpPtrOffset, Type(), type );
+    if( !type.IsWhole() ){
+        SetError(46,NULL,cp);
+    }
+    ExtendTypeTo64(type.GetBasicType(),reg);
 
     if(reg==REG_R14){
@@ -40 +40 @@
     }
 
-    if(PTR_LEVEL(*pType)){
-        *pType = PTR_LEVEL_DOWN( *pType );
-
-        i2=GetTypeSize(*pType,lpIndex);
-        if(i2>=2){
+    if( resultType.PtrLevel() ){
+        resultType.PtrLevelDown();
+
+        int typeSize = resultType.GetSize();
+        if(typeSize>=2){
             //imul reg,i2
-            op_imul_RV(sizeof(_int64),reg,i2);
+            op_imul_RV(sizeof(_int64),reg,typeSize);
         }
     }
@@ -80 +80 @@
     }
 }
-BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
+bool GetArrayOffset(const int *SubScripts,char *array, const Type &type){
     extern HANDLE hHeap;
-    int i,i2,i3,i4,TypeSize;
+    int i,i2,i3,i4;
     char temporary[VN_SIZE],*pParm[MAX_PARMS];
 
@@ -101 +101 @@
             if(SubScripts[i3]==-1){
                 for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
-                return 0;
+                return false;
             }
 
@@ -114 +114 @@
                 if(SubScripts[i3]!=-1){
                     for(i3--;i3>=0;i3--) HeapDefaultFree(pParm[i3]);
-                    return 0;
+                    return false;
                 }
                 break;
@@ -136 +136 @@
 
         int reg=REG_NON;
-        TYPEINFO TypeInfo;
+        Type type;
         BOOL bUseHeap;
-        TypeInfo.type=NumOpe(&reg,pParm[i],DEF_LONG,-1,&TypeInfo.u.lpIndex,&bUseHeap);
-        if(TypeInfo.type==DEF_OBJECT){
+        NumOpe( &reg, pParm[i], Type( DEF_LONG ), type, &bUseHeap );
+        if( type.IsObject() ){
             //キャスト演算子のオーバーロードに対応する
             CallCastOperatorProc(reg,
-                TypeInfo.type,TypeInfo.u.lpIndex,
-                bUseHeap,DEF_LONG,-1);
-            TypeInfo.type=DEF_LONG;
-        }
-
-        if(!IsWholeNumberType(TypeInfo.type)) SetError(46,NULL,cp);
-        ExtendTypeTo64(TypeInfo.type,reg);
+                type,
+                bUseHeap, Type(DEF_LONG) );
+            type.SetBasicType( DEF_LONG );
+        }
+
+        if( !type.IsWhole() ){
+            SetError(46,NULL,cp);
+        }
+        ExtendTypeTo64( type.GetBasicType(), reg );
 
         if(reg==REG_R14){
@@ -168 +170 @@
         HeapDefaultFree(pParm[i]);
     }
-
-    TypeSize=GetTypeSize(type,lpIndex);
 
     //imul r12,TypeSize
@@ -175 +175 @@
     OpBuffer[obp++]=(char)0x69;
     OpBuffer[obp++]=(char)0xE4;
-    *((long *)(OpBuffer+obp))=TypeSize;
+    *((long *)(OpBuffer+obp))=type.GetSize();
     obp+=sizeof(long);
 
@@ -186 +186 @@
     OpBuffer[obp++]=(char)0xDC;
 
-    return 1;
+    return true;
 }
-BOOL GetMemberOffset(bool isErrorEnabled, bool isWriteAccess, CClass *pobj_c, char *member, int *pType, RELATIVE_VAR *pRelativeVar, LONG_PTR *plpNestIndex, BOOL bPrivateAccess){
+bool _member_offset(bool isErrorEnabled, bool isWriteAccess, const CClass &objClass, const char *member, RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess){
     int i;
 
@@ -202 +202 @@
     CClass::RefType refType;
     lstrcpy(VarName,member);
-    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
+    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return false;
 
 
@@ -209 +209 @@
     ////////////////////////////
 
-    int offset = pobj_c->GetMemberOffset( VarName, &i );
-    if(i==pobj_c->iMemberNum){
+    int offset = objClass.GetMemberOffset( VarName, &i );
+    if(i==objClass.iMemberNum){
         if(isErrorEnabled) SetError(103,VarName,cp);
-        return 0;
-    }
-
-    CMember *pMember=pobj_c->ppobj_Member[i];
+        return false;
+    }
+
+    CMember *pMember=objClass.ppobj_Member[i];
 
 
     //アクセシビリティをチェック
-    if(pobj_c==pobj_CompilingClass){
+    if(&objClass==pobj_CompilingClass){
         //同一クラスオブジェクトの場合はプライベートアクセスを容認する
         if(pMember->dwAccess==ACCESS_NON){
             if(isErrorEnabled) SetError(107,VarName,cp);
-            return 0;
+            return false;
         }
     }
@@ -230 +230 @@
             pMember->dwAccess==ACCESS_NON){
             if(isErrorEnabled) SetError(107,VarName,cp);
-            return 0;
+            return false;
         }
         else if(bPrivateAccess==0&&pMember->dwAccess==ACCESS_PROTECTED){
             if(isErrorEnabled) SetError(108,VarName,cp);
-            return 0;
+            return false;
         }
     }
@@ -242 +242 @@
     if( pMember->IsConst() &&       //定数メンバである
         isWriteAccess &&                            //書き込みアクセスを要求されている
-        pobj_c->IsCompilingConstructor() == false   //コンストラクタ コンパイル中を除く
+        objClass.IsCompilingConstructor() == false  //コンストラクタ コンパイル中を除く
         ){
             //Const定義の変数に書き込みアクセスをしようとした場合
@@ -248 +248 @@
     }
 
-    *pType=pMember->TypeInfo.type;
-    *plpNestIndex=pMember->TypeInfo.u.lpIndex;
+    resultType = *pMember;
 
     //ポインタ変数の場合
-    if(IsPtrType(*pType)){
+    if( resultType.IsPointer() ){
         if(pMember->SubScripts[0]==-1){
             lstrcpy(lpPtrOffset,array);
@@ -261 +260 @@
         if(lpPtrOffset[0]){
             if(isErrorEnabled) SetError(16,member,cp);
-            return 0;
+            return false;
         }
     }
@@ -276 +275 @@
     if(array[0]){
         //配列オフセット
-        if(!GetArrayOffset(pMember->SubScripts,array,*pType,pMember->TypeInfo.u.lpIndex)){
+        if(!GetArrayOffset(pMember->SubScripts,array,*pMember)){
             if(isErrorEnabled) SetError(14,member,cp);
         }
     }
     else if(pMember->SubScripts[0]!=-1){
-        *pType|=FLAG_PTR;
+        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
     }
 
@@ -287 +286 @@
         //入れ子構造の場合
 
-        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
+        if( resultType.IsObject() || resultType.IsStruct() ){
             if( refType != CClass::Dot ){
                 if(isErrorEnabled) SetError(104,member,cp);
-                return 0;
-            }
-
-            if( *pType==DEF_OBJECT ){
+                return false;
+            }
+
+            if( resultType.IsObject() ){
                 // 参照内容へのポインタを抽出
                 SetRelativeOffset( *pRelativeVar );
             }
         }
-        else if(*pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT){
+        else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
             //構造体ポインタ型メンバ変数
 
             if(lpPtrOffset[0]){
                 //pObj[n].member
-                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Dot ){
-                    if(isErrorEnabled) SetError(104,member,cp);
-                    return 0;
+                if( ( resultType.IsObjectPtr() || resultType.IsStructPtr() )
+                    && refType != CClass::Dot ){
+                        if(isErrorEnabled) SetError(104,member,cp);
+                        return false;
                 }
 
                 //直接参照に切り替え
-                SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
+                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
                 pRelativeVar->dwKind=VAR_DIRECTMEM;
 
@@ -316 +316 @@
             else{
                 //pObj->member
-                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Pointer ){
-                    if(isErrorEnabled) SetError(104,member,cp);
-                    return 0;
+                if( (resultType.IsObjectPtr() || resultType.IsStructPtr() )
+                    && refType != CClass::Pointer ){
+                        if(isErrorEnabled) SetError(104,member,cp);
+                        return false;
                 }
 
@@ -324 +325 @@
             }
         }
-        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
+        else if( resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_OBJECT,2)
+            || resultType.GetBasicType() == MAKE_PTR_TYPE(DEF_STRUCT,2)){
             //構造体ポインタのポインタ型メンバ変数
 
@@ -331 +333 @@
                 if( refType != CClass::Pointer ){
                     if(isErrorEnabled) SetError(104,member,cp);
-                    return 0;
+                    return false;
                 }
 
                 //直接参照に切り替え
-                SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
+                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
                 pRelativeVar->dwKind=VAR_DIRECTMEM;
 
@@ -345 +347 @@
             else{
                 if(isErrorEnabled) SetError(104,member,cp);
-                return 0;
-            }
-        }
-
-        if(!GetMemberOffset(
+                return false;
+            }
+        }
+
+        if(!_member_offset(
             isErrorEnabled,
             isWriteAccess,
-            pMember->TypeInfo.u.pobj_Class,
+            pMember->GetClass(),
             NestMember,
-            pType,
             pRelativeVar,
-            plpNestIndex,
-            0)) return 0;
+            resultType,
+            0)) return false;
     }
 
     if(lpPtrOffset[0]){
-        SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
+        SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
         pRelativeVar->dwKind=VAR_DIRECTMEM;
     }
 
-    return 1;
+    return true;
 }
 void GetWithName(char *buffer){
@@ -380 +381 @@
     //自身のオブジェクトのThisポインタをregにコピー
 
-    extern VARIABLE *LocalVar;
     RELATIVE_VAR RelativeVar;
     RelativeVar.dwKind=VAR_LOCAL;
@@ -388 +388 @@
     SetReg_WholeVariable(DEF_PTR_VOID,&RelativeVar,reg);
 }
-BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
-    extern BOOL bCompilingGlobal;
+bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss){
     int i;
-    LONG_PTR lpIndex;
     char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
 
@@ -406 +404 @@
 
         void *pInfo;
-        int idProc=GetProc(VarName,&pInfo);
+        int idProc=GetProc(VarName,(void **)&pInfo);
 
         if(idProc){
             pRelativeVar->dwKind=VAR_DIRECTMEM;
+
+            Type type;
 
             //////////////////////////////////////////////////////
@@ -420 +420 @@
                 ////////////////
 
-                *pType=CallProc(idProc,pInfo,VarName,array,&lpIndex);
+                CallProc(idProc,pInfo,VarName,array,type);
 
                 //戻り値をr11にコピー
@@ -430 +430 @@
             }////////////////////////////////////////////
 
-            LONG_PTR lp2;
-            if(!GetMemberOffset(
+            if(!_member_offset(
                 isErrorEnabled,
                 isWriteAccess,
-                (CClass *)lpIndex,
-                member,pType,pRelativeVar,&lp2,0)) return 0;
-            if(plpIndex) *plpIndex=lp2;
-
-            return 1;
+                type.GetClass(),
+                member,pRelativeVar,resultType,0)) return false;
+
+            return true;
         }
     }
@@ -447 +445 @@
     GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
 
-    int *pSubScripts;
+    const int *pSubScripts;
     bool bConst = false;
 
 
-    if(bCompilingGlobal==0){
+    if( UserProc::IsLocalAreaCompiling() ){
         //////////////////
         // ローカル変数
         //////////////////
 
-        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){
+        const Variable *pVar = UserProc::CompilingUserProc().localVars.BackSearch( VarName );
+        if( pVar ){
             //ポインタ変数の場合
-            if(IsPtrType(LocalVar[i].type)){
-                if(LocalVar[i].SubScripts[0]==-1){
+            if( pVar->IsPointer() ){
+                if( !pVar->IsArray() ){
                     lstrcpy(lpPtrOffset,array);
                     array[0]=0;
@@ -475 +467 @@
                     SetError(16,variable,cp);
                     pRelativeVar->dwKind=NON_VAR;
-                    return 0;
+                    return false;
                 }
             }
 
-            pRelativeVar->offset=-LocalVar[i].offset;
+            pRelativeVar->offset=-pVar->offset;
             pRelativeVar->bOffsetOffset=0;
-            if(LocalVar[i].fRef){
+            if( pVar->IsRef() ){
                 // 参照型
                 pRelativeVar->dwKind = VAR_REFLOCAL;
             }
             else pRelativeVar->dwKind=VAR_LOCAL;
-            *pType=LocalVar[i].type;
-            lpIndex=LocalVar[i].u.index;
-            if(plpIndex) *plpIndex=lpIndex;
-            pSubScripts=LocalVar[i].SubScripts;
-            bConst = LocalVar[i].bConst;
+            resultType = *pVar;
+            pSubScripts=pVar->GetSubScriptsPtr();
+            bConst = pVar->IsConst();
 
             goto ok;
@@ -506 +496 @@
             SetThisPtrToReg(REG_R11);
 
-            *pType=DEF_OBJECT;
             pRelativeVar->dwKind=VAR_DIRECTMEM;
 
-            if(plpIndex) *plpIndex=(LONG_PTR)pobj_CompilingClass;
-            return 1;
+            resultType.SetType( DEF_OBJECT, pobj_CompilingClass );
+            return true;
         }
 
@@ -542 +531 @@
 
         pRelativeVar->dwKind=VAR_DIRECTMEM;
-        if(!GetMemberOffset(
+        if(!_member_offset(
             isErrorEnabled,
             isWriteAccess,
-            pobj_CompilingClass,
+            *pobj_CompilingClass,
             variable,
-            pType,
             pRelativeVar,
-            &lpIndex,1)) return 0;
-        if(plpIndex) *plpIndex=lpIndex;
-        return 1;
+            resultType,1)) return false;
+        return true;
     }
 
 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){
+    {
+        const Variable *pVar;
+
+        //////////////////////////
+        // 静的ローカル変数
+        // ※"Static.Object.Method.Variable"
+        //////////////////////////
+
+        char temporary[VN_SIZE];
+        if( UserProc::IsLocalAreaCompiling() ){
+            GetNowStaticVarFullName(VarName,temporary);
+
+            pVar = globalVars.Find( temporary );
+            if( pVar ){
+                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);
+            pVar = globalVars.Find( temp2 );
+            if( pVar ){
+                lstrcpy(member,tempMember);
+                lstrcpy(array,tempArray);
+                goto GlobalOk;
+            }
+        }
+
+        if(pobj_CompilingClass){
+            //自身のクラスから静的メンバを参照する場合
+            char temp2[VN_SIZE];
+            sprintf(temp2,"%s.%s",pobj_CompilingClass->name,VarName);
+            pVar = globalVars.Find( temp2 );
+            if( pVar ){
+                goto GlobalOk;
+            }
+        }
+
+        /////////////////////
+        // グローバル変数
+        /////////////////////
+
+        pVar = globalVars.BackSearch( VarName );
+        if( pVar ){
             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(isErrorEnabled) SetError(3,variable,cp);
-    pRelativeVar->dwKind=NON_VAR;
-    return 0;
+
+        if(isErrorEnabled) SetError(3,variable,cp);
+        pRelativeVar->dwKind=NON_VAR;
+        return false;
 
 
 
 GlobalOk:
-    //ポインタ変数の場合
-    if(IsPtrType(GlobalVar[i].type)){
-        if(GlobalVar[i].SubScripts[0]==-1){
-            lstrcpy(lpPtrOffset,array);
-            array[0]=0;
-        }
-    }
-    else{
-        if(lpPtrOffset[0]){
-            SetError(16,variable,cp);
-            pRelativeVar->dwKind=NON_VAR;
-            return 0;
-        }
-    }
-
-    pRelativeVar->offset=GlobalVar[i].offset;
-    pRelativeVar->bOffsetOffset=0;
-    if(GlobalVar[i].fRef){
-        // 参照型
-        pRelativeVar->dwKind = VAR_REFGLOBAL;
-    }
-    else pRelativeVar->dwKind=VAR_GLOBAL;
-    *pType=GlobalVar[i].type;
-    lpIndex=GlobalVar[i].u.index;
-    if(plpIndex) *plpIndex=lpIndex;
-    pSubScripts=GlobalVar[i].SubScripts;
-    bConst = GlobalVar[i].bConst;
+        //ポインタ変数の場合
+        if( pVar->IsPointer() ){
+            if( !pVar->IsArray() ){
+                lstrcpy(lpPtrOffset,array);
+                array[0]=0;
+            }
+        }
+        else{
+            if(lpPtrOffset[0]){
+                SetError(16,variable,cp);
+                pRelativeVar->dwKind=NON_VAR;
+                return false;
+            }
+        }
+
+        pRelativeVar->offset=pVar->offset;
+        pRelativeVar->bOffsetOffset=0;
+        if( pVar->IsRef() ){
+            // 参照型
+            pRelativeVar->dwKind = VAR_REFGLOBAL;
+        }
+        else pRelativeVar->dwKind=VAR_GLOBAL;
+        resultType = *pVar;
+        pSubScripts=pVar->GetSubScriptsPtr();
+        bConst = pVar->IsConst();
+    }
 
 
@@ -671 +645 @@
     if( bConst && isWriteAccess ){
         //Const定義の変数に書き込みアクセスをしようとした場合
-        if( *pType == DEF_OBJECT ){
+        if( resultType.IsObject() ){
             //オブジェクト定数
             SetError(130, VarName, cp );
@@ -683 +657 @@
     if(array[0]==0&&pSubScripts[0]!=-1){
         //配列の先頭ポインタを示す場合
-        *pType|=FLAG_PTR;
+        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
         if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
-        return 1;
+        return true;
     }
 
@@ -696 +670 @@
     }
     if(array[0]){
-        if(!GetArrayOffset(pSubScripts,array,*pType,lpIndex)){
+        if(!GetArrayOffset(pSubScripts,array,resultType)){
             SetError(14,variable,cp);
             pRelativeVar->dwKind=NON_VAR;
-            return 0;
+            return false;
         }
     }
     if(member[0]){
-        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
+        if( resultType.IsObject() || resultType.IsStruct() ){
             //実態オブジェクトのメンバを参照（obj.member）
             if( refType != CClass::Dot ){
                 SetError(104,VarName,cp);
                 pRelativeVar->dwKind=NON_VAR;
-                return 0;
-            }
-
-            if( *pType==DEF_OBJECT ){
+                return false;
+            }
+
+            if( resultType.IsObject() ){
                 // 参照内容へのポインタを抽出
                 SetRelativeOffset( *pRelativeVar );
             }
         }
-        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
+        else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
             //ポインタオブジェクトが示すメンバを参照
             if(lpPtrOffset[0]){
@@ -723 +697 @@
                     SetError(104,VarName,cp);
                     pRelativeVar->dwKind=NON_VAR;
-                    return 0;
+                    return false;
                 }
-                SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
+                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
                 pRelativeVar->dwKind=VAR_DIRECTMEM;
             }
@@ -733 +707 @@
                     SetError(104,VarName,cp);
                     pRelativeVar->dwKind=NON_VAR;
-                    return 0;
+                    return false;
                 }
 
@@ -743 +717 @@
             }
         }
-        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
+        else if( resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_OBJECT,2) || resultType.GetBasicType()==MAKE_PTR_TYPE(DEF_STRUCT,2)){
             //ポインタオブジェクトが示すメンバを参照
             if(lpPtrOffset[0]){
@@ -750 +724 @@
                     SetError(104,VarName,cp);
                     pRelativeVar->dwKind=NON_VAR;
-                    return 0;
+                    return false;
                 }
 
-                SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
+                SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
                 pRelativeVar->dwKind=VAR_DIRECTMEM;
 
@@ -765 +739 @@
                 SetError(104,VarName,cp);
                 pRelativeVar->dwKind=NON_VAR;
-                return 0;
+                return false;
             }
         }
@@ -771 +745 @@
             SetError(102,VarName,cp);
             pRelativeVar->dwKind=NON_VAR;
-            return 0;
-        }
-
-        LONG_PTR lp2;
-        if(!GetMemberOffset(
+            return false;
+        }
+
+        if(!_member_offset(
             isErrorEnabled,
             isWriteAccess,
-            (CClass *)lpIndex,
-            member,pType,pRelativeVar,&lp2,0)) return 0;
-        if(plpIndex) *plpIndex=lp2;
-
-        return 1;
+            resultType.GetClass(),
+            member,pRelativeVar,resultType,0)) return false;
+
+        return true;
     }
 
     if(lpPtrOffset[0]){
-        SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
+        SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
         pRelativeVar->dwKind=VAR_DIRECTMEM;
     }
 
-    return 1;
+    return true;
 }
 
-BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
+bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,char *InitBuf){
     extern BYTE *initGlobalBuf;
-    int i,i2,i3,TypeSize;
+    int i,i2,i3;
     char temporary[VN_SIZE];
 
@@ -802 +774 @@
         InitBuf[lstrlen(InitBuf)-1]=0;
 
-        TypeSize=GetTypeSize(type,lpIndex);
+        int typeSize = type.GetSize();
 
         if(SubScripts[0]!=-1){
-            TypeSize*=JumpSubScripts(SubScripts+1);
+            typeSize*=JumpSubScripts(SubScripts+1);
             i=0;
             i2=0;
@@ -815 +787 @@
                 i=GetOneParameter(InitBuf,i,temporary);
                 if(!SetInitGlobalData(
-                    offset+i2*TypeSize,
+                    offset+i2*typeSize,
                     type,
-                    lpIndex,
                     SubScripts+1,
-                    temporary)) return 0;
+                    temporary)) return false;
                 i2++;
                 if(InitBuf[i]=='\0') break;
             }
-            return -1;
-        }
-
-        if(type==DEF_STRUCT){
-            CClass *pobj_c;
-            pobj_c=(CClass *)lpIndex;
-
-            for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
+            return true;
+        }
+
+        if(type.IsStruct()){
+            const CClass &objClass = type.GetClass();
+
+            for(i=0,i2=0;i2<objClass.iMemberNum;i2++){
                 i=GetOneParameter(InitBuf,i,temporary);
 
-                i3=pobj_c->GetMemberOffset( pobj_c->ppobj_Member[i2]->name, NULL );
+                i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->name, NULL );
 
                 if(!SetInitGlobalData(offset+i3,
-                    pobj_c->ppobj_Member[i2]->TypeInfo.type,
-                    pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
-                    pobj_c->ppobj_Member[i2]->SubScripts,
-                    temporary)) return 0;
+                    *objClass.ppobj_Member[i2],
+                    objClass.ppobj_Member[i2]->SubScripts,
+                    temporary)) return false;
 
                 if(InitBuf[i]=='\0') break;
             }
-            if(i2+1!=pobj_c->iMemberNum){
+            if(i2+1!=objClass.iMemberNum){
                 SetError(41,0,cp);
-                return 0;
-            }
-            return 1;
+                return false;
+            }
+            return true;
         }
 
         SetError(41,0,cp);
-        return 0;
+        return false;
     }
 
@@ -859 +828 @@
     ///////////////////////////////////////
 
-    if( type == DEF_OBJECT || type == DEF_STRUCT ){
+    if( type.IsObject() || type.IsStruct() ){
         //オブジェクトまたは構造体の場合はありえない
         SetError(300,NULL,cp);
-        return 0;
+        return false;
     }
 
     if(SubScripts[0]!=-1){
         SetError(41,0,cp);
-        return 0;
+        return false;
     }
 
     double dbl;
     _int64 i64data;
-    int CalcType;
-    LONG_PTR lpCalcIndex;
-
-    CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
-    if(!CalcType){
+    Type calcType;
+
+    if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
         //動的データだった場合
-        return 0;
-    }
-    if(IsRealNumberType(CalcType)){
+        return false;
+    }
+    if( calcType.IsReal() ){
         memcpy(&dbl,&i64data,sizeof(double));
         i64data=(_int64)dbl;
@@ -889 +856 @@
     CheckDifferentType(
         type,
-        lpIndex,
-        CalcType,
-        lpCalcIndex,
+        calcType,
         0,0);
 
-    if(type==DEF_DOUBLE)
+    if( type.IsDouble() ){
         *(double *)(initGlobalBuf+offset)=(double)dbl;
-    else if(type==DEF_SINGLE)
-            *(float *)(initGlobalBuf+offset)=(float)dbl;
-    else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
-        if(type==typeOfPtrChar&&lpCalcIndex==LITERAL_STRING){
+    }
+    else if( type.IsSingle() ){
+        *(float *)(initGlobalBuf+offset)=(float)dbl;
+    }
+    else if( type.Is64() || type.IsPointer() ){
+        if(type.GetBasicType()==typeOfPtrChar && type.GetIndex()==LITERAL_STRING){
             //文字列定数のとき
 
@@ -923 +890 @@
         }
     }
-    else if(type==DEF_LONG||type==DEF_DWORD)
+    else if( type.IsDWord() || type.IsLong() ){
         *(DWORD *)(initGlobalBuf+offset)=(DWORD)i64data;
-    else if(type==DEF_INTEGER||type==DEF_WORD || (isUnicode&&type==DEF_CHAR))
+    }
+    else if( type.IsWord() || type.IsInteger() ){
         *(WORD *)(initGlobalBuf+offset)=(WORD)i64data;
-    else if(type==DEF_SBYTE||type==DEF_BYTE||type==DEF_BOOLEAN || (isUnicode==false&&type==DEF_CHAR))
+    }
+    else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){
         *(BYTE *)(initGlobalBuf+offset)=(BYTE)i64data;
-
-    return 1;
+    }
+
+    return true;
 }
-BOOL InitLocalVar(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf){
-    int i,i2,i3,TypeSize;
+bool InitLocalVar(int offset,const Type &type,const int *SubScripts,char *InitBuf){
+    int i,i2,i3;
     char temporary[VN_SIZE];
 
@@ -940 +910 @@
         InitBuf[lstrlen(InitBuf)-1]=0;
 
-        TypeSize=GetTypeSize(type,lpIndex);
+        int typeSize = type.GetSize();
 
         if(SubScripts[0]!=-1){
-            TypeSize*=JumpSubScripts(SubScripts+1);
+            typeSize*=JumpSubScripts(SubScripts+1);
             i=0;
             i2=0;
@@ -949 +919 @@
                 if(SubScripts[0]<i2){
                     SetError(41,0,cp);
-                    return 0;
+                    return false;
                 }
                 i=GetOneParameter(InitBuf,i,temporary);
                 if(!InitLocalVar(
-                    offset+i2*TypeSize,
+                    offset+i2*typeSize,
                     type,
-                    lpIndex,
                     SubScripts+1,
-                    temporary)) return 0;
+                    temporary)) return false;
                 i2++;
                 if(InitBuf[i]=='\0') break;
             }
-            return -1;
-        }
-
-        if(type==DEF_STRUCT){
-            CClass *pobj_c;
-            pobj_c=(CClass *)lpIndex;
-
-            for(i=0,i2=0;i2<pobj_c->iMemberNum;i2++){
+            return true;
+        }
+
+        if(type.IsStruct()){
+            const CClass &objClass = type.GetClass();
+
+            for(i=0,i2=0;i2<objClass.iMemberNum;i2++){
                 i=GetOneParameter(InitBuf,i,temporary);
 
-                i3=pobj_c->GetMemberOffset( pobj_c->ppobj_Member[i2]->name, NULL );
+                i3=objClass.GetMemberOffset( objClass.ppobj_Member[i2]->name, NULL );
 
                 if(!InitLocalVar(offset+i3,
-                    pobj_c->ppobj_Member[i2]->TypeInfo.type,
-                    pobj_c->ppobj_Member[i2]->TypeInfo.u.lpIndex,
-                    pobj_c->ppobj_Member[i2]->SubScripts,
-                    temporary)) return 0;
+                    *objClass.ppobj_Member[i2],
+                    objClass.ppobj_Member[i2]->SubScripts,
+                    temporary)) return false;
 
                 if(InitBuf[i]=='\0') break;
             }
-            if(i2+1!=pobj_c->iMemberNum){
+            if(i2+1!=objClass.iMemberNum){
                 SetError(41,0,cp);
                 return 0;
             }
-            return 1;
+            return true;
         }
 
         SetError(41,0,cp);
-        return 0;
+        return false;
     }
 
@@ -999 +966 @@
     if(SubScripts[0]!=-1){
         SetError(41,0,cp);
-        return 0;
+        return false;
     }
 
     double dbl;
     _int64 i64data;
-    int CalcType;
-    LONG_PTR lpCalcIndex;
-    CalcType=StaticCalculation(false, InitBuf,type,&i64data,&lpCalcIndex);
-    if(!CalcType){
+    Type calcType;
+
+    if( !StaticCalculation(false, InitBuf,type.GetBasicType(),&i64data,calcType) ){
         //動的データだった場合
-        return 0;
-    }
-    if(IsRealNumberType(CalcType)){
+        return false;
+    }
+    if( calcType.IsReal() ){
         memcpy(&dbl,&i64data,sizeof(double));
         i64data=(_int64)dbl;
@@ -1020 +986 @@
     CheckDifferentType(
         type,
-        lpIndex,
-        CalcType,
-        lpCalcIndex,
+        calcType,
         0,0);
 
-    if(type==DEF_DOUBLE){
+    if( type.IsDouble() ){
         memcpy(&i64data,&dbl,sizeof(double));
 
@@ -1037 +1001 @@
         obp+=sizeof(long);
     }
-    else if(type==DEF_SINGLE){
+    else if( type.IsSingle() ){
         float flt;
         flt=(float)dbl;
@@ -1047 +1011 @@
         obp+=sizeof(long)+sizeof(long);
     }
-    else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
-        if(type==typeOfPtrChar&&lpCalcIndex==LITERAL_STRING){
+    else if( type.Is64() || type.IsPointer() ){
+        if(type.GetBasicType()==typeOfPtrChar && type.GetIndex()==LITERAL_STRING){
             //文字列定数のとき
 
@@ -1088 +1052 @@
         }
     }
-    else if(type==DEF_LONG||type==DEF_DWORD){
+    else if( type.IsDWord() || type.IsLong() ){
         //mov dword ptr[rsp+offset],value
         op_mov_MV(sizeof(long),REG_RSP,offset,USE_OFFSET,(int)i64data);
@@ -1095 +1059 @@
         obp+=sizeof(long)+sizeof(long);
     }
-    else if(type==DEF_INTEGER||type==DEF_WORD || (isUnicode&&type==DEF_CHAR)){
+    else if( type.IsWord() || type.IsInteger() ){
         //mov word ptr[rsp+offset],value
         op_mov_MV(sizeof(short),REG_RSP,offset,USE_OFFSET,(int)i64data);
@@ -1102 +1066 @@
         obp+=sizeof(long)+sizeof(short);
     }
-    else if(type==DEF_SBYTE||type==DEF_BYTE||type==DEF_BOOLEAN || (isUnicode==false&&type==DEF_CHAR)){
+    else if( type.IsSByte() || type.IsByte() || type.IsBoolean() ){
         //mov byte ptr[rsp+offset],value
         op_mov_MV(sizeof(char),REG_RSP,offset,USE_OFFSET,(int)i64data);
@@ -1109 +1073 @@
         obp+=sizeof(long)+sizeof(char);
     }
-    return 1;
+    return true;
 }
 
-void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
-    extern BOOL bCompilingGlobal;
-    if(bCompilingGlobal){
+void dim(bool isRef, char *VarName,int *SubScripts,Type &type,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
+    if( UserProc::IsGlobalAreaCompiling() ){
         /////////////////////////
         // グローバル変数
         /////////////////////////
 
-        AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
+        AddGlobalVariable(isRef,VarName,SubScripts,type,InitBuf,ConstractParameter,dwFlags);
     }
     else{
@@ -1126 +1089 @@
         /////////////////
 
-        int i2,i3;
-
-        for(i2=0;i2<MaxLocalVarNum;i2++){
-            if(LocalVar[i2].bLiving&&obj_LexScopes.GetNowLevel()==LocalVar[i2].ScopeLevel){
-                if(lstrcmp(LocalVar[i2].name,VarName)==0){
-                    //２重定義のエラー
-                    SetError(15,VarName,cp);
-                    return;
-                }
-            }
-        }
-
-        LocalVar=(VARIABLE *)HeapReAlloc(hHeap,0,LocalVar,(MaxLocalVarNum+1)*sizeof(VARIABLE));
-        VARIABLE *pVar = &LocalVar[MaxLocalVarNum];
-        MaxLocalVarNum++;
-
-        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;
-        }
-        int VarSize=TypeSize*i2;
-        if(VarSize%8) VarSize+=8-(VarSize%8);
-
-        //変数データを追加
-        lstrcpy(pVar->name,VarName);
-        if(dwFlags & DIMFLAG_CONST) pVar->bConst = true;
-        else pVar->bConst = false;
-        if(SubScripts[0]==-1) pVar->bArray=0;
-        else pVar->bArray=1;
-        pVar->type=TypeInfo.type;
-        pVar->u.index=TypeInfo.u.lpIndex;
+        if( UserProc::CompilingUserProc().localVars.DuplicateCheck( VarName ) ){
+            //２重定義のエラー
+            SetError(15,VarName,cp);
+            return;
+        }
+
+        bool isConst = ( dwFlags & DIMFLAG_CONST ) ? true:false;
+
+        Variable *pVar = new Variable( VarName, type, isConst, isRef );
+
+        if( SubScripts[0] != -1 ){
+            //配列あり
+            pVar->SetArray( SubScripts );
+        }
+
+        //コンストラクタ用パラメータ
+        pVar->paramStrForConstructor = ConstractParameter;
+
+        //レキシカルスコープ
+        pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
+        pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
+        pVar->bLiving=TRUE;
+
+        //エラー用
+        pVar->source_code_address=cp;
+
+        // 変数を追加
+        UserProc::CompilingUserProc().localVars.push_back( pVar );
 
         //アラインメントを考慮
-        if( pVar->type==DEF_STRUCT ){
-            int alignment = pVar->u.pobj_c->iAlign;
+        if( pVar->IsStruct() ){
+            int alignment = pVar->GetClass().iAlign;
             if( alignment ){
                 if( AllLocalVarSize % alignment ){
@@ -1178 +1128 @@
         }
 
-        AllLocalVarSize+=VarSize;
-        pVar->offset=AllLocalVarSize;
+        AllLocalVarSize += pVar->GetMemorySize();
+        pVar->offset = AllLocalVarSize;
 
         //レキシカルスコープ
@@ -1188 +1138 @@
         if(InitBuf[0]){
             //初期代入時のみ、書き込みアクセスを許可する
-            bool bConstBack = pVar->bConst;
-            pVar->bConst = false;
+            if( isConst ){
+                pVar->ConstOff();
+            }
 
             int result = 0;
-            if( pVar->type != DEF_OBJECT ){
+            if( !pVar->IsObject() ){
                 result = InitLocalVar(-pVar->offset,
-                    pVar->type,
-                    pVar->u.index,
-                    pVar->SubScripts,
+                    *pVar,
+                    pVar->GetSubScriptsPtr(),
                     InitBuf);
             }
@@ -1207 +1157 @@
             }
 
-            pVar->bConst = bConstBack;
+            if( isConst ){
+                pVar->ConstOn();
+            }
         }
         else{
@@ -1216 +1168 @@
 
             //mov rdx, VarSize
-            op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
+            op_mov_RV( sizeof(_int64), REG_RDX, pVar->GetMemorySize() );
 
             //mov rcx, rsp
@@ -1228 +1180 @@
 
             //call FillMemory
-            DECLAREINFO *pdi;
-            pdi=GetDeclareHash("FillMemory");
-            op_call( pdi );
+            DllProc *pDllProc;
+            pDllProc=GetDeclareHash("FillMemory");
+            op_call( pDllProc );
         }
     }
 
     //コンストラクタ呼び出し
-    if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
+    if( type.IsObject() &&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
         char objectSize[255];
         if( SubScripts[0] == -1 ){
@@ -1246 +1198 @@
             sprintf( objectSize, "%d", SubScripts[0] );
         }
-        Operator_New( *TypeInfo.u.pobj_Class, objectSize, ConstractParameter, TypeInfo );
-
-        int type;
-        LONG_PTR lpIndex;
+        Operator_New( type.GetClass(), objectSize, ConstractParameter, type );
+
+        Type tempType;
         RELATIVE_VAR RelativeVar;
-        GetVarOffset( true, false, VarName, &type, &RelativeVar, &lpIndex );
+        GetVarOffset( true, false, VarName, &RelativeVar, tempType );
         if( RelativeVar.dwKind == VAR_DIRECTMEM ){
             SetError();
@@ -1258 +1209 @@
     }
 
-    if(TypeInfo.type==DEF_OBJECT){
-        if(TypeInfo.u.pobj_Class->IsAbstract()){
+    if( type.IsObject() ){
+        if( type.GetClass().IsAbstract() ){
             //抽象クラスだったとき
-            SetError(125,TypeInfo.u.pobj_Class->name,cp);
+            SetError(125,type.GetClass().name,cp);
         }
     }
 }
-void dim(char *Parameter,DWORD dwFlags){
-    extern BOOL bCompilingGlobal;
-    extern HANDLE hHeap;
-    int i2;
-    char VarName[VN_SIZE];
-
-    //参照型かどうか
-    bool isRef = false;
-
-    i2 = 0;
-
-    if( Parameter[i2] == 1 && Parameter[i2+1] == ESC_BYREF ){
-        //参照型
-        isRef = true;
-        Parameter += 2;
-    }
-
-    if(dwFlags & DIMFLAG_CONST){
-
-        //////////////////////////////////
-        // 定数変数の場合を考慮
-        //////////////////////////////////
-        for(;;i2++){
-            if(Parameter[i2] == '=' ||
-                Parameter[i2] == 1 && Parameter[i2] == ESC_AS ||
-                Parameter[i2] =='('){
-                    VarName[i2] = 0;
-                    break;
-            }
-            VarName[i2] = Parameter[i2];
-        }
-
-        //定数と２重定義されていないる場合は抜け出す
-        if(CDBConst::obj.GetType(VarName)){
-            return;
-        }
-
-        //定数マクロとして定義されている場合は抜け出す
-        if(GetConstHash(VarName)){
-            return;
-        }
-    }
-
-
-    //構文を解析
-    int SubScripts[MAX_ARRAYDIM];
-    TYPEINFO TypeInfo;
-    char InitBuf[8192];
-    char ConstractParameter[VN_SIZE];
-    if(!GetDimentionFormat(Parameter, isRef , VarName,SubScripts,&TypeInfo,InitBuf,ConstractParameter))
-        return;
-
-
-    //定数と２重定義されていないかを調べる
-    if(CDBConst::obj.GetType(VarName)){
-        SetError(15,VarName,cp);
-        return;
-    }
-
-    //定数マクロとして定義されている場合
-    if(GetConstHash(VarName)){
-        SetError(15,VarName,cp);
-        return;
-    }
-
-
-    //タイプサイズを取得
-    int TypeSize;
-    TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
-
-    extern BOOL bCompilingGlobal;
-    if(dwFlags&DIMFLAG_STATIC){
-        if(bCompilingGlobal){
-            SetError(60,NULL,cp);
-            return;
-        }
-
-        /////////////////////
-        // Static変数
-        // ※"Static.Object.Method.Variable"
-        /////////////////////
-
-        char temporary[VN_SIZE];
-        GetNowStaticVarFullName(VarName,temporary);
-
-        dim( isRef,temporary,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
-
-        /*
-        Note: 静的変数のコンストラクタ呼び出しは
-            _System_InitStaticLocalVariables関数内で一括して行う
-        */
-    }
-    else{
-        dim( isRef,VarName,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
-    }
-}
-void OpcodeDim(char *Parameter,DWORD dwFlags){
-    int i,i2,i3,IsStr=0;
-    char temporary[8192];
-
-    for(i=0,i2=0;;i++,i2++){
-        if(Parameter[i]=='\"') IsStr^=1;
-        if(Parameter[i]=='('&&IsStr==0){
-            i3=GetStringInPare(temporary+i2,Parameter+i);
-            i+=i3-1;
-            i2+=i3-1;
-            continue;
-        }
-        if(Parameter[i]=='['&&IsStr==0){
-            i3=GetStringInBracket(temporary+i2,Parameter+i);
-            i+=i3-1;
-            i2+=i3-1;
-            continue;
-        }
-        if((Parameter[i]==','&&IsStr==0)||
-            Parameter[i]=='\0'){
-            temporary[i2]=0;
-
-            dim(temporary,dwFlags);
-
-            if(Parameter[i]=='\0') break;
-            i2=-1;
-            continue;
-        }
-        temporary[i2]=Parameter[i];
-    }
-}
-
 void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar){
     if(!IsGeneralReg(reg)) SetError(300,NULL,cp);

BasicCompiler64/MakePeHdr.cpp

@@ -6 +6 @@
 // 特殊関数の構造体ポインタ
 ////////////////////////////
-SubInfo
+UserProc
     *pSub_System_StartupProgram,
     *pSub_DebugSys_StartProc,
@@ -136 +136 @@
 
     //関数ポインタ情報を初期化
-    extern PROCPTRINFO *pProcPtrInfo;
+    extern ProcPointer **ppProcPointer;
     extern int ProcPtrInfoNum;
-    pProcPtrInfo=(PROCPTRINFO *)HeapAlloc(hHeap,0,1);
+    ppProcPointer=(ProcPointer **)HeapAlloc(hHeap,0,1);
     ProcPtrInfoNum=0;
 
@@ -170 +170 @@
 
     if(pSub_System_StartupProgram=GetSubHash("_System_StartupProgram",1))
-        pSub_System_StartupProgram->bUse=1;
+        pSub_System_StartupProgram->Using();
 
     if(pSub_DebugSys_StartProc=GetSubHash("_DebugSys_StartProc",1))
-        pSub_DebugSys_StartProc->bUse=1;
+        pSub_DebugSys_StartProc->Using();
 
     if(pSub_DebugSys_EndProc=GetSubHash("_DebugSys_EndProc",1))
-        pSub_DebugSys_EndProc->bUse=1;
+        pSub_DebugSys_EndProc->Using();
 
     if(pSub_DebugSys_SaveContext=GetSubHash("_DebugSys_SaveContext",1))
-        pSub_DebugSys_SaveContext->bUse=1;
+        pSub_DebugSys_SaveContext->Using();
 
     if(pSub_System_GetEip=GetSubHash("_System_GetEip",1)){
-        pSub_System_GetEip->bUse=1;
-        pSub_System_GetEip->bSystem=1;
+        pSub_System_GetEip->Using();
+        pSub_System_GetEip->ThisIsSystemProc();
     }
 
     if(pSub_System_InitDllGlobalVariables=GetSubHash("_System_InitDllGlobalVariables",1)){
-        pSub_System_InitDllGlobalVariables->bUse=1;
-        pSub_System_InitDllGlobalVariables->bSystem=1;
+        pSub_System_InitDllGlobalVariables->Using();
+        pSub_System_InitDllGlobalVariables->ThisIsSystemProc();
     }
 
     if(pSub_System_InitStaticLocalVariables=GetSubHash("_System_InitStaticLocalVariables",1)){
-        pSub_System_InitStaticLocalVariables->bUse=1;
-        pSub_System_InitStaticLocalVariables->bSystem=1;
+        pSub_System_InitStaticLocalVariables->Using();
+        pSub_System_InitStaticLocalVariables->ThisIsSystemProc();
     }
 
     if(pSub_System_Call_Destructor_of_GlobalObject=GetSubHash("_System_Call_Destructor_of_GlobalObject",1)){
-        pSub_System_Call_Destructor_of_GlobalObject->bUse=1;
-        pSub_System_Call_Destructor_of_GlobalObject->bSystem=1;
+        pSub_System_Call_Destructor_of_GlobalObject->Using();
+        pSub_System_Call_Destructor_of_GlobalObject->ThisIsSystemProc();
     }
 
     if(pSub_System_GetSp=GetSubHash("_System_GetSp",1)){
-        pSub_System_GetSp->bUse=1;
-        pSub_System_GetSp->bSystem=1;
+        pSub_System_GetSp->Using();
+        pSub_System_GetSp->ThisIsSystemProc();
     }
 
     if(pSub_pow=GetSubHash("pow",1))
-        pSub_pow->bUse=1;
+        pSub_pow->Using();
 
     if(pSub_calloc=GetSubHash("calloc",1))
-        pSub_calloc->bUse=1;
+        pSub_calloc->Using();
 
     if(pSub_realloc=GetSubHash("realloc",1))
-        pSub_realloc->bUse=1;
+        pSub_realloc->Using();
 
     if(pSub_free=GetSubHash("free",1))
-        pSub_free->bUse=1;
+        pSub_free->Using();
 
     if( pSub_System_GC_malloc_ForObject = GetSubHash( "_System_GC_malloc_ForObject",1 ) )
-        pSub_System_GC_malloc_ForObject->bUse = 1;
+        pSub_System_GC_malloc_ForObject->Using();
 
     if( pSub_System_GC_malloc_ForObjectPtr = GetSubHash( "_System_GC_malloc_ForObjectPtr",1 ) )
-        pSub_System_GC_malloc_ForObjectPtr->bUse = 1;
+        pSub_System_GC_malloc_ForObjectPtr->Using();
 
     if( pSub_System_GC_free_for_SweepingDelete = GetSubHash( "_System_GC_free_for_SweepingDelete",1 ) )
-        pSub_System_GC_free_for_SweepingDelete->bUse = 1;
+        pSub_System_GC_free_for_SweepingDelete->Using();
 
 
@@ -271 +271 @@
 
     cp=-1;
-    extern BOOL bCompilingGlobal;
-    bCompilingGlobal=1;
+    UserProc::CompileStartForGlobalArea();
 
     if(!bDll){
@@ -352 +351 @@
 
         //call _System_Call_Destructor_of_GlobalObject
-        extern SubInfo *pSub_System_Call_Destructor_of_GlobalObject;
+        extern UserProc *pSub_System_Call_Destructor_of_GlobalObject;
         op_call(pSub_System_Call_Destructor_of_GlobalObject);
 
@@ -405 +404 @@
     /////////////////////
 
-    bCompilingGlobal=0;
-
     //プロシージャをコンパイル開始
     cp=0;
@@ -429 +426 @@
     ////////////////////////////////
     for(i=0;i<MAX_HASH;i++){
-        extern DECLAREINFO **ppDeclareHash;
-        DECLAREINFO *pdi;
-        pdi=ppDeclareHash[i];
-        while(pdi){
-            if(pdi->bUse==0){
-                pdi=pdi->pNextData;
+        extern DllProc **ppDeclareHash;
+        const DllProc *pDllProc = ppDeclareHash[i];
+        while(pDllProc){
+            if( !pDllProc->IsUsing() ){
+                pDllProc=pDllProc->pNextData;
                 continue;
             }
@@ -440 +436 @@
             //エラーチェック
             HINSTANCE hLib;
-            hLib=LoadLibrary(pdi->file);
+            hLib=LoadLibrary( pDllProc->GetDllFileName().c_str() );
             if(!hLib){
                 extern char OutputFileName[MAX_PATH];
@@ -446 +442 @@
                 _splitpath(OutputFileName,temp2,temp3,NULL,NULL);
                 lstrcat(temp2,temp3);
-                lstrcpy(temp3,pdi->file);
+                lstrcpy(temp3,pDllProc->GetDllFileName().c_str());
                 GetFullPath(temp3,temp2);
                 hLib=LoadLibrary(temp3);
 
                 if(!hLib){
-                    SetError(-106,pdi->file,pdi->pos);
+                    SetError(-106,pDllProc->GetDllFileName().c_str(),pDllProc->GetCodePos());
                 }
             }
 
             if(hLib){
-                if(!GetProcAddress(hLib,pdi->alias)){
+                if(!GetProcAddress(hLib,pDllProc->GetAlias().c_str())){
                     FreeLibrary(hLib);
-                    SetError(-107,pdi->alias,pdi->pos);
+                    SetError(-107,pDllProc->GetAlias(),pDllProc->GetCodePos());
                 }
                 FreeLibrary(hLib);
             }
 
-            pdi=pdi->pNextData;
+            pDllProc=pDllProc->pNextData;
         }
     }
@@ -500 +496 @@
         ExportNamesLength=lstrlen(lpExportNames)+1;
 
-        extern SubInfo **ppSubHash;
-        SubInfo *psi,*psi2;
+        extern UserProc **ppSubHash;
+        UserProc *pUserProc,*psi2;
         while(1){
             //辞書順にサーチ
             temporary[0]=0;
             for(i=0,psi2=0;i<MAX_HASH;i++){
-                psi=ppSubHash[i];
-                while(psi){
-                    if(psi->bExport){
+                pUserProc=ppSubHash[i];
+                while(pUserProc){
+                    if(pUserProc->IsExport()){
                         if(temporary[0]=='\0'){
-                            lstrcpy(temporary,psi->name);
-                            psi2=psi;
+                            lstrcpy(temporary,pUserProc->GetName().c_str());
+                            psi2=pUserProc;
                         }
                         else{
                             i3=lstrlen(temporary);
-                            i4=lstrlen(psi->name);
+                            i4=(int)pUserProc->GetName().size();
                             if(i3<i4) i3=i4;
-                            if(memcmp(temporary,psi->name,i3)>0){
-                                lstrcpy(temporary,psi->name);
-                                psi2=psi;
+                            if(memcmp(temporary,pUserProc->GetName().c_str(),i3)>0){
+                                lstrcpy(temporary,pUserProc->GetName().c_str());
+                                psi2=pUserProc;
                             }
                         }
                     }
-                    psi=psi->pNextData;
+                    pUserProc=pUserProc->pNextData;
                 }
             }
             if(psi2==0) break;
-            psi=psi2;
-
-            psi->bExport=0;
-
-            if(lstrcmpi(psi->name,"DllMain")==0)
-                DllMain_EntryPoint=psi->CompileAddress;
+            pUserProc=psi2;
+
+            pUserProc->ExportOff();
+
+            if( pUserProc->GetName() == "DllMain" ){
+                DllMain_EntryPoint=pUserProc->beginOpAddress;
+            }
 
             lpdwExportAddressTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportAddressTable,(ExportNum+1)*sizeof(DWORD));
-            lpdwExportAddressTable[ExportNum]=psi->CompileAddress;
+            lpdwExportAddressTable[ExportNum]=pUserProc->beginOpAddress;
 
             lpdwExportNamePointerTable=(DWORD *)HeapReAlloc(hHeap,0,lpdwExportNamePointerTable,(ExportNum+1)*sizeof(DWORD));
@@ -543 +540 @@
             lpwExportOrdinalTable[ExportNum]=ExportNum;
 
-            lstrcpy(lpExportNames+ExportNamesLength,psi->name);
+            lstrcpy(lpExportNames+ExportNamesLength,pUserProc->GetName().c_str());
             ExportNamesLength+=lstrlen(lpExportNames+ExportNamesLength)+1;
 
@@ -576 +573 @@
     //インポートDLL情報
     /////////////////////
-    extern DECLAREINFO **ppDeclareHash;
-    DECLAREINFO *pdi;
+    extern DllProc **ppDeclareHash;
+    DllProc *pDllProc;
     char **ppDllNames;
     int ImportDllNum;
@@ -613 +610 @@
     ImportDllNum=0;
     for(i=0;i<MAX_HASH;i++){
-        pdi=ppDeclareHash[i];
-        while(pdi){
-            if(pdi->dwType==DECLARE_STATIC||
-                pdi->bUse==0){
-                pdi=pdi->pNextData;
+        const DllProc *pDllProc=ppDeclareHash[i];
+        while(pDllProc){
+            if( !pDllProc->IsUsing() ){
+                pDllProc=pDllProc->pNextData;
                 continue;
             }
 
-            if(lstrlen(pdi->file)>16){
+            if( pDllProc->GetDllFileName().size() > 16 ){
                 SetError(7,NULL,cp);
                 break;
             }
             for(i2=0;i2<ImportDllNum;i2++){
-                if(lstrcmp(ppDllNames[i2],pdi->file)==0) break;
+                if( pDllProc->GetDllFileName() == ppDllNames[i2] ){
+                    break;
+                }
             }
             if(i2==ImportDllNum){
                 ppDllNames=(char **)HeapReAlloc(hHeap,0,ppDllNames,(ImportDllNum+1)*sizeof(char **));
                 ppDllNames[ImportDllNum]=(char *)HeapAlloc(hHeap,HEAP_ZERO_MEMORY,16);
-                lstrcpy(ppDllNames[ImportDllNum],pdi->file);
+                lstrcpy(ppDllNames[ImportDllNum],pDllProc->GetDllFileName().c_str());
                 ImportDllNum++;
             }
 
-            pdi=pdi->pNextData;
+            pDllProc=pDllProc->pNextData;
         }
     }
@@ -651 +649 @@
         pImportDescriptor[i].Name=i*0x10;   //※すぐ下で再計算
         for(i2=0;i2<MAX_HASH;i2++){
-            pdi=ppDeclareHash[i2];
-            while(pdi){
-                if(pdi->dwType==DECLARE_STATIC||
-                    pdi->bUse==0){
-                    pdi=pdi->pNextData;
+            pDllProc=ppDeclareHash[i2];
+            while(pDllProc){
+                if( !pDllProc->IsUsing() ){
+                    pDllProc=pDllProc->pNextData;
                     continue;
                 }
 
-                if(lstrcmp(ppDllNames[i],pdi->file)==0){
+                if( pDllProc->GetDllFileName() == ppDllNames[i] ){
                     //ルックアップデータのサイズを追加
                     LookupSize+=sizeof(_int64);
                 }
 
-                pdi=pdi->pNextData;
+                pDllProc=pDllProc->pNextData;
             }
         }
@@ -691 +688 @@
     for(i=0,i5=0;i<ImportDllNum;i++){
         for(i2=0;i2<MAX_HASH;i2++){
-            pdi=ppDeclareHash[i2];
-            while(pdi){
-                if(pdi->dwType==DECLARE_STATIC||
-                    pdi->bUse==0){
-                    pdi=pdi->pNextData;
+            pDllProc=ppDeclareHash[i2];
+            while(pDllProc){
+                if( !pDllProc->IsUsing() ){
+                    pDllProc=pDllProc->pNextData;
                     continue;
                 }
 
-                if(lstrcmp(ppDllNames[i],pdi->file)==0){
+                if( pDllProc->GetDllFileName() == ppDllNames[i] ){
                     //ルックアップの位置をセット（後にインポート アドレス テーブルにセットしなおされる）
-                    pdi->LookupAddress=i5*sizeof(_int64);
+                    pDllProc->SetLookupAddress( i5*sizeof(_int64) );
 
                     //ルックアップ テーブルの値をセット
@@ -714 +710 @@
                     pHintTable[HintSize++]=0;
                     pHintTable[HintSize++]=0;
-                    lstrcpy(pHintTable+HintSize,pdi->alias);
-                    i4=lstrlen(pdi->alias);
+                    lstrcpy(pHintTable+HintSize,pDllProc->GetAlias().c_str());
+                    i4=(int)pDllProc->GetAlias().size();
                     HintSize+=i4+1;
                     if(i4%2==0) pHintTable[HintSize++]=0;
@@ -725 +721 @@
                 }
 
-                pdi=pdi->pNextData;
+                pDllProc=pDllProc->pNextData;
             }
         }
@@ -742 +738 @@
     //グローバル変数情報を扱う構造体も初期バッファの有無による配置を行う
     //（デバッグ情報で利用される）
-    extern int MaxGlobalVarNum;
-    extern VARIABLE *GlobalVar;
     extern int AllInitGlobalVarSize;
-    for(i=0;i<MaxGlobalVarNum;i++){
-        if(GlobalVar[i].offset&0x80000000){
-            GlobalVar[i].offset=(GlobalVar[i].offset&0x7FFFFFFF)+AllInitGlobalVarSize;
+    foreach( Variable *pVar, globalVars ){
+        if(pVar->offset&0x80000000){
+            pVar->offset=(pVar->offset&0x7FFFFFFF)+AllInitGlobalVarSize;
         }
     }
@@ -997 +991 @@
 
         for(i2=0;i2<MAX_HASH;i2++){
-            pdi=ppDeclareHash[i2];
-            while(pdi){
-                if(pdi->bUse==0){
-                    pdi=pdi->pNextData;
+            const DllProc *pDllProc=ppDeclareHash[i2];
+            while(pDllProc){
+                if( !pDllProc->IsUsing() ){
+                    pDllProc=pDllProc->pNextData;
                     continue;
                 }
 
-                if(lstrcmp(ppDllNames[i],pdi->file)==0){
+                if( pDllProc->GetDllFileName() == ppDllNames[i] ){
                     //ルックアップ テーブル
                     pLookupTable[i5++]+=MemPos_ImportSection;
                 }
 
-                pdi=pdi->pNextData;
+                pDllProc=pDllProc->pNextData;
             }
         }
@@ -1033 +1027 @@
     // ※x86はRVAからのオフセット。x64はRPI（実行中アドレス）からのオフセット
     for(i=0;i<pobj_ImportAddrSchedule->num;i++){
-        DECLAREINFO *pdi;
-        pdi=pobj_ImportAddrSchedule->ppdi[i];
+        DllProc *pDllProc;
+        pDllProc=pobj_ImportAddrSchedule->ppdi[i];
         *((long *)(OpBuffer+pobj_ImportAddrSchedule->pObpValues[i]))=
             MemPos_ImportSection+
-            pdi->LookupAddress
+            pDllProc->GetLookupAddress()
             -(MemPos_CodeSection+pobj_ImportAddrSchedule->pObpValues[i]+sizeof(long));
     }
@@ -1046 +1040 @@
     // プロシージャポインタスケジュール
     for(i=0;i<pobj_SubAddrSchedule->num;i++){
-        if(pobj_SubAddrSchedule->ppsi[i]->CompileAddress==0
-            &&pobj_SubAddrSchedule->ppsi[i]->EndOpAddr==0){
+        if(pobj_SubAddrSchedule->ppsi[i]->beginOpAddress==0
+            &&pobj_SubAddrSchedule->ppsi[i]->endOpAddress==0){
             SetError(300,NULL,-1);
         }
@@ -1053 +1047 @@
         if(pobj_SubAddrSchedule->pbCall[i]){
             *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))=
-                pobj_SubAddrSchedule->ppsi[i]->CompileAddress-(pobj_SubAddrSchedule->pObpValues[i]+sizeof(long));
+                pobj_SubAddrSchedule->ppsi[i]->beginOpAddress-(pobj_SubAddrSchedule->pObpValues[i]+sizeof(long));
         }
         else{
             *((long *)(OpBuffer+pobj_SubAddrSchedule->pObpValues[i]))=
-                pobj_SubAddrSchedule->ppsi[i]->CompileAddress+ImageBase+MemPos_CodeSection;
+                pobj_SubAddrSchedule->ppsi[i]->beginOpAddress+ImageBase+MemPos_CodeSection;
         }
     }
@@ -1098 +1092 @@
     //グローバル変数情報を扱う構造体も初期バッファの有無による配置を行う
     //（デバッグ情報で利用される）
-    extern int MaxGlobalVarNum;
-    extern VARIABLE *GlobalVar;
-    for(i=0;i<MaxGlobalVarNum;i++){
-        if(GlobalVar[i].offset&0x80000000){
-            GlobalVar[i].offset=(GlobalVar[i].offset&0x7FFFFFFF)+AllInitGlobalVarSize;
+    foreach( Variable *pVar, globalVars ){
+        if(pVar->offset&0x80000000){
+            pVar->offset=(pVar->offset&0x7FFFFFFF)+AllInitGlobalVarSize;
         }
     }

BasicCompiler64/NumOpe.cpp

@@ -19 +19 @@
 
         extern CClass *pobj_StringClass;
-        TYPEINFO baseTypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
-        Operator_New( *pobj_StringClass, "", parameter, baseTypeInfo );
+        Operator_New( *pobj_StringClass, "", parameter, Type( DEF_OBJECT, *pobj_StringClass ) );
 
         free( parameter );
@@ -70 +69 @@
 }
 
-int NumOpe(int *pReg,const char *Command,int BaseType,LONG_PTR lpBaseIndex,LONG_PTR *plpIndex,BOOL *pbUseHeap){
-    extern HANDLE hHeap;
+void ExtendRegToBigType( int reg, int bigBasicType, int baseBasicType ){
+    switch( Type::GetBasicSize( bigBasicType ) ){
+        case sizeof(_int64):
+            ExtendTypeTo64(baseBasicType,reg);
+            break;
+        case sizeof(long):
+            ExtendTypeTo32(baseBasicType,reg);
+            break;
+        case sizeof(short):
+            ExtendTypeTo16(baseBasicType,reg);
+            break;
+    }
+}
+
+bool NumOpe( int *pReg,
+            const char *expression,
+            const Type &baseType,
+            Type &resultType,
+            BOOL *pbUseHeap ){
+
     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演算子（オブジェクト生成）
-        TYPEINFO baseTypeInfo = { BaseType, lpBaseIndex };
-        int resultType = Operator_New(Command+2,plpIndex, baseTypeInfo );
+
+        if( !Operator_New( expression+2, baseType, resultType ) ){
+            return false;
+        }
 
         //mov reg,rax
         op_mov_RR( *pReg, REG_RAX );
 
-        return resultType;
+        return true;
     }
 
@@ -100 +119 @@
     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]);
@@ -156 +175 @@
     double dbl;
     int sp;
-    int type[255];
+    int type_stack[255];
     LONG_PTR index_stack[255];
     BOOL bUseHeap[255];
@@ -167 +186 @@
 
         if(idCalc){
-            if(type[sp-2]==DEF_OBJECT){
+            if(type_stack[sp-2]==DEF_OBJECT){
                 //オーバーロードされたオペレータを呼び出す
-                TYPEINFO BaseTypeInfo={BaseType,lpBaseIndex};
-                i2=CallOperatorProc(idCalc,&BaseTypeInfo,type,index_stack,bUseHeap,sp);
+                i2=CallOperatorProc(idCalc,baseType,type_stack,index_stack,bUseHeap,sp);
                 if(i2==0){
                     if(idCalc==CALC_EQUAL) lstrcpy(temp2,"==");
@@ -183 +201 @@
             }
 
-            if(!CheckCalcType(idCalc,type,sp)) goto error;
+            if(!CheckCalcType(idCalc,type_stack,sp)) goto error;
         }
 
@@ -209 +227 @@
 StrLiteral:
                     
-                    if(BaseType==DEF_OBJECT){
-                        CClass *pobj_Class;
-                        pobj_Class=(CClass *)lpBaseIndex;
-                        TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
-                        if(IsStringObjectType(BaseTypeInfo)){
+                    if( baseType.IsObject() ){
+                        if( baseType.IsStringObject() ){
                             //要求タイプがStringのとき
 
@@ -220 +235 @@
 
                             extern CClass *pobj_StringClass;
-                            type[sp]=DEF_OBJECT;
+                            type_stack[sp]=DEF_OBJECT;
                             index_stack[sp]=(LONG_PTR)pobj_StringClass;
                             bLiteralCalculation=0;
@@ -232 +247 @@
                     }
 
-                    type[sp]=typeOfPtrChar;
+                    type_stack[sp]=typeOfPtrChar;
                     bLiteralCalculation=0;
 
@@ -277 +292 @@
                         int idProc;
                         void *pInfo;
-                        idProc=GetProc(temporary,&pInfo);
-
+                        idProc=GetProc(temporary,(void **)&pInfo);
+
+                        Type resultType;
                         if(idProc){
                             //閉じカッコ")"に続く文字がNULLでないとき
@@ -302 +318 @@
                                 ////////////////
 
-                                i2=CallProc(idProc,pInfo,temporary,temp2,&index_stack[sp]);
-                                if(i2==-1){
+                                CallProc(idProc,pInfo,temporary,temp2,resultType);
+                                if(resultType.IsNull()){
                                     //戻り値が存在しないとき
                                     for(i2=2;;i2++){
@@ -325 +341 @@
 
                                 //大きな型への暗黙の変換
-                                type[sp]=AutoBigCast(BaseType,i2);
+                                type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
+                                index_stack[sp] = resultType.GetIndex();
                                 bLiteralCalculation=0;
 
-                                SetUseRegFromRax(i2,UseReg,XmmReg);
-
-                                if(IsRealNumberType(i2)) bXmm=1;
+                                if( type_stack[sp] != resultType.GetBasicType() ){
+                                    // 大きな型へ変換された場合
+                                    // ※レジスタの値をキャストする
+                                    ExtendRegToBigType( REG_RAX, type_stack[sp], resultType.GetBasicType() );
+                                }
+
+                                SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+
+                                if(resultType.IsReal()) bXmm=1;
                                 else bXmm=0;
 
@@ -342 +365 @@
                             else pobj_reg->LockReg();
 
-                            if(i2==DEF_STRUCT){
+                            if(resultType.IsStruct()){
                                 //構造体が戻ったときはヒープ領域にインスタンスが格納されている
                                 //※後にfreeする必要あり
@@ -360 +383 @@
 
                             //マクロ関数の場合
-                            i2=NumOpe(&UseReg,temp3,0,0,&index_stack[sp]);
-
-                            if(!IS_LITERAL(index_stack[sp])){
+                            NumOpe(&UseReg,temp3,Type(),resultType);
+
+                            if(!IS_LITERAL(resultType.GetIndex())){
                                 //リテラル値ではなかったとき
                                 bLiteralCalculation=0;
                             }
 
-                            type[sp]=i2;
-
-                            if(IsRealNumberType(i2)) pobj_reg->LockXmmReg();
+                            type_stack[sp] = resultType.GetBasicType();
+                            index_stack[sp] = resultType.GetIndex();
+
+                            if(resultType.IsReal()) pobj_reg->LockXmmReg();
                             else pobj_reg->LockReg();
 
@@ -381 +405 @@
                     //インデクサ（getアクセサ）
                     char variable[VN_SIZE],array_element[VN_SIZE];
-                    CClass *pobj_c;
                     GetArrayElement(term,variable,array_element);
                     if(array_element[0]){
-                        i2=GetVarType(variable,(LONG_PTR *)&pobj_c,0);
-                        if(i2==DEF_OBJECT){
-                            TYPEINFO RetTypeInfo;
-                            CallIndexerGetterProc(UseReg,pobj_c,variable,array_element,RetTypeInfo);
-                            type[sp]=RetTypeInfo.type;
-                            index_stack[sp]=RetTypeInfo.u.lpIndex;
+                        Type resultType;
+                        GetVarType(variable,resultType,0);
+                        if( resultType.IsObject() ){
+                            CallIndexerGetterProc(UseReg,&resultType.GetClass(),variable,array_element,resultType);
+                            type_stack[sp]=resultType.GetBasicType();
+                            index_stack[sp]=resultType.GetIndex();
                             bLiteralCalculation=0;
 
-                            if(IsRealNumberType(RetTypeInfo.type)) pobj_reg->LockXmmReg();
+                            if(resultType.IsReal()) pobj_reg->LockXmmReg();
                             else pobj_reg->LockReg();
                             sp++;
@@ -402 +425 @@
                     // Nothing
                     if( lstrcmp( term, "Nothing" ) == 0 ){
-                        type[sp] = DEF_OBJECT;
-                        if( BaseType == DEF_OBJECT ){
-                            index_stack[sp] = lpBaseIndex;
+                        type_stack[sp] = DEF_OBJECT;
+                        if( baseType.IsObject() ){
+                            index_stack[sp] = baseType.GetIndex();
                         }
                         else{
@@ -427 +450 @@
 
                     RELATIVE_VAR RelativeVar;
+                    Type varType;
                     if(GetVarOffset(
                         false,  //エラー表示あり
                         false,  //読み込み専用
                         term,
-                        &i2,&RelativeVar,&index_stack[sp])){
+                        &RelativeVar,varType)){
                         //////////
                         // 変数
@@ -437 +461 @@
 
                         //大きな型への暗黙の変換
-                        type[sp]=AutoBigCast(BaseType,i2);
+                        type_stack[sp]=AutoBigCast(baseType.GetBasicType(),varType.GetBasicType());
+                        index_stack[sp] = varType.GetIndex();
                         bLiteralCalculation=0;
 
-                        if(type[sp]!=i2){
-                            //大きな型へ変換された場合（レジスタを0に初期化する）
-
-                            //xor reg,reg
-                            op_zero_reg(UseReg);
-                        }
-
-                        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);
 
                             SetVarPtrToReg(UseReg,&RelativeVar);
                         }
-                        else if(IsRealNumberType(i2)){
+                        else if(varType.IsReal()){
                             //実数型
                             bXmm=1;
 
-                            if(i2==DEF_DOUBLE)
+                            if( varType.IsDouble() )
                                 SetXmmReg_DoubleVariable(&RelativeVar,XmmReg);
-                            if(i2==DEF_SINGLE)
+                            if( varType.IsSingle() )
                                 SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
                         }
-                        else if(IsWholeNumberType(i2) || i2==DEF_OBJECT){
+                        else if( varType.IsWhole() || varType.IsObject()){
                             //整数型
-                            SetReg_WholeVariable(i2,&RelativeVar,UseReg);
-                        }
-                        else if(i2==DEF_STRUCT){
+                            SetReg_WholeVariable(varType.GetBasicType(),&RelativeVar,UseReg);
+                        }
+                        else if( varType.IsStruct() ){
                             //構造体ポインタをUseRegへ格納（構造体は値型）
                             SetVarPtrToReg(UseReg,&RelativeVar);
                         }
                         else SetError(11,term,cp);
+
+                        if( type_stack[sp] != varType.GetBasicType() ){
+                            // 大きな型へ変換された場合
+                            // ※レジスタの値をキャストする
+                            ExtendRegToBigType( UseReg, type_stack[sp], varType.GetBasicType() );
+                        }
 
                         if(bXmm==0&&UseReg==REG_R14){
@@ -477 +501 @@
                         }
                         if(bXmm&&XmmReg==REG_XMM4){
-                            if(i2==DEF_DOUBLE){
+                            if(varType.IsDouble()){
                                 //movsd qword ptr[rsp+offset],xmm4  ※スタックフレームを利用
                                 pobj_sf->push(REG_XMM4,sizeof(double));
                             }
-                            if(i2==DEF_SINGLE){
+                            if(varType.IsSingle()){
                                 //movss dword ptr[rsp+offset],xmm4  ※スタックフレームを利用
                                 pobj_sf->push(REG_XMM4,sizeof(float));
@@ -500 +524 @@
                     i3 = CDBConst::obj.GetType(term);
                     if(i3){
-                        type[sp] = i3;
+                        type_stack[sp] = i3;
                         if(IsRealNumberType(i3)){
                             //実数
@@ -536 +560 @@
                     i3=GetTypeFixed(term,&lp);
                     if(i3!=-1){
-                        type[sp]=i3|FLAG_CAST;
+                        type_stack[sp]=i3|FLAG_CAST;
                         index_stack[sp]=lp;
                         sp++;
@@ -559 +583 @@
                         //////////////////////////////////////////////////////
 
-                            TYPEINFO RetTypeInfo;
-                            CallPropertyMethod(term,NULL,&RetTypeInfo);
+                            Type resultType;
+                            CallPropertyMethod(term,NULL,resultType);
 
                             //大きな型への暗黙の変換
-                            type[sp]=AutoBigCast(BaseType,RetTypeInfo.type);
-
-                            index_stack[sp]=RetTypeInfo.u.lpIndex;
+                            type_stack[sp]=AutoBigCast(baseType.GetBasicType(),resultType.GetBasicType());
+                            index_stack[sp]=resultType.GetIndex();
                             bLiteralCalculation=0;
 
-                            SetUseRegFromRax(RetTypeInfo.type,UseReg,XmmReg);
-
-                            if(IsRealNumberType(type[sp])) bXmm=1;
+                            if( type_stack[sp] != resultType.GetBasicType() ){
+                                // 大きな型へ変換された場合
+                                // ※レジスタの値をキャストする
+                                ExtendRegToBigType( REG_RAX, type_stack[sp], resultType.GetBasicType() );
+                            }
+
+                            SetUseRegFromRax(resultType.GetBasicType(),UseReg,XmmReg);
+
+                            if(IsRealNumberType(type_stack[sp])) bXmm=1;
                             else bXmm=0;
 
@@ -578 +607 @@
                         }////////////////////////////////////////////
 
-                        if(type[sp]==DEF_STRUCT){
+                        if(type_stack[sp]==DEF_STRUCT){
                             //構造体が戻ったときはヒープ領域にインスタンスが格納されている
                             //※後にfreeする必要あり
@@ -595 +624 @@
                     bError=1;
                     SetError(3,term,cp);
-                    type[sp]=DEF_DOUBLE;
+                    type_stack[sp]=DEF_DOUBLE;
                 }
                 else{
                     //リテラル値
-                    type[sp]=GetLiteralValue(term,&i64data,BaseType);
+                    type_stack[sp]=GetLiteralValue(term,&i64data,baseType.GetBasicType());
 Literal:
-                    if(type[sp]==DEF_DOUBLE){
+                    if(type_stack[sp]==DEF_DOUBLE){
                         //64ビット浮動小数型
                         bXmm=1;
@@ -627 +656 @@
                         }
                     }
-                    else if(type[sp]==DEF_SINGLE){
+                    else if(type_stack[sp]==DEF_SINGLE){
                         //32ビット浮動小数型
                         bXmm=1;
@@ -680 +709 @@
             case CALC_OR:
             case CALC_AND:
-                if(!CalcTwoTerm_Logical(idCalc,type,index_stack,&sp)) goto error;
+                if(!CalcTwoTerm_Logical(idCalc,type_stack,index_stack,&sp)) goto error;
                 break;
             case CALC_NOT:
                 //value[sp-1]=Not value[sp-1]
                 //NOT演算子
-                if(!Calc_Not(type,sp)) goto error;
+                if(!Calc_Not(type_stack,sp)) goto error;
                 break;
 
@@ -695 +724 @@
             case CALC_NOTEQUAL: //value[sp-2] <> value[sp-1]
             case CALC_EQUAL:    //value[sp-2] =  value[sp-1]                
-                if(!CalcTwoTerm_Relational(idCalc,type,index_stack,&sp)) goto error;
+                if(!CalcTwoTerm_Relational(idCalc,type_stack,index_stack,&sp)) goto error;
                 break;
 
@@ -701 +730 @@
             case CALC_SHL:  //value[sp-2] << value[sp-1]
             case CALC_SHR:  //value[sp-2] >> value[sp-1]
-                if(!Calc_Shift(idCalc,type,&sp)) goto error;
+                if(!Calc_Shift(idCalc,type_stack,&sp)) goto error;
                 break;
 
@@ -708 +737 @@
             case CALC_SUBTRACTION:
             case CALC_PRODUCT:
-                if(!CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp)) goto error;
+                if(!CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp)) goto error;
                 break;
             case CALC_MOD:
                 //value[sp-2]%=value[sp-1]
                 //剰余演算
-                if(!Calc_Mod(type,index_stack,&sp)) goto error;
+                if(!Calc_Mod(type_stack,index_stack,&sp)) goto error;
                 break;
             case CALC_QUOTIENT:
                 //value[sp-2]/=value[sp-1];
                 //除算
-                if(!Calc_Divide(type,&sp,BaseType)) goto error;
+                if(!Calc_Divide(type_stack,&sp,baseType.GetBasicType())) goto error;
                 break;
             case CALC_INTQUOTIENT:
                 //value[sp-2]/=value[sp-1]
                 //整数除算
-                if(!Calc_IntDivide(type,index_stack,&sp)) goto error;
+                if(!Calc_IntDivide(type_stack,index_stack,&sp)) goto error;
                 break;
             case CALC_MINUSMARK:
                 //value[sp-1]=-value[sp-1]
                 //符号反転
-                if(!Calc_MinusMark(type,sp)) goto error;
+                if(!Calc_MinusMark(type_stack,sp)) goto error;
                 break;
             case CALC_POWER:
                 //べき乗演算（浮動小数点演算のみ）
-                if(!Calc_Power(type,&sp)) goto error;
+                if(!Calc_Power(type_stack,&sp)) goto error;
                 break;
             case CALC_AS:
                 //キャスト
-                if(!Calc_Cast(type,index_stack,&sp)) goto error;
+                if(!Calc_Cast(type_stack,index_stack,&sp)) goto error;
                 break;
             case CALC_BYVAL:
                 //ポインタ型→参照型
-                if( PTR_LEVEL( type[sp-1] ) <= 0 ){
+                if( PTR_LEVEL( type_stack[sp-1] ) <= 0 ){
                     //ポインタ型ではないとき
                     SetError( 3, NULL, cp );
@@ -746 +775 @@
                 }
 
-                type[sp-1] = PTR_LEVEL_DOWN( type[sp-1] );
+                type_stack[sp-1] = PTR_LEVEL_DOWN( type_stack[sp-1] );
 
                 break;
@@ -765 +794 @@
     if(bLiteralCalculation){
         //右辺値が数値の定数式の場合
-        LONG_PTR lpClassIndex;
-        i2=StaticCalculation(true, Command,BaseType,&i64data,&lpClassIndex);
+        Type resultType;
+        StaticCalculation(true, expression,baseType.GetBasicType(),&i64data,resultType);
 
         obp=BeforeObp;
@@ -775 +804 @@
         *pobj_reg=objReg_Backup;
 
-        if(IsRealNumberType(i2)){
-            if(IsRealNumberType(BaseType)) i2=BaseType;
+        if(resultType.IsReal()){
+            if(baseType.IsReal()) resultType=baseType;
 
             XmmReg=pobj_reg->LockXmmReg();
 
-            if(i2==DEF_DOUBLE){
+            if(resultType.IsDouble()){
                 i3 = dataTable.Add( i64data );
 
@@ -793 +822 @@
                 obp+=sizeof(long);
             }
-            if(i2==DEF_SINGLE){
+            if(resultType.IsSingle()){
                 memcpy(&dbl,&i64data,sizeof(_int64));
 
@@ -815 +844 @@
         }
         else{
-            if(!Is64Type(i2)){
+            if(!resultType.Is64()){
                 //整数（符号有り/無し）
 
                 i3=(long)i64data;
 
-                if(GetTypeSize(i2,-1)==sizeof(char)) i3=i3&0x000000FF;
-                if(GetTypeSize(i2,-1)==sizeof(short)) i3=i3&0x0000FFFF;
+                if(resultType.GetBasicSize()==sizeof(char)) i3=i3&0x000000FF;
+                if(resultType.GetBasicSize()==sizeof(short)) i3=i3&0x0000FFFF;
 
                 i64data=(_int64)i3;
@@ -832 +861 @@
         }
 
-        type[0]=i2;
-        index_stack[0]=lpClassIndex;
+        type_stack[0]=resultType.GetBasicType();
+        index_stack[0]=resultType.GetIndex();
     }
     else{
@@ -840 +869 @@
     }
 
-    if(plpIndex) *plpIndex=index_stack[0];
     if(pbUseHeap) *pbUseHeap=bUseHeap[0];
 
-    if(IsRealNumberType(type[0]))
+    if(IsRealNumberType(type_stack[0]))
         *pReg=pobj_reg->UnlockXmmReg();
     else
@@ -858 +886 @@
     }
 
-    int RetType;
-    RetType=type[0];
+    resultType.SetType( type_stack[0], index_stack[0] );
+
+    bool isSuccessful = true;
     goto finish;
 
@@ -878 +907 @@
     }
 
-    RetType=-1;
+    isSuccessful = false;
     goto finish;
 
@@ -893 +922 @@
     delete pobj_BackReloc;
 
-    return RetType;
+    return isSuccessful;
 }

BasicCompiler64/NumOpe_Arithmetic.cpp

@@ -559 +559 @@
 
         //call pow
-        extern SubInfo *pSub_pow;
+        extern UserProc *pSub_pow;
         op_call(pSub_pow);
 

BasicCompiler64/Opcode.h

@@ -251 +251 @@
 
 //NumOpe.cpp
-int NumOpe(int *pReg,const char *Command,int BaseType,LONG_PTR lpBaseIndex,LONG_PTR *plpIndex,BOOL *pbUseHeap=0);
+bool NumOpe( int *pReg,
+           const char *Command,
+           const Type &baseType,
+           Type &resultType,
+           BOOL *pbUseHeap = NULL );
 
 //NumOpe_Arithmetic.cpp
@@ -286 +290 @@
 //Compile_Set_Var.cpp
 BOOL IsUse_r11(RELATIVE_VAR *pRelativeVar);
-void SetStructVariableFromRax(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,RELATIVE_VAR *pRelativeVar,BOOL bUseHeap);
+void SetStructVariableFromRax( const Type &varType, const Type &calcType, RELATIVE_VAR *pRelativeVar,BOOL bUseHeap);
 void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar);
 void SetBooleanVariable(int type,RELATIVE_VAR *pRelative);
@@ -307 +311 @@
 
 //Compile_Object.cpp
-void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter,const TYPEINFO &baseTypeInfo );
-int Operator_New(const char *Parameter,LONG_PTR *plpIndex,const TYPEINFO &baseTypeInfo );
+void Operator_New( const CClass &classObj, const char *objectSizeStr, const char *parameter,const Type &baseTypeInfo );
 void OpcodeDelete(const char *Parameter, bool isSweeping);
 
@@ -314 +317 @@
 void GetWithName(char *buffer);
 void SetThisPtrToReg(int reg);
-BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss=0);
-BOOL SetInitGlobalData(int offset,int type,LONG_PTR lpIndex,int *SubScripts,char *InitBuf);
+bool GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,RELATIVE_VAR *pRelativeVar,Type &resultType,int *pss = NULL);
+bool SetInitGlobalData(int offset,const Type &type,const int *SubScripts,char *InitBuf);
 #define DIMFLAG_INITDEBUGVAR            0x01
 #define DIMFLAG_NONCALL_CONSTRACTOR     0x02
 #define DIMFLAG_STATIC                  0x04
 #define DIMFLAG_CONST                   0x08
-void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags);
-void OpcodeDim(char *Parameter,DWORD dwFlag);
+void dim(bool isRef, char *VarName,int *SubScripts,Type &type,char *InitBuf,char *ConstractParameter,DWORD dwFlags);
 void SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar);
 
@@ -333 +335 @@
 class ParamImpl{
     char *Parms[255];
-    TYPEINFO types[255];
+    vector<Type> types;
     int ParmsNum;
 
-    TYPEINFO ReturnTypeInfo;
+    Type returnType;
 
     //一時オブジェクト管理用
@@ -345 +347 @@
 public:
     ParamImpl(const char *buffer);
-    ParamImpl(const PARAMETER_INFO *pParamInfo, const int ParmNum);
+    ParamImpl(const Parameters &params);
     ~ParamImpl();
-    void SetReturnType(TYPEINFO *pTypeInfo);
+    void SetReturnType( const Type &returnType );
 
 private:
-    BOOL _overload_check( Parameters &params, TYPEINFO *pReturnTypeInfo,int overload_level);
-    SubInfo *OverloadSolutionWithReturnType( const char *name, std::vector<SubInfo *> &subs );
+    bool _overload_check( int level, const Parameters &params, const Type &returnType );
+    UserProc *OverloadSolutionWithReturnType( const char *name, std::vector<UserProc *> &subs );
 public:
-    SubInfo *OverloadSolution( const char *name, std::vector<SubInfo *> &subs );
-
-    BOOL ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
-    void MacroParameterSupport(PARAMETER_INFO *ppi);
-    void SetStructParameter(int reg,CClass *pobj_Class,LPSTR Parameter);
+    UserProc *OverloadSolution( const char *name, std::vector<UserProc *> &subs );
+
+    bool ErrorCheck( const string &procName, const Parameters &params, int SecondParmNum = -1 );
+    void MacroParameterSupport( const Parameters &params );
+    void SetStructParameter( int reg, const Type &baseType, const char *expression );
+    void SetParameter( const string &procName, const Parameters &params, int SecondParmNum = -1 );
 
     //一時オブジェクトパラメータの生成と破棄
-    int NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
+    int NewTempParameters( const string &procName, const Parameters &params, int SecondParmNum = -1 );
     void DeleteTempParameters();
-
-    void SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
 
     void BackupParameter(int pi_num);
@@ -384 +385 @@
 void AddLocalVarAddrSchedule();
 #define PROCFLAG_NEW    1
-int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex);
-void Opcode_CallProc(const char *Parameter,SubInfo *psi,DWORD dwFlags,char *ObjectName,int RefType);
-int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex);
+bool Opcode_CallProcPtr(const char *variable, const char *lpszParms,ProcPointer *pProcPointer);
+bool Opcode_CallProc(const char *Parameter,UserProc *pUserProc,DWORD dwFlags,const char *ObjectName,int RefType);
+bool Opcode_CallDllProc( const char *lpszParms,DllProc *pDllProc);
 
 //Compile_ProcOp.cpp
@@ -394 +395 @@
 int GetFunctionType(int FuncNum);
 int GetFunctionFromName(char *FuncName);
-void Opcode_CallFunc( const char *Parameter, const int FuncNum, TYPEINFO &ReturnTypeInfo );
+bool Opcode_CallFunc( const char *Parameter, const int FuncNum, Type &ReturnTypeInfo, bool isCallOn = true );
 
 //OperatorProc.cpp
-void FreeTempObject(int reg,CClass *pobj_c);
-int CallOperatorProc(int idCalc,TYPEINFO *pBaseTypeInfo,int *type,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp);
-void CallCastOperatorProc(int reg,int &CalcType,LONG_PTR &lpCalcIndex,BOOL bCalcUseHeap,int ToType,LONG_PTR lpToIndex);
-void CallIndexerGetterProc(int reg,CClass *pobj_Class,char *ObjectName,char *Parameter,TYPEINFO &RetTypeInfo);
+void FreeTempObject(int reg,const CClass *pobj_c);
+int CallOperatorProc(int idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp);
+void CallCastOperatorProc(int reg,Type &calcType,BOOL bCalcUseHeap,const Type &toType);
+void CallIndexerGetterProc(int reg,const CClass *pobj_Class,char *ObjectName,char *Parameter,Type &resultType);
 
 //Compile_Statement.cpp
@@ -411 +412 @@
 void OpcodeContinue(void);
 void OpcodeExitSub(void);
-void OpcodeSelect(char *Parameter);
+void OpcodeSelect( const char *Parameter );
 void OpcodeCase(char *Parameter);
 void OpcodeGosub(char *Parameter);
@@ -512 +513 @@
 void op_fld_ptr_esp(int type);
 void op_zero_reg(int reg);
-void op_call( SubInfo *psi );
-void op_call( DECLAREINFO *pdi );
+void op_call( UserProc *pUserProc );
+void op_call( DllProc *pDllProc );

BasicCompiler64/OperatorProc.cpp

@@ -2 +2 @@
 #include "Opcode.h"
 
-void FreeTempObject(int reg,CClass *pobj_c){
+void FreeTempObject(int reg,const CClass *pobj_c){
     if(!IsSafeReg(reg)) SetError(300,NULL,cp);
 
@@ -16 +16 @@
 
         //call DestructorProcAddr
-        op_call( method->psi );
+        op_call( method->pUserProc );
     }
 
@@ -23 +23 @@
 
     //call free
-    extern SubInfo *pSub_free;
+    extern UserProc *pSub_free;
     op_call(pSub_free);
 }
 
-int CallOperatorProc(int idCalc,TYPEINFO *pBaseTypeInfo,int *type,LONG_PTR *index_stack,BOOL *bUseHeap,int &sp){
+int CallOperatorProc(int idCalc, const Type &baseType, int *type_stack,LONG_PTR *index_stack,BOOL *bUseHeap,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 ){
@@ -45 +45 @@
 
     int i;
-    BOOL bReturnTypeIsObject=1;
-    TYPEINFO ReturnType={DEF_OBJECT,subs[0]->u.ReturnIndex};
-    for(i=0;i<subs.size();i++){
-        if(subs[i]->ReturnType!=DEF_OBJECT)
-            bReturnTypeIsObject=0;
-    }
-
-    if(bReturnTypeIsObject==0){
-        if(pBaseTypeInfo){
-            if(pBaseTypeInfo->type==DEF_OBJECT){
-                ReturnType.u.lpIndex=pBaseTypeInfo->u.lpIndex;
-            }
-        }
-    }
-
 
 
@@ -66 +51 @@
     /////////////////////////////////////////////
 
-    PARAMETER_INFO *ppi = (PARAMETER_INFO *)HeapAlloc(hHeap,0,sizeof(PARAMETER_INFO)*3);
-    int iParmNum=0;
-
-    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++;
-    }
-
+    Parameters params;
+
+    if(bTwoTerm){
+        params.push_back( new Parameter( "", Type( type_stack[sp-1], index_stack[sp-1] ) ) );
+    }
 
     //オーバーロードを解決
@@ -84 +61 @@
     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(!pUserProc){
+        if(bTwoTerm){
+            delete params[0];
+        }
         return -1;
     }
     else{
         //オーバーロードされていないが、パラメータ個数が一致しないとき
-        if(iParmNum!=psi->params.size()){
-            HeapDefaultFree(ppi);
+        if(params.size()!=pUserProc->Params().size()){
+            if(bTwoTerm){
+                delete params[0];
+            }
             return -1;
         }
     }
 
-    for(i=0;i<iParmNum;i++){
+    for(i=0;i<(int)params.size();i++){
         CheckDifferentType(
-            psi->params[i]->GetBasicType(),
-            psi->params[i]->GetIndex(),
-            ppi[i].type,
-            ppi[i].u.index,
+            pUserProc->Params()[i]->GetBasicType(),
+            pUserProc->Params()[i]->GetIndex(),
+            params[i]->GetBasicType(),
+            params[i]->GetIndex(),
             "",
             i);
     }
 
-    HeapDefaultFree(ppi);
-
-    if(bTwoTerm){
-        if( psi->realParams[1]->IsStruct() && psi->realParams[1]->IsRef() == false ){
+    if(bTwoTerm){
+        delete params[0];
+    }
+
+    int right_side_size = GetTypeSize(type_stack[sp-1],index_stack[sp-1]);
+
+    if(bTwoTerm){
+        if( pUserProc->RealParams()[1]->IsStruct() &&pUserProc->RealParams()[1]->IsRef() == false ){
             //一時オブジェクトはメソッド内で破棄される
             bUseHeap[sp-1]=0;
@@ -119 +102 @@
     }
 
-    if(psi->ReturnType==DEF_STRUCT){
+
+    if( pUserProc->ReturnType().IsStruct() ){
         //////////////////////////////////////////////////////
         // 戻り値に構造体インスタンスを持つ場合
@@ -131 +115 @@
         //////////////////////////////////////////////////////
 
-            int object_size = psi->u.Return_pobj_c->GetSize();
+            int object_size = pUserProc->ReturnType().GetClass().GetSize();
 
             //mov rcx,object_size
@@ -137 +121 @@
 
             //call calloc
-            extern SubInfo *pSub_calloc;
+            extern UserProc *pSub_calloc;
             op_call(pSub_calloc);
 
@@ -152 +136 @@
     if(bTwoTerm){
         //右の項（実数の場合が未完成）
-        SetOneTermToReg_Whole64Calc(type[sp-1],&reg2);
+        SetOneTermToReg_Whole64Calc(type_stack[sp-1],&reg2);
         pobj_reg->UnlockReg();
-        if( !psi->realParams[1]->IsRef() == false ){
+        if( !pUserProc->RealParams()[1]->IsRef() == false ){
             //一時参照を作成
             pobj_sf->push( reg2 );
@@ -190 +174 @@
 
         if(bTwoTerm){
-            if(psi->ReturnType==DEF_STRUCT){
+            if( pUserProc->ReturnType().IsStruct() ){
                 //mov r8,reg2
                 op_mov_RR(REG_R8,reg2);
@@ -200 +184 @@
         }
 
-        if(psi->ReturnType==DEF_STRUCT){
+        if( pUserProc->ReturnType().IsStruct() ){
             //mov rdx,r13
             op_mov_RR(REG_RDX,REG_R13);
@@ -209 +193 @@
 
         //call operator_proc
-        op_call(psi);
-
-        if(psi->ReturnType!=DEF_NON){
+        op_call(pUserProc);
+
+        if( !pUserProc->ReturnType().IsNull() ){
             //戻り値を一時的に退避
 
@@ -253 +237 @@
 
     if(bTwoTerm){
-        if( !psi->realParams[1]->IsRef() == false ){
+        if( !pUserProc->RealParams()[1]->IsRef() == false ){
             //一時参照を破棄
             pobj_sf->pop();
@@ -259 +243 @@
     }
 
-    if(psi->ReturnType!=DEF_NON){
+    if( !pUserProc->ReturnType().IsNull() ){
         //戻り値をreg1にセット
         reg1=pobj_reg->LockReg();
@@ -268 +252 @@
 
     sp--;
-    type[sp-1]=psi->ReturnType;
-    index_stack[sp-1]=psi->u.ReturnIndex;
-
-    if(psi->ReturnType==DEF_STRUCT){
+    type_stack[sp-1]=pUserProc->ReturnType().GetBasicType();
+    index_stack[sp-1]=pUserProc->ReturnType().GetIndex();
+
+    if( pUserProc->ReturnType().IsStruct() ){
         //構造体が戻ったときはヒープ領域にインスタンスが格納されている
         //※後にfreeする必要あり
@@ -281 +265 @@
 }
 
-void CallCastOperatorProc(int reg,int &CalcType,LONG_PTR &lpCalcIndex,BOOL bCalcUseHeap,int ToType,LONG_PTR lpToIndex){
-    int type[10];
+void CallCastOperatorProc(int reg,Type &calcType,BOOL bCalcUseHeap,const Type &toType){
+    int type_stack[10];
     LONG_PTR index_stack[10];
     BOOL array_bUseHeap[10];
@@ -304 +288 @@
 
         //左辺
-        type[0]=CalcType;
-        index_stack[0]=lpCalcIndex;
+        type_stack[0]=calcType.GetBasicType();
+        index_stack[0]=calcType.GetIndex();
         array_bUseHeap[0]=0;
-        type[1]=ToType;
-        index_stack[1]=lpToIndex;
+        type_stack[1]=toType.GetBasicType();
+        index_stack[1]=toType.GetIndex();
         array_bUseHeap[1]=0;
 
-        TYPEINFO BaseTypeInfo={ToType,lpToIndex};
-
-        iRet=CallOperatorProc(CALC_AS,&BaseTypeInfo,type,index_stack,array_bUseHeap,sp);
+        iRet=CallOperatorProc(CALC_AS,toType,type_stack,index_stack,array_bUseHeap,sp);
 
         pobj_reg->UnlockReg();
@@ -325 +307 @@
     if(iRet==1){
         //成功したとき
-        CalcType=type[0];
-        lpCalcIndex=index_stack[0];
+        calcType.SetType( type_stack[0], index_stack[0] );
         return;
     }
@@ -339 +320 @@
 
 //インデクサ（getter）を呼び出す
-void CallIndexerGetterProc(int reg,CClass *pobj_Class,char *ObjectName,char *Parameter,TYPEINFO &RetTypeInfo){
-
-    std::vector<SubInfo *> subs;
+void CallIndexerGetterProc(int reg,const CClass *pobj_Class,char *ObjectName,char *Parameter,Type &resultType ){
+
+    std::vector<UserProc *> subs;
     pobj_Class->EnumMethod( CALC_ARRAY_GET, subs );
     if( subs.size() == 0 ){
@@ -353 +334 @@
 
         Opcode_CallProc(Parameter,subs[0],0,ObjectName,DEF_OBJECT);
-        RetTypeInfo.type = subs[0]->ReturnType;
-        RetTypeInfo.u.lpIndex = subs[0]->u.ReturnIndex;
+        resultType = subs[0]->ReturnType();
 
         //mov reg,rax

BasicCompiler64/WatchList.cpp

@@ -5 +5 @@
 #include "../BasicCompiler_Common/debug.h"
 
-int Debugging_GetArray(int *SubScripts,char *array,int type,LONG_PTR lpIndex,LONG_PTR *plpOffset);
+int Debugging_GetArray( const int *SubScripts,char *array,const Type &type,LONG_PTR *plpOffset);
 
 ULONG_PTR Debugging_GetVarPtr(RELATIVE_VAR *pRelativeVar){
@@ -61 +61 @@
 }
 
-BOOL Debugging_SetRelativeOffset(int *pType,LONG_PTR lpIndex,RELATIVE_VAR *pRelativeVar,char *lpPtrOffset){
+bool Debugging_SetRelativeOffset( Type &type,RELATIVE_VAR *pRelativeVar,char *lpPtrOffset){
     int array_num;
 
     _int64 i64data;
-    int type;
-    type=StaticCalculation(true, lpPtrOffset,0,&i64data,0,1);
-    if(!type) return 0;
-    if(IsRealNumberType(type)){
+    if( !StaticCalculation( true, lpPtrOffset, 0, &i64data, Type(), 1 ) ){
+        return false;
+    }
+    if( type.IsReal() ){
         double dbl;
         memcpy(&dbl,&i64data,sizeof(double));
@@ -76 +76 @@
     array_num=(int)i64data;
 
-    if(PTR_LEVEL(*pType)){
-        *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
-        array_num *= GetTypeSize(*pType,-1);
+    if( type.PtrLevel() ){
+        type.PtrLevelDown();
+        array_num *= type.GetSize();
     }
     else{
         //エラー
-        return 0;
+        return false;
     }
 
@@ -89 +89 @@
     SIZE_T stAccBytes;
     lpData=Debugging_GetVarPtr(pRelativeVar);
-    if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&stAccBytes)) return 0;
+    if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&stAccBytes)){
+        return false;
+    }
     pRelativeVar->dwKind=VAR_DIRECTMEM;
 
     pRelativeVar->offset+=array_num;
-    return 1;
+    return true;
 }
 
-BOOL Debugging_GetMember(CClass *pobj_c,char *member,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpNestIndex,BOOL bPrivateAccess){
+int Debugging_GetMember( const CClass &objClass,char *member,RELATIVE_VAR *pRelativeVar, Type &resultType, BOOL bPrivateAccess){
     int i,i2;
 
@@ -117 +119 @@
     ////////////////////////////
 
-    int offset = pobj_c->GetMemberOffset( VarName, &i );
-    if(i==pobj_c->iMemberNum) return 0;
+    int offset = objClass.GetMemberOffset( VarName, &i );
+    if(i==objClass.iMemberNum) return 0;
 
 
     //アクセシビリティをチェック
-    if((bPrivateAccess==0&&pobj_c->ppobj_Member[i]->dwAccess==ACCESS_PRIVATE)||
-        pobj_c->ppobj_Member[i]->dwAccess==ACCESS_NON){
+    if((bPrivateAccess==0&&objClass.ppobj_Member[i]->dwAccess==ACCESS_PRIVATE)||
+        objClass.ppobj_Member[i]->dwAccess==ACCESS_NON){
         return 0;
     }
-    else if(bPrivateAccess==0&&pobj_c->ppobj_Member[i]->dwAccess==ACCESS_PROTECTED)
+    else if(bPrivateAccess==0&&objClass.ppobj_Member[i]->dwAccess==ACCESS_PROTECTED)
         return 0;
 
-    *pType=pobj_c->ppobj_Member[i]->TypeInfo.type;
-    *plpNestIndex=pobj_c->ppobj_Member[i]->TypeInfo.u.lpIndex;
+    resultType = *objClass.ppobj_Member[i];
 
     //ポインタ変数の場合
-    if(IsPtrType(*pType)){
-        if(pobj_c->ppobj_Member[i]->SubScripts[0]==-1){
+    if( resultType.IsPointer() ){
+        if(objClass.ppobj_Member[i]->SubScripts[0]==-1){
             lstrcpy(lpPtrOffset,array);
             array[0]=0;
@@ -148 +149 @@
         //配列オフセット
         i2=Debugging_GetArray(
-            pobj_c->ppobj_Member[i]->SubScripts,
+            objClass.ppobj_Member[i]->SubScripts,
             array,
-            *pType,
-            pobj_c->ppobj_Member[i]->TypeInfo.u.lpIndex,
+            resultType,
             &pRelativeVar->offset);
         if(i2==0){
@@ -162 +162 @@
         }
     }
-    else if(pobj_c->ppobj_Member[i]->SubScripts[0]!=-1){
-        *pType|=FLAG_PTR;
+    else if(objClass.ppobj_Member[i]->SubScripts[0]!=-1){
+        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
     }
 
@@ -169 +169 @@
         //入れ子構造の場合
 
-        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
+        if( resultType.IsObject() || resultType.IsStruct() ){
             if( refType != CClass::Dot ) return 0;
 
-            if( *pType==DEF_OBJECT ){
+            if( resultType.IsObject() ){
                 extern HANDLE hDebugProcess;
                 LONG_PTR lpData;
@@ -181 +181 @@
             }
         }
-        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
+        else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
             //構造体ポインタ型メンバ変数
 
@@ -188 +188 @@
 
                 //直接参照に切り替え
-                Debugging_SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
+                Debugging_SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
 
                 lpPtrOffset[0]=0;
@@ -204 +204 @@
         }
 
-        i2=Debugging_GetMember(pobj_c->ppobj_Member[i]->TypeInfo.u.pobj_Class,
+        i2=Debugging_GetMember(objClass.ppobj_Member[i]->GetClass(),
             NestMember,
-            pType,
             pRelativeVar,
-            plpNestIndex,
+            resultType,
             0);
         if(i2==0){
@@ -221 +220 @@
 
     if(lpPtrOffset[0]){
-        Debugging_SetRelativeOffset(pType,*plpNestIndex,pRelativeVar,lpPtrOffset);
+        Debugging_SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
     }
 
     return 1;
 }
-int Debugging_GetArray(int *SubScripts,char *array,int type,LONG_PTR lpIndex,LONG_PTR *plpOffset){
+int Debugging_GetArray( const int *SubScripts,char *array,const Type &type,LONG_PTR *plpOffset){
     extern HANDLE hHeap;
-    int i,i2,i3,i4,i5,array_offset,TypeSize;
+    int i,i2,i3,i4,i5,array_offset;
     char temporary[VN_SIZE],*pParm[MAX_PARMS];
 
@@ -275 +274 @@
     for(i=i3-1;i>=0;i--){
         _int64 i64data;
-        i2=StaticCalculation(true, pParm[i],0,&i64data,0,1);
-        if(i2==0){
+        Type resultType;
+        bool isMemoryAccessError;
+        if( !StaticCalculation(true, pParm[i],0,&i64data,resultType,1, &isMemoryAccessError ) ){
             //式エラー
             return 0;
         }
-        if(i2==-1){
+        if(isMemoryAccessError){
             //アクセスエラー
             return -1;
         }
 
-        if(IsRealNumberType(i2)){
+        if(resultType.IsReal()){
             double dbl;
             memcpy(&dbl,&i64data,sizeof(double));
@@ -299 +299 @@
     }
 
-    TypeSize=GetTypeSize(type,lpIndex);
-
-    array_offset*=TypeSize;
+    array_offset *= type.GetSize();
 
     *plpOffset+=array_offset;
@@ -308 +306 @@
 }
 ULONG_PTR Debugging_GetThisPtrOffset(LONG_PTR obp_Rip){
-    int i;
-    SubInfo *psi;
-
-    //ripからプロシージャを取得
-    psi=GetSubFromObp(obp_Rip);
-
-    for(i=0;i<psi->VarNum;i++){
-        if(lstrcmp(psi->pVar[i].name,"_System_LocalThis")==0) break;
-    }
-    if(i==psi->VarNum) return 0;
-
-    return psi->pVar[i].offset;
+    UserProc *pUserProc = GetSubFromObp(obp_Rip);
+
+    foreach( Variable *pVar, pUserProc->localVars ){
+        if( pVar->GetName() == "_System_LocalThis" ){
+            return pVar->offset;
+        }
+    }
+    return 0;
 }
-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){
     extern HANDLE hDebugProcess;
     int i,i2,i3;
@@ -332 +326 @@
     GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
 
-    LONG_PTR lpIndex;
-    int *pSubScripts;
-    BOOL bArray;
+    const int *pSubScripts;
+    bool isArray;
 
 
@@ -340 +333 @@
     // ローカル変数
     /////////////////
-    extern VARIABLE *LocalVar;
-    extern int MaxLocalVarNum;
-    for(i=0;i<MaxLocalVarNum;i++){
-        if(lstrcmp(VarName,LocalVar[i].name)==0) break;
-    }
-    if(i!=MaxLocalVarNum){
+    const Variable *pVar = UserProc::CompilingUserProc().localVars.Find( VarName );
+    if( pVar ){
         //ポインタ変数の場合
-        if(IsPtrType(LocalVar[i].type)){
-            if(!LocalVar[i].bArray){
+        if( pVar->IsPointer() ){
+            if( !pVar->IsArray() ){
                 lstrcpy(lpPtrOffset,array);
                 array[0]=0;
@@ -357 +346 @@
         }
 
-        pRelativeVar->offset=LocalVar[i].offset;
-        if(LocalVar[i].fRef) pRelativeVar->dwKind=VAR_REFLOCAL;
-        else pRelativeVar->dwKind=VAR_LOCAL;
-        *pType=LocalVar[i].type;
-        lpIndex=LocalVar[i].u.index;
-        *plpIndex=lpIndex;
-        bArray=LocalVar[i].bArray;
-        pSubScripts=LocalVar[i].SubScripts;
+        pRelativeVar->offset = pVar->offset;
+        if( pVar->IsRef() ){
+            pRelativeVar->dwKind=VAR_REFLOCAL;
+        }
+        else{
+            pRelativeVar->dwKind=VAR_LOCAL;
+        }
+        resultType = *pVar;
+        isArray = pVar->IsArray();
+        pSubScripts = pVar->GetSubScriptsPtr();
     }
     else{
@@ -406 +397 @@
             pRelativeVar->dwKind=VAR_DIRECTMEM;
 
-            LONG_PTR lp2;
-            i3=Debugging_GetMember(pobj_CompilingClass,variable,pType,pRelativeVar,&lp2,1);
+            i3=Debugging_GetMember(*pobj_CompilingClass,variable,pRelativeVar,resultType,1);
             if(i3==0){
                 //式エラー
@@ -417 +407 @@
             }
 
-            *plpIndex=lp2;
             return 1;
         }
@@ -426 +415 @@
         // グローバル変数
         ///////////////////
-        extern VARIABLE *GlobalVar;
-        extern int MaxGlobalVarNum;
-
-        for(i=0;i<MaxGlobalVarNum;i++){
-            if(lstrcmp(VarName,GlobalVar[i].name)==0) break;
-        }
-        if(i==MaxGlobalVarNum){
+
+        const Variable *pVar = globalVars.Find( VarName );
+        if( !pVar ){
             //一致しないとき
             return 0;
@@ -438 +423 @@
 
         //ポインタ変数の場合
-        if(IsPtrType(GlobalVar[i].type)){
-            if(!GlobalVar[i].bArray){
+        if( pVar->IsPointer() ){
+            if( !pVar->IsArray() ){
                 lstrcpy(lpPtrOffset,array);
                 array[0]=0;
@@ -448 +433 @@
         }
 
-        pRelativeVar->offset=GlobalVar[i].offset;
-        if(GlobalVar[i].fRef) pRelativeVar->dwKind=VAR_REFGLOBAL;
+        pRelativeVar->offset=pVar->offset;
+        if(pVar->IsRef()) pRelativeVar->dwKind=VAR_REFGLOBAL;
         else pRelativeVar->dwKind=VAR_GLOBAL;
-        *pType=GlobalVar[i].type;
-        lpIndex=GlobalVar[i].u.index;
-        *plpIndex=lpIndex;
-        bArray=GlobalVar[i].bArray;
-        pSubScripts=GlobalVar[i].SubScripts;
-    }
-
-
-    if(array[0]==0&&bArray){
+        resultType = *pVar;
+        isArray = pVar->IsArray();
+        pSubScripts=pVar->GetSubScriptsPtr();
+    }
+
+
+    if(array[0]==0&&isArray){
         //配列の先頭ポインタを示す場合
-        *pType|=FLAG_PTR;
-        if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM);
+        resultType.SetBasicType( resultType.GetBasicType() | FLAG_PTR );
+        if(pss) memcpy(pss,pSubScripts,MAX_ARRAYDIM*sizeof(int));
         return 1;
     }
 
     if(array[0]){
-        i3=Debugging_GetArray(pSubScripts,array,*pType,lpIndex,&pRelativeVar->offset);
+        i3=Debugging_GetArray(pSubScripts,array,resultType,&pRelativeVar->offset);
         if(i3==0){
             //式エラー
@@ -478 +461 @@
     }
     if(member[0]){
-        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
+        if( resultType.IsObject() || resultType.IsStruct() ){
             //実態オブジェクトのメンバを参照（obj.member）
             if( refType != CClass::Dot ){
@@ -484 +467 @@
             }
 
-            LONG_PTR lp2;
-            i3=Debugging_GetMember((CClass *)lpIndex,member,pType,pRelativeVar,&lp2,0);
+            i3=Debugging_GetMember(resultType.GetClass(),member,pRelativeVar,resultType,0);
             if(i3==0){
                 //式エラー
@@ -494 +476 @@
                 return -1;
             }
-
-            *plpIndex=lp2;
-        }
-        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
+        }
+        else if( resultType.IsObjectPtr() || resultType.IsStructPtr() ){
             //ポインタオブジェクトが示すメンバを参照
             if(lpPtrOffset[0]){
                 //pObj[n].member
                 if( refType != CClass::Dot ) return 0;
-                Debugging_SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
-
-                LONG_PTR lp2;
-                i3=Debugging_GetMember((CClass *)lpIndex,member,pType,pRelativeVar,&lp2,0);
+                Debugging_SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset);
+
+                i3=Debugging_GetMember(resultType.GetClass(),member,pRelativeVar,resultType,0);
                 if(i3==0){
                     //式エラー
@@ -514 +493 @@
                     return -1;
                 }
-
-                *plpIndex=lp2;
             }
             else{
@@ -527 +504 @@
                 pRelativeVar->offset=lpData;
 
-                LONG_PTR lp2;
-                i3=Debugging_GetMember((CClass *)lpIndex,member,pType,pRelativeVar,&lp2,0);
+                i3=Debugging_GetMember(resultType.GetClass(),member,pRelativeVar,resultType,0);
                 if(i3==0){
                     //式エラー
@@ -537 +513 @@
                     return -1;
                 }
-
-                *plpIndex=lp2;
             }
         }
@@ -548 +522 @@
 
     if(lpPtrOffset[0]){
-        if(!Debugging_SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset)) return 0;
+        if(!Debugging_SetRelativeOffset(resultType,pRelativeVar,lpPtrOffset)) return 0;
     }
 

BasicCompiler64/amd64_main.cpp

@@ -1791 +1791 @@
 /////////////////////////////
 
-void op_call( SubInfo *psi ){
+void op_call( UserProc *pUserProc ){
     OpBuffer[obp++] = (char)0xE8;
-    pobj_SubAddrSchedule->add( psi, 1 );
-    psi->bUse = 1;
+    pobj_SubAddrSchedule->add( pUserProc, 1 );
+    pUserProc->Using();
     obp += sizeof(long);
 }
-void op_call( DECLAREINFO *pdi ){
+void op_call( DllProc *pDllProc ){
     OpBuffer[obp++] = (char)0xFF;
     OpBuffer[obp++] = (char)0x15;
-    pobj_ImportAddrSchedule->add(pdi);
+    pobj_ImportAddrSchedule->add(pDllProc);
     obp += sizeof(long);
 
-    pdi->bUse=1;
-}
+    pDllProc->Using();
+}

BasicCompiler64/increment.cpp

@@ -3 +3 @@
 
 void IncDec(int idCalc, char *lpszLeft, char *lpszRight){
-    int VarType;
-    LONG_PTR lpVarIndex;
-    RELATIVE_VAR VarRelativeVar;
-
 
     ///////////////////////////
@@ -12 +8 @@
     ///////////////////////////
 
+    RELATIVE_VAR VarRelativeVar;
+    Type varType;
     if(!GetVarOffsetReadWrite(
         lpszLeft,
-        &VarType,
         &VarRelativeVar,
-        &lpVarIndex)) return;
+        varType)) return;
 
     //変数オフセットを一時退避
@@ -30 +27 @@
 
     int reg;
-    if(VarType==DEF_DOUBLE){
+    if( varType.IsDouble() ){
         reg=REG_XMM0;
         SetXmmReg_DoubleVariable(&VarRelativeVar,reg);
     }
-    else if(VarType==DEF_SINGLE){
+    else if( varType.IsSingle() ){
         reg=REG_XMM0;
         SetXmmReg_SingleVariable(&VarRelativeVar,reg);
@@ -40 +37 @@
     else{
         reg=REG_RAX;
-        SetReg_WholeVariable(VarType,&VarRelativeVar,reg);
+        SetReg_WholeVariable(varType.GetBasicType(),&VarRelativeVar,reg);
     }
 
 
-    if(IsWholeNumberType(VarType)&&lstrcmp(lpszRight,"1")==0&&
+    if(varType.IsWhole()&&lstrcmp(lpszRight,"1")==0&&
         (idCalc==CALC_ADDITION||idCalc==CALC_SUBTRACTION)){
             if(idCalc==CALC_ADDITION){
@@ -60 +57 @@
 
         //右辺を計算
-        int CalcType;
-        LONG_PTR lpCalcIndex;
+        Type calcType;
         if(reg==REG_RAX) reg=REG_RCX;
         else reg=REG_RAX;
-        CalcType=NumOpe(&reg,lpszRight,VarType,lpVarIndex,&lpCalcIndex);
+        NumOpe(&reg,lpszRight,varType,calcType);
 
         //レジスタのブロッキングを解除
@@ -70 +66 @@
 
 
-        if(IsPtrType(VarType)&&IsWholeNumberType(CalcType)&&(!IsPtrType(CalcType))){
+        if(varType.IsPointer()&&calcType.IsWhole()&&(!calcType.IsPointer())){
             //左辺がポインタ型、右辺が整数型の場合は、エラーをださないようにする
-            CalcType=VarType;
-            lpCalcIndex=lpVarIndex;
+            calcType = varType;
         }
 
@@ -81 +76 @@
         /////////////////////////////////
 
-        CheckDifferentType(VarType,lpVarIndex,CalcType,lpCalcIndex,0,0);
+        CheckDifferentType(varType,calcType,0,0);
 
 
@@ -88 +83 @@
 
         //左辺用レジスタ
-        if(IsRealNumberType(VarType))
+        if(varType.IsReal())
             pobj_reg->LockXmmReg();
         else
@@ -94 +89 @@
 
         //右辺値レジスタ
-        if(VarType==DEF_DOUBLE)
-            ChangeTypeToXmm_Double(CalcType,
+        if(varType.IsDouble())
+            ChangeTypeToXmm_Double(calcType.GetBasicType(),
                 pobj_reg->LockXmmReg(),
                 pobj_reg->GetNextReg());
-        else if(VarType==DEF_SINGLE)
-            ChangeTypeToXmm_Single(CalcType,
+        else if(varType.IsSingle())
+            ChangeTypeToXmm_Single(calcType.GetBasicType(),
                 pobj_reg->LockXmmReg(),
                 pobj_reg->GetNextReg());
         else
-            ChangeTypeToWhole(CalcType,VarType,
+            ChangeTypeToWhole(calcType.GetBasicType(),varType.GetBasicType(),
                 pobj_reg->LockReg(),
                 pobj_reg->GetNextXmmReg());
 
-        int type[255],sp;
+        int type_stack[255],sp;
         LONG_PTR index_stack[255];
-        type[0]=VarType;
-        type[1]=VarType;
-        index_stack[0]=lpVarIndex;
-        index_stack[1]=lpVarIndex;
+        type_stack[0]=varType.GetBasicType();
+        type_stack[1]=varType.GetBasicType();
+        index_stack[0]=varType.GetIndex();
+        index_stack[1]=varType.GetIndex();
         sp=2;
 
@@ -119 +114 @@
             case CALC_OR:
             case CALC_AND:
-                CalcTwoTerm_Logical(idCalc,type,index_stack,&sp);
+                CalcTwoTerm_Logical(idCalc,type_stack,index_stack,&sp);
                 break;
             case CALC_SHL:
             case CALC_SHR:
-                Calc_Shift(idCalc,type,&sp);
+                Calc_Shift(idCalc,type_stack,&sp);
                 break;
             case CALC_ADDITION:
             case CALC_SUBTRACTION:
             case CALC_PRODUCT:
-                CalcTwoTerm_Arithmetic(idCalc,type,index_stack,&sp);
+                CalcTwoTerm_Arithmetic(idCalc,type_stack,index_stack,&sp);
                 break;
             case CALC_MOD:
-                Calc_Mod(type,index_stack,&sp);
+                Calc_Mod(type_stack,index_stack,&sp);
                 break;
             case CALC_QUOTIENT:
-                Calc_Divide(type,&sp,VarType);
+                Calc_Divide(type_stack,&sp,varType.GetBasicType());
                 break;
             case CALC_INTQUOTIENT:
-                Calc_IntDivide(type,index_stack,&sp);
+                Calc_IntDivide(type_stack,index_stack,&sp);
                 break;
             case CALC_POWER:
-                Calc_Power(type,&sp);
+                Calc_Power(type_stack,&sp);
                 break;
         }
@@ -160 +155 @@
     }
 
-    SetVariableFromRax(VarType,VarType,&VarRelativeVar);
+    SetVariableFromRax(varType.GetBasicType(),varType.GetBasicType(),&VarRelativeVar);
 }

BasicCompiler64/varlist.cpp

@@ -7 +7 @@
 HWND hVarTree_Global,hVarTree_Local,hVarTree_This;
 
-int VarList_Array(HWND hVarTree,HTREEITEM hParent,LONG_PTR offset,int type,int *SubScripts,LONG_PTR lpIndex);
-void VarList_Member(HWND hVarTree,HTREEITEM hParent,LONG_PTR pTopOffset,CClass *pobj_c,BOOL bPtr);
-void VarList_Insert(HWND hVarTree,TV_INSERTSTRUCT *lptv,char *VarName,int type,LONG_PTR offset,LONG_PTR lpIndex){
+int VarList_Array(HWND hVarTree,HTREEITEM hParent,LONG_PTR offset,const Type &type,const int *SubScripts);
+void VarList_Member(HWND hVarTree,HTREEITEM hParent,LONG_PTR pTopOffset,const CClass &objClass,BOOL bPtr);
+void VarList_Insert(HWND hVarTree,TV_INSERTSTRUCT *lptv,const char *VarName,const Type &type,LONG_PTR offset){
     extern HANDLE hDebugProcess;
     int i2;
@@ -22 +22 @@
     _int64 i64data;
 
-    if(type==DEF_OBJECT||type==DEF_STRUCT){
-        if( type==DEF_OBJECT ){
+    if( type.IsObject() || type.IsStruct() ){
+        if( type.IsObject() ){
             // 参照型ということを考慮する
             ReadProcessMemory(hDebugProcess,(void *)offset,&pData,sizeof(void *),&stAccBytes);
@@ -34 +34 @@
         hParent=TreeView_InsertItem(hVarTree,lptv);
 
-        VarList_Member(hVarTree,hParent,offset,(CClass *)lpIndex,0);
+        VarList_Member(hVarTree,hParent,offset,type.GetClass(),0);
         return;
     }
-    if(type==DEF_PTR_OBJECT||type==DEF_PTR_STRUCT){
+    else if( type.IsObjectPtr() || type.IsStructPtr() ){
         i2=ReadProcessMemory(hDebugProcess,(void *)offset,&pData,sizeof(void *),&stAccBytes);
 
@@ -45 +45 @@
         hParent=TreeView_InsertItem(hVarTree,lptv);
 
-        if(i2) VarList_Member(hVarTree,hParent,pData,(CClass *)lpIndex,1);
+        if(i2) VarList_Member(hVarTree,hParent,pData,type.GetClass(),1);
         return;
     }
     else{
-        if(type==MAKE_PTR_TYPE(DEF_SBYTE,1)||type==MAKE_PTR_TYPE(DEF_BYTE,1)){
+        if(type.GetBasicType()==MAKE_PTR_TYPE(DEF_SBYTE,1)||type.GetBasicType()==MAKE_PTR_TYPE(DEF_BYTE,1)){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&pData,sizeof(void *),&stAccBytes)){
                 for(i2=0;;i2++){
@@ -67 +67 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_DOUBLE){
+        else if(type.IsDouble()){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&dbl,sizeof(double),&stAccBytes)){
                 sprintf(lptv->item.pszText,"%s %.15g",VarName,dbl);
@@ -73 +73 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_SINGLE){
+        else if(type.IsSingle()){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&flt,sizeof(float),&stAccBytes)){
                 sprintf(lptv->item.pszText,"%s %.6g",VarName,flt);
@@ -79 +79 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_INT64){
+        else if(type.IsInt64()){
             _int64 i64data;
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&i64data,sizeof(_int64),&stAccBytes)){
@@ -89 +89 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_QWORD||IsPtrType(type)){
+        else if(type.IsQWord()||type.IsPointer()){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&i64data,sizeof(_int64),&stAccBytes)){
                 _ui64toa(i64data,temporary,10);
@@ -98 +98 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_LONG){
+        else if(type.IsLong()){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&i64data,sizeof(_int64),&stAccBytes)){
                 sprintf(lptv->item.pszText,"%s %d(&H%X)",VarName,i64data,i64data);
@@ -104 +104 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_DWORD){
+        else if(type.IsDWord()){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&i64data,sizeof(_int64),&stAccBytes)){
                 sprintf(lptv->item.pszText,"%s %u(&H%X)",VarName,i64data,i64data);
@@ -110 +110 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){
+        else if(type.IsInteger()){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&wData,sizeof(WORD),&stAccBytes)){
                 sprintf(lptv->item.pszText,"%s %d(&H%X)",VarName,(short)wData,(short)wData);
@@ -116 +116 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_WORD){
+        else if(type.IsWord()){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&wData,sizeof(WORD),&stAccBytes)){
                 sprintf(lptv->item.pszText,"%s %u(&H%X)",VarName,wData,wData);
@@ -122 +122 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
+        else if(type.IsSByte()){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&byteData,sizeof(BYTE),&stAccBytes)){
                 temporary[0]=byteData;
@@ -130 +130 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_BYTE){
+        else if(type.IsByte()){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&byteData,sizeof(BYTE),&stAccBytes)){
                 temporary[0]=byteData;
@@ -138 +138 @@
             else sprintf(lptv->item.pszText,"%s %s",VarName,STRING_CANNOTACCESS);
         }
-        else if(type==DEF_BOOLEAN){
+        else if(type.IsBoolean()){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&byteData,sizeof(BYTE),&stAccBytes)){
                 if( byteData ) lstrcpy( temporary, "True" );
@@ -152 +152 @@
     TreeView_InsertItem(hVarTree,lptv);
 }
-void VarList_Member(HWND hVarTree,HTREEITEM hParent,LONG_PTR pTopOffset,CClass *pobj_c,BOOL bPtr){
+void VarList_Member(HWND hVarTree,HTREEITEM hParent,LONG_PTR pTopOffset,const CClass &objClass,BOOL bPtr){
     int i,i2;
     char VarData[VN_SIZE],VarName[VN_SIZE];
@@ -163 +163 @@
     tv.item.pszText=VarData;
 
-    for(i=0;i<pobj_c->iMemberNum;i++){
+    for(i=0;i<objClass.iMemberNum;i++){
         if(bPtr){
             lstrcpy(VarName,"->");
-            lstrcat(VarName,pobj_c->ppobj_Member[i]->name);
+            lstrcat(VarName,objClass.ppobj_Member[i]->name);
         }
         else{
             lstrcpy(VarName,".");
-            lstrcat(VarName,pobj_c->ppobj_Member[i]->name);
+            lstrcat(VarName,objClass.ppobj_Member[i]->name);
         }
 
         LONG_PTR offset;
-        offset=pobj_c->GetMemberOffset( pobj_c->ppobj_Member[i]->name, &i2 );
-
-        if(pobj_c->ppobj_Member[i]->SubScripts[0]!=-1){
+        offset=objClass.GetMemberOffset( objClass.ppobj_Member[i]->name, &i2 );
+
+        if(objClass.ppobj_Member[i]->SubScripts[0]!=-1){
             //構造体内の配列
             sprintf(VarData,"%s %s(&H%X)",VarName,STRING_ARRAY,pTopOffset+offset);
@@ -185 +185 @@
             i2=VarList_Array(hVarTree,hParent,
                 pTopOffset+offset,
-                pobj_c->ppobj_Member[i]->TypeInfo.type,
-                pobj_c->ppobj_Member[i]->SubScripts,
-                pobj_c->ppobj_Member[i]->TypeInfo.u.lpIndex);
+                *objClass.ppobj_Member[i],
+                objClass.ppobj_Member[i]->SubScripts);
         }
         else{
@@ -194 +193 @@
                 &tv,
                 VarName,
-                pobj_c->ppobj_Member[i]->TypeInfo.type,
-                pTopOffset+offset,
-                pobj_c->ppobj_Member[i]->TypeInfo.u.lpIndex);
-        }
-    }
-}
-int VarList_Array(HWND hVarTree,HTREEITEM hParent,LONG_PTR offset,int type,int *SubScripts,LONG_PTR lpIndex){
-    int i,i2,i3,ElementNum,MemCounter,UseCount[255],TypeSize;
+                *objClass.ppobj_Member[i],
+                pTopOffset+offset);
+        }
+    }
+}
+int VarList_Array(HWND hVarTree,HTREEITEM hParent,LONG_PTR offset,const Type &type,const int *SubScripts ){
+    int i,i2,i3,ElementNum,MemCounter,UseCount[255];
     char temporary[VN_SIZE],temp2[DIGIT_SIZE];
 
@@ -210 +208 @@
     tv.hParent=hParent;
     tv.item.pszText=temporary;
-
-    TypeSize=GetTypeSize(type,lpIndex);
 
     for(i=0;i<255;i++){
@@ -240 +236 @@
 
             VarList_Insert(hVarTree,&tv,temporary,type,
-                offset+MemCounter*TypeSize,
-                lpIndex);
+                offset+MemCounter*type.GetSize());
         }
 
@@ -254 +249 @@
 void RefreshGlobalVar(void){
     extern DWORD ImageBase;
-    int i;
     char temporary[VN_SIZE];
     TV_INSERTSTRUCT tv;
@@ -269 +263 @@
     extern HANDLE hDebugProcess;
     extern int MemPos_RWSection;
-    extern int MaxGlobalVarNum;
-    extern VARIABLE *GlobalVar;
-
-    for(i=0;i<MaxGlobalVarNum;i++){
-        VARIABLE *pVar=&GlobalVar[i];
+
+    foreach( Variable *pVar, globalVars ){
 
         //スコープ外の場合は無視
@@ -289 +280 @@
 
         if(!pobj_nv->bShow_DefaultSystem_Var){
-            if(memcmp(pVar->name,"_System_",8)==0||
-                memcmp(pVar->name,"_DebugSys_",10)==0||
-                memcmp(pVar->name,"_PromptSys_",11)==0) continue;
+            if(memcmp(pVar->GetName().c_str(),"_System_",8)==0||
+                memcmp(pVar->GetName().c_str(),"_DebugSys_",10)==0||
+                memcmp(pVar->GetName().c_str(),"_PromptSys_",11)==0) continue;
         }
         if(!pobj_nv->bShow_Rad_Var){
-            if(memcmp(pVar->name,"_RadSys_",8)==0) continue;
+            if(memcmp(pVar->GetName().c_str(),"_RadSys_",8)==0) continue;
         }
         if(!pobj_nv->bShow_GUID_Var){
-            if(memcmp(pVar->name,"GUID_",5)==0||
-                memcmp(pVar->name,"IID_",4)==0||
-                memcmp(pVar->name,"CLSID_",6)==0) continue;
+            if(memcmp(pVar->GetName().c_str(),"GUID_",5)==0||
+                memcmp(pVar->GetName().c_str(),"IID_",4)==0||
+                memcmp(pVar->GetName().c_str(),"CLSID_",6)==0) continue;
         }
 
         //静的メンバ
-        if(strstr(pVar->name,".")) continue;
-
-        if(pVar->bArray){
+        if(strstr(pVar->GetName().c_str(),".")) continue;
+
+        if(pVar->IsArray()){
             sprintf(temporary,"%s %s(&H%X)",
-                pVar->name,
+                pVar->GetName().c_str(),
                 STRING_ARRAY,
                 ImageBase+MemPos_RWSection+pVar->offset);
@@ -316 +307 @@
             VarList_Array(hVarTree_Global,hParent,
                 (LONG_PTR)(ImageBase+MemPos_RWSection+pVar->offset),
-                pVar->type,
-                pVar->SubScripts,
-                pVar->u.index);
+                *pVar,
+                pVar->GetSubScriptsPtr());
         }
         else{
             VarList_Insert(hVarTree_Global,
                 &tv,
-                pVar->name,
-                pVar->type,
-                (LONG_PTR)(ImageBase+MemPos_RWSection+pVar->offset),
-                pVar->u.index);
+                pVar->GetName().c_str(),
+                *pVar,
+                (LONG_PTR)(ImageBase+MemPos_RWSection+pVar->offset));
         }
     }
@@ -354 +343 @@
     if(pobj_dti->lplpSpBase[i2]==0) return;
 
-    extern SubInfo **ppSubHash;
-    SubInfo *psi;
+    extern UserProc **ppSubHash;
+    UserProc *pUserProc;
     for(i3=0,sw=0;i3<MAX_HASH;i3++){
-        psi=ppSubHash[i3];
-        while(psi){
-            if(rva_to_real(psi->CompileAddress) <= pobj_dti->lplpObp[i2]  &&
-                pobj_dti->lplpObp[i2] < rva_to_real(psi->EndOpAddr)){
+        pUserProc=ppSubHash[i3];
+        while(pUserProc){
+            if(rva_to_real(pUserProc->beginOpAddress) <= pobj_dti->lplpObp[i2]  &&
+                pobj_dti->lplpObp[i2] < rva_to_real(pUserProc->endOpAddress)){
                 sw=1;
                 break;
             }
 
-            psi=psi->pNextData;
+            pUserProc=pUserProc->pNextData;
         }
         if(sw) break;
     }
-    if(!psi) return;
-
-    for(i=0;i<psi->VarNum;i++){
-        VARIABLE *pVar=&psi->pVar[i];
+    if(!pUserProc) return;
+
+    foreach( Variable *pVar, UserProc::CompilingUserProc().localVars ){
 
         //スコープ外の場合は無視
@@ -386 +374 @@
         }
 
-        if(pVar->bArray){
+        if(pVar->IsArray()){
             sprintf(temporary,"%s %s(&H%X)",
-                pVar->name,
+                pVar->GetName().c_str(),
                 STRING_ARRAY,
                 pobj_dti->lplpSpBase[i2]+pVar->offset);
@@ -397 +385 @@
             VarList_Array(hVarTree_Local,hParent,
                 pobj_dti->lplpSpBase[i2]+pVar->offset,
-                pVar->type,
-                pVar->SubScripts,
-                pVar->u.index);
+                *pVar,
+                pVar->GetSubScriptsPtr());
         }
         else{
             offset=pobj_dti->lplpSpBase[i2]+pVar->offset;
-            if(pVar->fRef){
+            if(pVar->IsRef()){
                 ReadProcessMemory(hDebugProcess,(void *)offset,&lpData,sizeof(LONG_PTR),&stAccBytes);
                 offset=lpData;
             }
             VarList_Insert(hVarTree_Local,&tv,
-                pVar->name,
-                pVar->type,
-                offset,
-                pVar->u.index);
+                pVar->GetName().c_str(),
+                *pVar,
+                offset);
         }
     }
@@ -422 +408 @@
 
     TreeView_DeleteAllItems(hVarTree_This);
-    if(!psi->pobj_ParentClass) return;
+    if(!pUserProc->GetParentClassPtr()) return;
 
     //Thisポインタを取得
     LONG_PTR pThis;
-    for(i=0;i<psi->VarNum;i++){
-        if(lstrcmp(psi->pVar[i].name,"_System_LocalThis")==0) break;
-    }
-    if(i==psi->VarNum) return;
-    lpData=pobj_dti->lplpSpBase[i2]+psi->pVar[i].offset;
+    const Variable *pVar = UserProc::CompilingUserProc().localVars.Find( "_System_LocalThis" );
+    if( !pVar ){
+        return;
+    }
+    lpData=pobj_dti->lplpSpBase[i2]+pVar->offset;
     ReadProcessMemory(hDebugProcess,(void *)lpData,&pThis,sizeof(LONG_PTR),&stAccBytes);
 
-    for(i=0;i<psi->pobj_ParentClass->iMemberNum;i++){
-        offset=psi->pobj_ParentClass->GetMemberOffset( psi->pobj_ParentClass->ppobj_Member[i]->name,&i2);
-
-        if(psi->pobj_ParentClass->ppobj_Member[i]->SubScripts[0]!=-1){
+    for(i=0;i<pUserProc->GetParentClassPtr()->iMemberNum;i++){
+        offset=pUserProc->GetParentClassPtr()->GetMemberOffset( pUserProc->GetParentClassPtr()->ppobj_Member[i]->name,&i2);
+
+        if(pUserProc->GetParentClassPtr()->ppobj_Member[i]->SubScripts[0]!=-1){
             //配列
             sprintf(temporary,"%s %s(&H%X)",
-                psi->pobj_ParentClass->ppobj_Member[i]->name,
+                pUserProc->GetParentClassPtr()->ppobj_Member[i]->name,
                 STRING_ARRAY,
                 (DWORD64)offset);
@@ -448 +434 @@
             VarList_Array(hVarTree_This,hParent,
                 pThis+offset,
-                psi->pobj_ParentClass->ppobj_Member[i]->TypeInfo.type,
-                psi->pobj_ParentClass->ppobj_Member[i]->SubScripts,
-                psi->pobj_ParentClass->ppobj_Member[i]->TypeInfo.u.lpIndex);
+                *pUserProc->GetParentClassPtr()->ppobj_Member[i],
+                pUserProc->GetParentClassPtr()->ppobj_Member[i]->SubScripts);
         }
         else{
             VarList_Insert(hVarTree_This,&tv,
-                psi->pobj_ParentClass->ppobj_Member[i]->name,
-                psi->pobj_ParentClass->ppobj_Member[i]->TypeInfo.type,
-                pThis+offset,
-                psi->pobj_ParentClass->ppobj_Member[i]->TypeInfo.u.lpIndex);
+                pUserProc->GetParentClassPtr()->ppobj_Member[i]->name,
+                *pUserProc->GetParentClassPtr()->ppobj_Member[i],
+                pThis+offset);
         }
     }
@@ -489 +473 @@
 
 void SetCalcToWatchList(HWND hListView,int iItem,char *buffer){
-    int i;
     char temporary[255],temp2[255];
 
@@ -498 +481 @@
 
     //カッコを相互チェック
-    if(!CheckParenthesis2(buffer)){
-        ListView_SetItemText(hListView,iItem,1,"式の解析に失敗");
+    if(!CheckParenthesis2(buffer)){ListView_SetItemText(hListView,iItem,1,"式の解析に失敗");
         return;
     }
@@ -505 +487 @@
     double dbl;
     _int64 i64data;
-    i=StaticCalculation(true, buffer,0,&i64data,0,1);
-    if(IsRealNumberType(i)){
-        memcpy(&dbl,&i64data,sizeof(double));
-    }
-
-    if(i==0){
+    Type resultType;
+    bool isMemoryAccessError;
+    if( !StaticCalculation(true, buffer,0,&i64data,resultType,1,&isMemoryAccessError) ){
         ListView_SetItemText(hListView,iItem,1,"式の解析に失敗");
     }
-    else if(i==-1){
+    else if(isMemoryAccessError){
         ListView_SetItemText(hListView,iItem,1,"アクセスできません");
     }
     else{
-        if(IsRealNumberType(i))
+        if(resultType.IsReal()){
+            memcpy(&dbl,&i64data,sizeof(double));
             sprintf(temporary,"%.15g (&H%08X)",dbl,(int)dbl);
-        else if(Is64Type(i)){
+        }
+        else if(resultType.Is64()){
             _i64toa(i64data,temporary,10);
             _i64toa(i64data,temp2,16);
@@ -586 +567 @@
 
     //プロシージャ コンボボックス
-    extern SubInfo **ppSubHash;
-    SubInfo *psi;
+    extern UserProc **ppSubHash;
+    UserProc *pUserProc;
     int sw;
     SendMessage(hProcCombo,CB_RESETCONTENT,0,0);
     for(i2=pobj_dti->iProcLevel;i2>=0;i2--){
         for(i3=0,sw=0;i3<MAX_HASH;i3++){
-            psi=ppSubHash[i3];
-            while(psi){
-                if(rva_to_real(psi->CompileAddress) <= pobj_dti->lplpObp[i2]  &&
-                    pobj_dti->lplpObp[i2] < rva_to_real(psi->EndOpAddr)){
-                    lstrcpy(temporary,psi->name);
-                    sw=1;
-                    break;
+            pUserProc=ppSubHash[i3];
+            while(pUserProc){
+                if(rva_to_real(pUserProc->beginOpAddress) <= pobj_dti->lplpObp[i2]  &&
+                    pobj_dti->lplpObp[i2] < rva_to_real(pUserProc->endOpAddress)){
+                        lstrcpy(temporary,pUserProc->GetName().c_str());
+                        sw=1;
+                        break;
                 }
-                psi=psi->pNextData;
+                pUserProc=pUserProc->pNextData;
             }
             if(sw) break;
         }
-        if(!psi){
+        if(!pUserProc){
             if(i2==0){
                 lstrcpy(temporary,"Global");
@@ -699 +680 @@
     ///////////////////////////////////////////////
 
-    extern VARIABLE *LocalVar;
-    extern int MaxLocalVarNum;
     int sw;
-
-    MaxLocalVarNum=0;
 
     i2=(int)SendDlgItemMessage(hDebugWnd,IDC_PROCCOMBO,CB_GETCURSEL,0,0);
@@ -709 +686 @@
 
     if(pobj_dti->lplpSpBase[i2]){
-        extern SubInfo **ppSubHash;
-        SubInfo *psi;
+        extern UserProc **ppSubHash;
+        UserProc *pUserProc;
         for(i3=0,sw=0;i3<MAX_HASH;i3++){
-            psi=ppSubHash[i3];
-            while(psi){
-                if(rva_to_real(psi->CompileAddress) <= pobj_dti->lplpObp[i2]  &&
-                    pobj_dti->lplpObp[i2] < rva_to_real(psi->EndOpAddr)){
+            pUserProc=ppSubHash[i3];
+            while(pUserProc){
+                if(rva_to_real(pUserProc->beginOpAddress) <= pobj_dti->lplpObp[i2]  &&
+                    pobj_dti->lplpObp[i2] < rva_to_real(pUserProc->endOpAddress)){
                     sw=1;
                     break;
                 }
 
-                psi=psi->pNextData;
+                pUserProc=pUserProc->pNextData;
             }
             if(sw) break;
@@ -726 +703 @@
 
 
-        if(psi){
-            LocalVar=psi->pVar;
-            MaxLocalVarNum=psi->VarNum;
-
-            pobj_CompilingClass=psi->pobj_ParentClass;
+        if(pUserProc){
+            pobj_CompilingClass=pUserProc->GetParentClassPtr();
+            UserProc::CompileStartForUserProc( pUserProc );
         }
     }