Changeset 64 in dev

Timestamp:

Mar 8, 2007, 2:49:34 AM (18 years ago)

Author:

dai_9181

Message:

すべてのオブジェクトを参照型に切り替えた。

Files:

• BasicCompiler32/CParameter.cpp (modified) (11 diffs)
• BasicCompiler32/Compile_Calc.cpp (modified) (7 diffs)
• BasicCompiler32/Compile_CallProc.cpp (modified) (7 diffs)
• BasicCompiler32/Compile_Func.cpp (modified) (3 diffs)
• BasicCompiler32/Compile_Object.cpp (modified) (5 diffs)
• BasicCompiler32/Compile_ProcOp.cpp (modified) (10 diffs)
• BasicCompiler32/Compile_Set_Var.cpp (modified) (4 diffs)
• BasicCompiler32/Compile_Statement.cpp (modified) (10 diffs)
• BasicCompiler32/Compile_Var.cpp (modified) (20 diffs)
• BasicCompiler32/MakePeHdr.cpp (modified) (4 diffs)
• BasicCompiler32/NumOpe.cpp (modified) (11 diffs)
• BasicCompiler32/NumOpe_Relation.cpp (modified) (1 diff)
• BasicCompiler32/Opcode.h (modified) (9 diffs)
• BasicCompiler32/OperatorProc.cpp (modified) (6 diffs)
• BasicCompiler32/VarList.cpp (modified) (3 diffs)
• BasicCompiler32/WatchList.cpp (modified) (9 diffs)
• BasicCompiler32/commandvalue.h (modified) (1 diff)
• BasicCompiler32/increment.cpp (modified) (2 diffs)
• BasicCompiler32/op32_main.cpp (modified) (4 diffs)
• BasicCompiler64/CParameter.cpp (modified) (12 diffs)
• BasicCompiler64/CommandValue.h (modified) (1 diff)
• BasicCompiler64/Compile_Calc.cpp (modified) (7 diffs)
• BasicCompiler64/Compile_CallProc.cpp (modified) (7 diffs)
• BasicCompiler64/Compile_Func.cpp (modified) (3 diffs)
• BasicCompiler64/Compile_Object.cpp (modified) (10 diffs)
• BasicCompiler64/Compile_ProcOp.cpp (modified) (15 diffs)
• BasicCompiler64/Compile_Set_Var.cpp (modified) (6 diffs)
• BasicCompiler64/Compile_Statement.cpp (modified) (11 diffs)
• BasicCompiler64/Compile_Var.cpp (modified) (25 diffs)
• BasicCompiler64/MakePeHdr.cpp (modified) (3 diffs)
• BasicCompiler64/NumOpe.cpp (modified) (9 diffs)
• BasicCompiler64/NumOpe_Arithmetic.cpp (modified) (13 diffs)
• BasicCompiler64/NumOpe_Logical.cpp (modified) (1 diff)
• BasicCompiler64/Opcode.h (modified) (12 diffs)
• BasicCompiler64/OperatorProc.cpp (modified) (10 diffs)
• BasicCompiler64/WatchList.cpp (modified) (9 diffs)
• BasicCompiler64/amd64_main.cpp (modified) (5 diffs)
• BasicCompiler64/stack_frame.cpp (modified) (1 diff)
• BasicCompiler64/varlist.cpp (modified) (3 diffs)
• BasicCompiler_Common/BasicFixed.h (modified) (4 diffs)
• BasicCompiler_Common/Class.cpp (modified) (15 diffs)
• BasicCompiler_Common/Class.h (modified) (3 diffs)
• BasicCompiler_Common/Compile.cpp (modified) (1 diff)
• BasicCompiler_Common/DebugMiddleFile.cpp (modified) (2 diffs)
• BasicCompiler_Common/Intermediate_Step1.cpp (modified) (1 diff)
• BasicCompiler_Common/Intermediate_Step2.cpp (modified) (1 diff)
• BasicCompiler_Common/LexicalScoping.cpp (modified) (4 diffs)
• BasicCompiler_Common/NumOpe_GetType.cpp (modified) (4 diffs)
• BasicCompiler_Common/Overload.cpp (modified) (2 diffs)
• BasicCompiler_Common/Parameter.cpp (modified) (9 diffs)
• BasicCompiler_Common/Subroutine.cpp (modified) (10 diffs)
• BasicCompiler_Common/Variable.cpp (modified) (25 diffs)
• BasicCompiler_Common/Variable.h (modified) (1 diff)
• BasicCompiler_Common/calculation.cpp (modified) (6 diffs)
• BasicCompiler_Common/common.h (modified) (2 diffs)
• BasicCompiler_Common/error.cpp (modified) (3 diffs)
• ProjectEditor/WindowControl.cpp (modified) (1 diff)

BasicCompiler32/CParameter.cpp

@@ -2 +2 @@
 #include "opcode.h"
 
-void CParameter::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
+int CParameter::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
     ///////////////////////////////////////////////////////
     // 一時オブジェクトをあらかじめスタックに積んでおく
     ///////////////////////////////////////////////////////
-    //TODO: 64ビットコードのままなので、32ビット用に書き換える
 
     useTempObject = false;
 
-    //一時オブジェクトの数
+    //一時参照の数
     nCountOfTempObjects = 0;
 
@@ -64 +63 @@
                 int type = NumOpe( Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
                 //↑ここでスタックに積む
+
+                nCountOfTempObjects++;
+
+                if( type == DEF_OBJECT ){
+                    //一時参照を作成
+
+                    //push esp
+                    op_push( REG_ESP );
+
+                    nCountOfTempObjects++;
+                }
 
                 bool result = CheckDifferentType(
@@ -80 +90 @@
                     types[i2].u.lpIndex = lpVarIndex;
                 }
-
-                nCountOfTempObjects++;
-            }
-        }
-    }
+            }
+        }
+    }
+
+    return nCountOfTempObjects * PTR_SIZE;
 }
+
 void CParameter::DeleteTempParameters(){
     ///////////////////////////////////////////////////////
     // 一時オブジェクトを破棄
     ///////////////////////////////////////////////////////
-    //TODO: 64ビットコードのままなので、32ビット用に書き換える
-
     if( !useTempObject ) return;
 
     for(int i2=ParmsNum-1;i2>=0;i2--){
         if( useTempParameters[i2] ){
-            //スタックフレームから取得
-            // ※関数呼び出し時も値が普遍のebxを利用する
-            op_pop(REG_EBX);
-
-
-            ///////////////////////////
-            // デストラクタを呼び出す
-            ///////////////////////////
-
-            //push ebx
-            op_push(REG_EBX);
-
-            //call destructor
-            CMethod *method = types[i2].u.pobj_Class->GetDestructorMethod();
-            if( method ){
-                op_call( method->psi );
-            }
-
-
-            /////////////////////////
-            // メモリを解放する
-            /////////////////////////
-
-            //push ebx
-            op_push(REG_EBX);
-
-            //call free
-            extern SUBINFO *pSub_free;
-            op_call(pSub_free);
+            if( types[i2].type == DEF_STRUCT ){
+                // 構造体の一時メモリ
+
+                //メモリを解放する
+
+                //call free
+                extern SUBINFO *pSub_free;
+                op_call(pSub_free);
+            }
+            else if( types[i2].type == DEF_OBJECT ){
+                op_pop( REG_NON );
+                op_pop( REG_NON );
+            }
+            else{
+                SetError(300,NULL,cp);
+            }
+
         }
     }
 }
 
-void CParameter::SetObjectParameter(CClass *pobj_Class,LPSTR Parameter){
+void CParameter::SetStructParameter(CClass *pobj_Class,LPSTR Parameter){
     int object_size = pobj_Class->GetSize();
 
@@ -143 +140 @@
 
 
-    TYPEINFO BaseType={DEF_OBJECT,(LONG_PTR)pobj_Class};
+    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){
@@ -185 +184 @@
         }
     }
-    else{
+    else{*/
+
+
         //push eax
         op_push(REG_EAX);
 
-
+/*
+            TODO: 消す
             if( pobj_Class->GetConstructorMethod() ){
                 ////////////////////////////////
@@ -201 +203 @@
                 op_call(pobj_Class->GetConstructorMethod()->psi);
             }
-
-
-            TYPEINFO CalcType;
+*/
+
             BOOL bUseHeap;
-            CalcType.type=NumOpe(Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
-
-
-
-        SetObjectVariable((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,bUseHeap);
-    }
+            CalcType.type=NumOpe(Parameter,DEF_STRUCT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
+
+
+
+        SetStructVariable((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,bUseHeap);
+    //}
 }
 
@@ -280 +281 @@
             }
 
-            if(DummyTypeInfo.type==DEF_OBJECT){
-                SetObjectParameter(DummyTypeInfo.u.pobj_Class,Parms[i2]);
+            if(DummyTypeInfo.type==DEF_STRUCT){
+                SetStructParameter(DummyTypeInfo.u.pobj_Class,Parms[i2]);
                 goto next;
             }
@@ -299 +300 @@
 
             if(CalcType==DEF_OBJECT){
-                //キャスト演算子のオーバーロードに対応する
-                CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
+                if( DummyTypeInfo.type != DEF_OBJECT
+                    ||
+                    DummyTypeInfo.type == DEF_OBJECT &&
+                    !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpCalcIndex ) ){
+                        //キャスト演算子のオーバーロードに対応する
+                        CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
+                }
             }
 
@@ -328 +334 @@
                 ParmSize+=sizeof(long)*2;
             }
-            else if(DummyTypeInfo.type==DEF_LONG||DummyTypeInfo.type==DEF_DWORD||
+            else if(DummyTypeInfo.type==DEF_LONG||DummyTypeInfo.type==DEF_DWORD||DummyTypeInfo.type==DEF_OBJECT||DummyTypeInfo.type==DEF_STRUCT||
                 (IsPtrType(DummyTypeInfo.type)/*&&DummyTypeInfo.type!=DEF_PTR_VOID&&DummyTypeInfo.type!=DEF_PTR_BYTE*/)){
                 ChangeTypeToLong(CalcType);
@@ -354 +360 @@
             }
             else{
-                //変数のアドレスを取得
-                int VarType;
-                LONG_PTR lpVarIndex;
-                if(GetVarOffset(
-                    false,
-                    false,
-                    Parms[i2],
-                    &VarType,
-                    &RelativeVar,
-                    &lpVarIndex)){
-                        if(DummyTypeInfo.type!=DEF_ANY){
-                            //型チェックを行う
-                            if(DummyTypeInfo.type==VarType){
-                                if(DummyTypeInfo.type==DEF_OBJECT){
-                                    if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
-                                        SetError(11,Parms[i2],cp);
-                                    }
-                                }
-                            }
-                            else if((VarType&FLAG_PTR)&&((int)(VarType^FLAG_PTR)==DummyTypeInfo.type)){
-                                //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
-                            }
-                            else{
-                                SetError(11,Parms[i2],cp);
-                            }
-                        }
-
-                        //変数アドレスをレジスタにセット
-                        SetVarPtrToEax(&RelativeVar);
-
-                        //push eax
-                        op_push(REG_EAX);
-                }
-                else{
+                if( useTempParameters[i2] ){
                     //一時オブジェクトをコピー
+
+                    if( types[i2].type == DEF_OBJECT ){
+                        // 一時参照のための領域を考慮する
+                        nCountOfNowTempObjects++;
+                    }
+
+                    nCountOfNowTempObjects++;
 
                     //mov eax, dword ptr[esp+offset]
@@ -395 +375 @@
                         REG_EAX,
                         REG_ESP,
-                        ( ( ParmsNum - i2 - 1 ) + ( nCountOfTempObjects - nCountOfNowTempObjects - 1 ) ) * PTR_SIZE,
+                        ( ( ParmsNum - i2 - 1 ) + ( nCountOfTempObjects - nCountOfNowTempObjects ) ) * PTR_SIZE,
                         MOD_BASE_DISP32 );
-
-                    nCountOfNowTempObjects++;
 
                     //push eax
                     op_push(REG_EAX);
-
-                    //VarType = NumOpe( Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
+                }
+                else{
+                    //変数のアドレスを取得
+                    int VarType;
+                    LONG_PTR lpVarIndex;
+                    if(GetVarOffset(
+                        false,
+                        false,
+                        Parms[i2],
+                        &VarType,
+                        &RelativeVar,
+                        &lpVarIndex)){
+                            if(DummyTypeInfo.type!=DEF_ANY){
+                                //型チェックを行う
+                                if(DummyTypeInfo.type==VarType){
+                                    if(DummyTypeInfo.type==DEF_OBJECT){
+                                        if( !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpVarIndex ) ){
+                                            SetError(11,Parms[i2],cp);
+                                        }
+                                    }
+                                    else if(DummyTypeInfo.type==DEF_STRUCT){
+                                        if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
+                                            SetError(11,Parms[i2],cp);
+                                        }
+                                    }
+                                }
+                                else if((VarType&FLAG_PTR)&&((int)(VarType^FLAG_PTR)==DummyTypeInfo.type)){
+                                    //仮引数がポインタ参照で、実引数が配列の先頭ポインタのとき
+                                }
+                                else{
+                                    SetError(11,Parms[i2],cp);
+                                }
+                            }
+
+                            //変数アドレスをレジスタにセット
+                            SetVarPtrToEax(&RelativeVar);
+
+                            //push eax
+                            op_push(REG_EAX);
+                    }
                 }
             }

BasicCompiler32/Compile_Calc.cpp

@@ -364 +364 @@
     //push eax
     op_push(REG_EAX);
+}
+
+
+
+
+
+
+
+
+
+void RestoreDefaultRegisterFromStackMemory( int type ){
+    //現在のスタックの内容を実数レジスタに保存する
+    //NumOpeの直後専用
+    if(type==DEF_DOUBLE){
+        //fld qword ptr[esp]
+        op_fld_ptr_esp(DEF_DOUBLE);
+
+        //add esp,8
+        op_add_esp(8);
+    }
+    else if(type==DEF_SINGLE){
+        //fld dword ptr[esp]
+        op_fld_ptr_esp(DEF_SINGLE);
+
+        //add esp,4
+        op_add_esp(4);
+    }
+    else if( Is64Type( type ) ){
+        //pop eax
+        op_pop(REG_EAX);
+
+        //pop edx
+        op_pop(REG_EDX);
+    }
+    else{
+        //pop eax
+        op_pop(REG_EAX);
+    }
+}
+
+void SetVariableFromEax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
+    /////////////////////////////////////////////////
+    // eaxの内容を変数にコピーするコードを抽出
+    /////////////////////////////////////////////////
+
+    if(VarType==DEF_BOOLEAN){
+        //bool
+        SetBooleanVariable(CalcType,pRelativeVar);
+    }
+    else if( IsRealNumberType( VarType ) ){
+        // Double/Single型変数へレジスタの値を代入
+        SetRealVariable(VarType, CalcType, pRelativeVar);
+    }
+    else if( IsWholeNumberType( VarType ) || VarType == DEF_OBJECT ){
+        int typeSize = GetTypeSize( VarType, -1 );
+
+        //整数変数へraxの値を格納する
+        SetWholeVariable( typeSize, CalcType, pRelativeVar );
+    }
+    else{
+        SetError(300,NULL,cp);
+    }
 }
 
@@ -485 +547 @@
     }
 
+
+    if( lstrcmpi( variable, "This" ) == 0 ){
+        SetError(133,NULL,cp);
+        return;
+    }
+
+
     ////////////////////////////////////////
     // 変数のタイプ型を識別して、演算を行う
@@ -511 +580 @@
     else ProcPtr_BaseIndex=-1;
 
-    if(VarType==DEF_OBJECT){
-        //代入演算のオーバーロード オペレータに備える
+    if(VarType==DEF_STRUCT){
+        //代入コピーに備える
 
         //変数アドレスを取得
@@ -544 +613 @@
     }
 
-    if(VarType==DEF_OBJECT){
+    if(VarType==DEF_STRUCT){
         //オブジェクトインスタンスへの代入
-        SetObjectVariable(lpVarIndex,CalcType,lpCalcIndex,bCalcUseHeap);
+        SetStructVariable(lpVarIndex,CalcType,lpCalcIndex,bCalcUseHeap);
         return;
     }
 
-    if(CalcType==DEF_OBJECT){
+    if(CalcType==DEF_OBJECT && (CalcType!=VarType || lpCalcIndex!=lpVarIndex) ){
         //キャスト演算子のオーバーロードに対応する
         CallCastOperatorProc(CalcType,lpCalcIndex,bCalcUseHeap,VarType,lpVarIndex);
@@ -568 +637 @@
     /////////////////////////////////////////////////
 
+    //eax、edx:eax、またはst(0)にスタック上のデータを取り出す
+    RestoreDefaultRegisterFromStackMemory( CalcType );
+
+    SetVariableFromEax( VarType, CalcType, &VarRelativeVar );
+/*
+    TODO: 消す
     if(VarType==DEF_BOOLEAN){
         //bool
@@ -598 +673 @@
         //Single型変数へスタックの内容を格納する
         SetSingleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset);
-    }
-}
-
+    }*/
+}
+
+
+// TODO: 消す
+/*
 void SetRefVariable( const char *varname, const char *expression ){
     ////////////////////////////////////////
@@ -721 +799 @@
     }
 }
+*/

BasicCompiler32/Compile_CallProc.cpp

@@ -94 +94 @@
 }
 
-void Opcode_CallProc(char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType){
+void Opcode_CallProc(const char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType){
     int i2;
 
@@ -206 +206 @@
 
     ///////////////////////////////////////////////////////////////
-    // _System_LocalThis、_System_ReturnObjectのダミーをセット
+    // _System_LocalThisのダミーをセット
     ///////////////////////////////////////////////////////////////
 
@@ -215 +215 @@
     }
 
-    if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false ){
-        //_System_ReturnObject（第一または第二パラメータのダミーを作成）
-        sprintf(temporary+lstrlen(temporary),"%c%c0,",1,ESC_BYVAL);
-    }
-
     if(Parameter[0]=='\0'&&temporary[0])
         temporary[lstrlen(temporary)-1]=0;
@@ -246 +241 @@
 
     //一時オブジェクトを生成
-    pobj_parameter->NewTempParameters( psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum );
+    int tempSize = pobj_parameter->NewTempParameters( psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum );
 
     //レジスタ、スタックフレームにセット
@@ -252 +247 @@
     ParmSize=pobj_parameter->SetParameter(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum);
 
-
-    if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
+    if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
         //////////////////////////////////////////////////////
-        // 戻り値にオブジェクト インスタンスを持つ場合
-        // ※ByRef _System_ReturnObject パラメータをセット
+        // 戻り値に構造体インスタンスを持つ場合
+        // ※ByRef _System_ReturnValue パラメータをセット
         //////////////////////////////////////////////////////
 
@@ -294 +288 @@
                 SetVarPtrToEax(&RelativeVar);
 
-                //参照タイプが "->" の場合
-                if(RefType==DEF_PTR_OBJECT){
-                    //mov eax,dword ptr[eax]
-                    OpBuffer[obp++]=(char)0x8B;
-                    OpBuffer[obp++]=(char)0x00;
-                }
-
-                //mov ecx,eax
-                OpBuffer[obp++]=(char)0x8B;
-                OpBuffer[obp++]=(char)0xC8;
+                // 参照を実体ポインタにする
+                op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
             }
         }
@@ -310 +296 @@
             if(dwFlags&PROCFLAG_NEW){
                 //New演算子によるコンストラクタ呼び出しの場合
+
                 //mov ecx,dword ptr[esp+ParmSize]
-                OpBuffer[obp++]=(char)0x8B;
-                OpBuffer[obp++]=(char)0x8C;
-                OpBuffer[obp++]=(char)0x24;
-                *((long *)(OpBuffer+obp))=ParmSize;
-                obp+=sizeof(long);
+                op_mov_RM( sizeof(long), REG_ECX, REG_ESP, ParmSize + tempSize, MOD_BASE_DISP32 );
             }
             else{

BasicCompiler32/Compile_Func.cpp

@@ -208 +208 @@
 
     TYPEINFO TypeInfo={type,lpIndex};
-    if(IsStringObjectType(&TypeInfo)){
+    if(IsStringObjectType(TypeInfo)){
         //Stringオブジェクトの場合
         char temporary[VN_SIZE];
@@ -346 +346 @@
 }
 void Opcode_Func_SizeOf(const char *Parameter){
-    int type,size;
     LONG_PTR lpIndex;
-
-    type=GetTypeFixed(Parameter,&lpIndex);
-    if(type==-1){
-        extern int cp;
-        SetError(3,Parameter,cp);
-        return;
-    }
-    size=GetTypeSize(type,lpIndex);
+    int type = GetTypeFixed(Parameter,&lpIndex);
+
+    int size;
+    if( type == DEF_OBJECT ){
+        CClass *pClass = (CClass *)lpIndex;
+        size = pClass->GetSize();
+    }
+    else{
+        size=GetTypeSize(type,lpIndex);
+    }
 
     //mov eax,size
-    OpBuffer[obp++]=(char)0xB8;
-    *((long *)(OpBuffer+obp))=size;
-    obp+=sizeof(long);
+    op_mov_RV( REG_EAX, size );
 }
 void Opcode_Func_VarPtr( const char *Parameter, TYPEINFO &ReturnTypeInfo ){
@@ -368 +367 @@
     if(!GetVarOffsetReadOnly( Parameter, &ReturnTypeInfo.type, &RelativeVar, &ReturnTypeInfo.u.lpIndex )) return;
 
+    int beforeType = ReturnTypeInfo.type;
+
     PTR_LEVEL_UP( ReturnTypeInfo.type );
 
     SetVarPtrToEax(&RelativeVar);
+
+    if( beforeType == DEF_OBJECT && lstrcmpi( Parameter, "This" ) != 0 ){
+        //参照をオブジェクトポインタに変更
+
+        //mov eax,dword ptr[eax]
+        op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
+    }
 }
 void Opcode_Func_GetPtrData(const char *Parameter,const int type){

BasicCompiler32/Compile_Object.cpp

@@ -2 +2 @@
 #include "opcode.h"
 
-void _call_constructor(CClass *pobj_c,char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
+void _call_constructor(CClass *pobj_c, const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
     ////////////////////////////
     // コンストラクタの呼び出し
@@ -74 +74 @@
     }
 }
-int Operator_New(const char *Parameter,LONG_PTR *plpIndex){
-    char TypeName[VN_SIZE],CreateParameter[VN_SIZE],ObjectSize[VN_SIZE];
+void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter, const TYPEINFO &baseTypeInfo ){
+    int typeSize = classObj.GetSize();
+
+    if(classObj.IsAbstract()){
+        //抽象クラスだったとき
+        SetError(125,classObj.name,cp);
+    }
+
+    if(objectSizeStr[0]){
+        int type = NumOpe(objectSizeStr,0,0,0);
+        ChangeTypeToLong(type);
+
+        //pop eax
+        op_pop(REG_EAX);
+
+        //※添え字上限値であることを考慮
+        //add eax,1
+        OpBuffer[obp++]=(char)0x83;
+        OpBuffer[obp++]=(char)0xC0;
+        OpBuffer[obp++]=(char)0x01;
+
+        //オブジェクトの個数をebxに一時保持
+        //※ebxは関数が呼ばれても不変
+        //mov ebx,eax
+        OpBuffer[obp++]=(char)0x8B;
+        OpBuffer[obp++]=(char)0xD8;
+
+        //imul eax,size
+        OpBuffer[obp++]=(char)0x69;
+        OpBuffer[obp++]=(char)0xC0;
+        *((long *)(OpBuffer+obp))=typeSize;
+        obp+=sizeof(long);
+
+        //add eax,sizeof(DWORD)*2
+        OpBuffer[obp++]=(char)0x05;
+        *((long *)(OpBuffer+obp))=sizeof(DWORD)*3;
+        obp+=sizeof(long);
+
+        //push eax
+        op_push(REG_EAX);
+    }
+    else{
+        //オブジェクトの個数をebxに一時保持
+        //※ebxは関数が呼ばれても不変
+        //mov ebx,1
+        OpBuffer[obp++]=(char)0xBB;
+        *((long *)(OpBuffer+obp))=1;
+        obp+=sizeof(long);
+
+        //push size
+        OpBuffer[obp++]=(char)0x68;
+        *((long *)(OpBuffer+obp))=typeSize+sizeof(DWORD)*3;
+        obp+=sizeof(long);
+    }
+
+    if( baseTypeInfo.type == DEF_OBJECT ){
+        //DeleteはGCで処理
+
+        //call _System_GC_malloc_ForObject
+        extern SUBINFO *pSub_System_GC_malloc_ForObject;
+        op_call(pSub_System_GC_malloc_ForObject);
+    }
+    else{
+        //明示的なDeleteが必要
+
+        //call _System_GC_malloc_ForObjectPtr
+        extern SUBINFO *pSub_System_GC_malloc_ForObjectPtr;
+        op_call(pSub_System_GC_malloc_ForObjectPtr);
+    }
+
+
+    /*
+    確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
+    pPtr-=sizeof(DWORD)*3
+    pPtr[0]=オブジェクトの個数
+    pPtr[1]=オブジェクトのサイズ
+    pPtr[2]=デストラクタの関数ポインタ
+    */
+
+
+    //mov dword ptr[eax],ebx（オブジェクトの個数）
+    OpBuffer[obp++]=(char)0x89;
+    OpBuffer[obp++]=(char)0x18;
+
+    //add eax,sizeof(DWORD)
+    OpBuffer[obp++]=(char)0x05;
+    *((long *)(OpBuffer+obp))=sizeof(DWORD);
+    obp+=sizeof(long);
+
+
+    //mov ecx,TypeSize
+    OpBuffer[obp++]=(char)0xB9;
+    *((long *)(OpBuffer+obp))=typeSize;
+    obp+=sizeof(long);
+
+    //mov dword ptr[eax],ecx
+    OpBuffer[obp++]=(char)0x89;
+    OpBuffer[obp++]=(char)0x08;
+
+    //add eax,sizeof(DWORD)
+    OpBuffer[obp++]=(char)0x05;
+    *((long *)(OpBuffer+obp))=sizeof(DWORD);
+    obp+=sizeof(long);
+
+
+    CMethod *method = classObj.GetDestructorMethod();
+    if( method == NULL ) return;
+
+    //mov ecx,DestructorProcAddr
+    OpBuffer[obp++]=(char)0xB9;
+    pobj_SubAddrSchedule->add(method->psi,0);
+    method->psi->bUse=1;
+    obp+=sizeof(long);
+
+    //mov dword ptr[eax],ecx
+    OpBuffer[obp++]=(char)0x89;
+    OpBuffer[obp++]=(char)0x08;
+
+    //add eax,sizeof(DWORD)
+    OpBuffer[obp++]=(char)0x05;
+    *((long *)(OpBuffer+obp))=sizeof(DWORD);
+    obp+=sizeof(long);
+
+
+    // ※ここでプッシュされた値はNew演算子の戻り値となる
+    //push eax
+    op_push(REG_EAX);
+
+
+    /////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////
+    // コンストラクタの呼び出し
+    ////////////////////////////
+
+    BOOL bSomeObjects;
+    if(objectSizeStr[0]) bSomeObjects=1;
+    else bSomeObjects=0;
+    _call_constructor(&classObj,parameter,typeSize,bSomeObjects);
+}
+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;
 
@@ -81 +221 @@
 
     if(Parameter[0]=='['){
-        i=GetStringInBracket(ObjectSize,Parameter);
-
-        SlideString(ObjectSize+1,-1);
-        ObjectSize[i-2]=0;
-    }
-    else ObjectSize[0]=0;
+        i=GetStringInBracket(objectSizeStr,Parameter);
+
+        SlideString(objectSizeStr+1,-1);
+        objectSizeStr[i-2]=0;
+    }
+    else objectSizeStr[0]=0;
 
     for(i2=0;;i++,i2++){
@@ -129 +269 @@
     pobj_c=(CClass *)*plpIndex;
 
-    if(pobj_c->IsAbstract()){
-        //抽象クラスだったとき
-        SetError(125,pobj_c->name,cp);
-    }
-
-    if(ObjectSize[0]){
-        i2=NumOpe(ObjectSize,0,0,0);
-        ChangeTypeToLong(i2);
-
-        //pop eax
-        op_pop(REG_EAX);
-
-        //※添え字上限値であることを考慮
-        //add eax,1
-        OpBuffer[obp++]=(char)0x83;
-        OpBuffer[obp++]=(char)0xC0;
-        OpBuffer[obp++]=(char)0x01;
-
-        //オブジェクトの個数をebxに一時保持
-        //※ebxは関数が呼ばれても不変
-        //mov ebx,eax
-        OpBuffer[obp++]=(char)0x8B;
-        OpBuffer[obp++]=(char)0xD8;
-
-        //imul eax,size
-        OpBuffer[obp++]=(char)0x69;
-        OpBuffer[obp++]=(char)0xC0;
-        *((long *)(OpBuffer+obp))=TypeSize;
-        obp+=sizeof(long);
-
-        //add eax,sizeof(DWORD)*2
-        OpBuffer[obp++]=(char)0x05;
-        *((long *)(OpBuffer+obp))=sizeof(DWORD)*3;
-        obp+=sizeof(long);
-
-        //push eax
-        op_push(REG_EAX);
-    }
-    else{
-        //オブジェクトの個数をebxに一時保持
-        //※ebxは関数が呼ばれても不変
-        //mov ebx,1
-        OpBuffer[obp++]=(char)0xBB;
-        *((long *)(OpBuffer+obp))=1;
-        obp+=sizeof(long);
-
-        //push size
-        OpBuffer[obp++]=(char)0x68;
-        *((long *)(OpBuffer+obp))=TypeSize+sizeof(DWORD)*3;
-        obp+=sizeof(long);
-    }
-
-    //call calloc
-    extern SUBINFO *pSub_calloc;
-    op_call(pSub_calloc);
-
-
-    /*
-    確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
-    pPtr-=sizeof(DWORD)*3
-    pPtr[0]=オブジェクトの個数
-    pPtr[1]=オブジェクトのサイズ
-    pPtr[2]=デストラクタの関数ポインタ
-    */
-
-
-    //mov dword ptr[eax],ebx（オブジェクトの個数）
-    OpBuffer[obp++]=(char)0x89;
-    OpBuffer[obp++]=(char)0x18;
-
-    //add eax,sizeof(DWORD)
-    OpBuffer[obp++]=(char)0x05;
-    *((long *)(OpBuffer+obp))=sizeof(DWORD);
-    obp+=sizeof(long);
-
-
-    //mov ecx,TypeSize
-    OpBuffer[obp++]=(char)0xB9;
-    *((long *)(OpBuffer+obp))=TypeSize;
-    obp+=sizeof(long);
-
-    //mov dword ptr[eax],ecx
-    OpBuffer[obp++]=(char)0x89;
-    OpBuffer[obp++]=(char)0x08;
-
-    //add eax,sizeof(DWORD)
-    OpBuffer[obp++]=(char)0x05;
-    *((long *)(OpBuffer+obp))=sizeof(DWORD);
-    obp+=sizeof(long);
-
-
-    CMethod *method = pobj_c->GetDestructorMethod();
-    if( method == NULL ) return 0;
-
-    //mov ecx,DestructorProcAddr
-    OpBuffer[obp++]=(char)0xB9;
-    pobj_SubAddrSchedule->add(method->psi,0);
-    method->psi->bUse=1;
-    obp+=sizeof(long);
-
-    //mov dword ptr[eax],ecx
-    OpBuffer[obp++]=(char)0x89;
-    OpBuffer[obp++]=(char)0x08;
-
-    //add eax,sizeof(DWORD)
-    OpBuffer[obp++]=(char)0x05;
-    *((long *)(OpBuffer+obp))=sizeof(DWORD);
-    obp+=sizeof(long);
-
-
-    // ※ここでプッシュされた値はNew演算子の戻り値となる
-    //push eax
-    op_push(REG_EAX);
-
-
-    /////////////////////////////////////////////////////////////////////
-
-    ////////////////////////////
-    // コンストラクタの呼び出し
-    ////////////////////////////
-
-    BOOL bSomeObjects;
-    if(ObjectSize[0]) bSomeObjects=1;
-    else bSomeObjects=0;
-    _call_constructor(pobj_c,CreateParameter,TypeSize,bSomeObjects);
-
+    Operator_New( *pobj_c, objectSizeStr, CreateParameter, baseTypeInfo );
+
+    if( baseTypeInfo.type == DEF_OBJECT ){
+        return DEF_OBJECT;
+    }
     return DEF_PTR_OBJECT;
 }
 
-void OpcodeDelete(char *Parameter){
+void OpcodeDelete(const char *Parameter, bool isSweeping){
     int type;
 
@@ -355 +374 @@
     //////////////////////////////////////////
 
-    //call free
-    extern SUBINFO *pSub_free;
-    op_call(pSub_free);
+    if( isSweeping ){
+        //call _System_GC_free_for_SweepingDelete
+        extern SUBINFO *pSub_System_GC_free_for_SweepingDelete;
+        op_call(pSub_System_GC_free_for_SweepingDelete);
+    }
+    else{
+        //call free
+        extern SUBINFO *pSub_free;
+        op_call(pSub_free);
+    }
 }

BasicCompiler32/Compile_ProcOp.cpp

@@ -293 +293 @@
 
         LocalVar[MaxLocalVarNum].type=psi->pRealParmInfo[i3].type;
-        if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT){
-            if(psi->bExport)
-                SetError(24,NULL,cp);
+        if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT
+            ||LocalVar[MaxLocalVarNum].type==DEF_STRUCT){
+                if(psi->bExport)
+                    SetError(24,NULL,cp);
         }
 
         LocalVar[MaxLocalVarNum].u.index=psi->pRealParmInfo[i3].u.index;
 
-        if(psi->pRealParmInfo[i3].bByVal&&psi->pRealParmInfo[i3].type==DEF_OBJECT){
-            //実態オブジェクトのByValパラメータ
+        if(psi->pRealParmInfo[i3].bByVal&&psi->pRealParmInfo[i3].type==DEF_STRUCT){
+            //構造体のByValパラメータ
             LocalVar[MaxLocalVarNum].fRef=REF_PARAMETER | OBJECT_PARAMETER;
             VarSize=PTR_SIZE;
@@ -370 +371 @@
     OpBuffer[obp++]=(char)0x57;
 
-    if(psi->ReturnType!=-1){
+    if(psi->ReturnType!=DEF_NON){
         //戻り値が存在するとき
 
@@ -377 +378 @@
         else temp=psi->name;
 
-        if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
-            //戻り値用オブジェクトのコンストラクタを呼び出す
-            if( psi->u.Return_pobj_c->GetConstructorMethod() ){
-                sprintf(temporary,"%s.%s()",temp,psi->u.Return_pobj_c->name);
-                OpcodeOthers(temporary);
-            }
+        if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
+            //戻り値用の構造体（値型）はパラメータで引き渡される
         }
         else{
@@ -517 +514 @@
             for(i3=0;i3<pobj_CompilingClass->iMemberNum;i3++){
                 CMember *pMember = pobj_CompilingClass->ppobj_Member[i3];
-                int MemberTypeSize=
-                    GetTypeSize(pMember->TypeInfo.type,
-                        pMember->TypeInfo.u.lpIndex);
-
-                int MemberObjectNum=
-                    JumpSubScripts(pMember->SubScripts);
-
-                int offset = pobj_CompilingClass->GetMemberOffset( pMember->name, NULL );
-
-                if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef() == false){
-                    CMethod *method = pMember->TypeInfo.u.pobj_Class->GetConstructorMethod();
-                    if( method ){
-                        if( method->psi->RealParmNum == 1 ){    //Thisポインタを第一引数に持ち合わせるため、引数なしの場合はこの値が1になる
-                            for(i4=0;i4<MemberObjectNum;i4++){
-                                //Thisポインタをecxにコピー
-                                SetThisPtrToReg(REG_ECX);
-
-                                //add ecx,offset
-                                OpBuffer[obp++]=(char)0x81;
-                                OpBuffer[obp++]=(char)0xC1;
-                                *((long *)(OpBuffer+obp))=offset+i4*MemberTypeSize;
-                                obp+=sizeof(long);
-
-                                //push ecx
-                                op_push(REG_ECX);
-
-                                //call constructor
-                                op_call( method->psi );
-                            }
-                        }
-                    }
+                if(pMember->TypeInfo.type==DEF_OBJECT){
+                    // オブジェクトメンバを発見したとき
+
+                    sprintf(temporary, "This.%s=%c%c%s()",
+                        pMember->name,
+                        1, ESC_NEW,
+                        pMember->TypeInfo.u.pobj_Class->name );
+                    OpcodeCalc( temporary );
                 }
             }
@@ -619 +593 @@
             }
 
-            //実体クラスを持つメンバのデストラクタを呼び出す
+            //実体クラスを持つメンバのデストラクタ呼び出しはGCに任せる
+            /*
             //※コンストラクタと逆順序で呼び出す
             int offset;
@@ -658 +633 @@
                     }
                 }
-            }
+            }*/
         }
     }
@@ -706 +681 @@
 
     if(bDebugCompile&&bDebugSupportProc==0){
-        *((long *)(OpBuffer+EspOffsetSchedule))=AllLocalVarSize-BaseOffset;
+        *((long *)(OpBuffer+EspOffsetSchedule))=AllLocalVarSize-BaseOffset-sizeof(long);
 
         //call _DebugSys_EndProc
@@ -713 +688 @@
     }
 
-    if(psi->ReturnType!=-1){
+    if(psi->ReturnType!=DEF_NON){
         //戻り値をeax、edxに設定
         RELATIVE_VAR RelativeVar;
@@ -726 +701 @@
         i3=psi->ReturnType;
 
-        if(i3==DEF_OBJECT){
+        if(i3==DEF_OBJECT || i3==DEF_STRUCT){
             SetVarPtrToEax(&RelativeVar);
+            if( i3==DEF_OBJECT ){
+                //mov eax,dword ptr[eax]
+                op_mov_RM( sizeof(long), REG_EAX, REG_EAX, 0, MOD_BASE );
+            }
         }
         else if(i3==DEF_DOUBLE){
@@ -818 +797 @@
     op_pop(REG_EBX);
 
+    if(bDebugCompile){
+        //cmp esp,ebp
+        op_cmp_RR( REG_ESP, REG_EBP );
+
+        //jz 6（次のcallとbreakpointを飛び越す）
+        OpBuffer[obp++]=(char)0x74;
+        OpBuffer[obp++]=(char)0x06;
+
+        //call _esp_error
+        extern SUBINFO *pSub_esp_error;
+        op_call( pSub_esp_error );
+
+        breakpoint;
+    }
+
     //mov esp,ebp
     OpBuffer[obp++]=(char)0x8B;

BasicCompiler32/Compile_Set_Var.cpp

@@ -7 +7 @@
 }
 
-void SetObjectVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap){
+void SetStructVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap){
+/*
+    TODO: 消す
     ///////////////////////////////////////////////////////////////////
     // オペレータ '=' のオーバーロード関数を呼ぶ
@@ -32 +34 @@
         //成功したとき、またはエラーが発行されたとき
         return;
-    }
-
-
-    if( CalcType == DEF_OBJECT ){
+    }*/
+
+
+    if( CalcType == DEF_STRUCT ){
         CClass *pVarClass = (CClass *)lpVarIndex;
         CClass *pCalcClass = (CClass *)lpCalcIndex;
 
 
-        if( pVarClass->IsEquals( pCalcClass )           //等しい
-            || pVarClass->IsSubClass( pCalcClass ) ){   //派生・継承関係
+        if( pVarClass->IsEquals( pCalcClass ) ){        //等しい
 
                 //双方のオブジェクト型が一致、または派生・継承関係にあるとき
@@ -81 +82 @@
 }
 
+
+void SetRealVariable(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
+    if( !IsRealNumberType( CalcType ) ){
+        // 実数へ変換
+        // 64bit edx:eax -> st(0)
+        // 32bit     eax -> st(0)
+
+        if( Is64Type( CalcType ) ){
+            //64ビット整数型
+
+            //push edx
+            op_push( REG_EDX );
+
+            //push eax
+            op_push( REG_EAX );
+
+            //fild qword ptr[esp]
+            op_fld_ptr_esp(DEF_INT64);
+
+            //pop
+            op_pop( REG_NON );
+
+            //pop
+            op_pop( REG_NON );
+        }
+        else{
+            //push eax
+            op_push( REG_EAX );
+
+            //fild qword ptr[esp]
+            op_fld_ptr_esp(DEF_LONG);
+
+            //pop
+            op_pop( REG_NON );
+        }
+    }
+
+    if(pRelativeVar->dwKind==VAR_GLOBAL){
+        if(pRelativeVar->bOffsetOffset){
+            //fstp ptr[ecx+offset]
+            op_fstp_base_offset(VarType,REG_ECX,(int)pRelativeVar->offset);
+            obp-=sizeof(long);
+            pobj_GlobalVarSchedule->add();
+            obp+=sizeof(long);
+        }
+        else{
+            //mov ecx,offset
+            op_mov_RV(REG_ECX,(int)pRelativeVar->offset);
+            obp-=sizeof(long);
+            pobj_GlobalVarSchedule->add();
+            obp+=sizeof(long);
+
+            //fstp ptr[ecx]
+            op_fstp_basereg(VarType,REG_ECX);
+        }
+    }
+    else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
+        if(pRelativeVar->bOffsetOffset){
+            //add ecx,qword ptr[offset]
+            op_add_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
+        }
+        else{
+            //mov ecx,qword ptr[offset]
+            op_mov_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
+        }
+        obp-=sizeof(long);
+        pobj_GlobalVarSchedule->add();
+        obp+=sizeof(long);
+
+        goto directmem;
+    }
+    else if(pRelativeVar->dwKind==VAR_LOCAL){
+        if(pRelativeVar->bOffsetOffset){
+            //fstp ptr[ebp+ecx+offset]
+            op_fstp_base_offset_ex(VarType,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
+        }
+        else{
+            //fstp ptr[ebp+offset]
+            op_fstp_base_offset(VarType,REG_EBP,(int)pRelativeVar->offset);
+        }
+        obp-=sizeof(long);
+        AddLocalVarAddrSchedule();
+        obp+=sizeof(long);
+    }
+    else if(pRelativeVar->dwKind==VAR_REFLOCAL){
+        if(pRelativeVar->bOffsetOffset){
+            //add ecx,qword ptr[ebp+offset]
+            op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+        }
+        else{
+            //mov ecx,qword ptr[ebp+offset]
+            op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
+        }
+        obp-=sizeof(long);
+        AddLocalVarAddrSchedule();
+        obp+=sizeof(long);
+
+        goto directmem;
+    }
+    else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
+directmem:
+        //fstp ptr[ecx]
+        op_fstp_basereg(VarType,REG_ECX);
+    }
+}
+
+void SetBooleanVariable(int type,RELATIVE_VAR *pRelative){
+    if(type==DEF_DOUBLE){
+        // TODO: 実装
+        SetError();
+    }
+    else if(type==DEF_SINGLE){
+        // TODO: 実装
+        SetError();
+    }
+    else if(type==DEF_INT64||type==DEF_QWORD){
+        //cmp eax,0
+        op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
+
+        //setne al
+        op_setne( REG_EAX );
+
+        //cmp edx,0
+        op_cmp_value(GetTypeSize(type,-1),REG_EDX,0);
+
+        //setne cl
+        op_setne( REG_ECX );
+
+        //or al,cl
+        op_or_RR( sizeof( _int8 ), REG_EAX, REG_ECX );
+    }
+    else{
+        if(!IsWholeNumberType(type)){
+            //不正な型の場合
+            SetError(9,NULL,cp);
+            return;
+        }
+    }
+
+    //cmp eax,0
+    op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
+
+    //setne al
+    op_setne( REG_EAX );
+
+    SetWholeVariable( sizeof(char), DEF_BYTE, pRelative );
+}
+
+void ExtendTypeTo32(int type,int reg);
+void ExtendTypeTo64(int type){
+    if(Is64Type(type)) return;
+
+    ExtendTypeTo32(type,REG_EAX);
+
+    if(IsSignedType(type)){
+        //cdq
+        op_cdq();
+    }
+    else{
+        //xor edx,edx
+        op_zero_reg(REG_EDX);
+    }
+}
+void ExtendTypeTo32(int type,int reg){
+    if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){
+        //movsx reg32,reg16
+        op_movsx_R32R16(reg,reg);
+    }
+    else if(type==DEF_WORD){
+        //and reg,0000FFFFh
+        op_and_RV(reg,(int)0x0000FFFF);
+    }
+    else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
+        //movsx reg32,reg8
+        op_movsx_R32R8(reg,reg);
+    }
+    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
+        //and reg,000000FFh
+        op_and_RV(reg,(int)0xFF);
+    }
+}
+void ExtendTypeTo16(int type,int reg){
+    if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
+        //movsx reg16,reg8
+        op_movsx_R16R8(reg,reg);
+    }
+    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
+        //and reg,000000FFh
+        op_and_RV(reg,(int)0xFF);
+    }
+}
+
+void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative){
+    if(type==DEF_DOUBLE){
+        //Double型
+        // st(0)の内容をedx:eaxに変換
+
+        //TODO: 実装
+        SetError();
+    }
+    else if(type==DEF_SINGLE){
+        //Single型
+        // st(0)の内容をeaxに変換
+
+        //TODO: 実装
+        SetError();
+    }
+    else{
+        //その他の整数
+
+        if(var_size==sizeof(_int64)){
+            //eaxの値を64ビット（edx:eax）に拡張する
+            ExtendTypeTo64(type);
+        }
+        else if(var_size==sizeof(long)){
+            //レジスタの値を32ビット（eax）に拡張する
+            ExtendTypeTo32(type,REG_EAX);
+        }
+        else if(var_size==sizeof(short)){
+            //レジスタの値を16ビット（ax）に拡張する
+            ExtendTypeTo16(type,REG_EAX);
+        }
+        //8ビットは拡張なし
+    }
+
+    if(var_size==sizeof(_int64)){
+        //下位32ビット
+        SetWholeVariable(sizeof(long),DEF_LONG,pRelative);
+
+        //mov eax,edx
+        op_mov_RR( REG_EAX, REG_EDX );
+
+        //上位32ビット
+        if( pRelative->dwKind == VAR_DIRECTMEM ){
+            //add ecx,sizeof(long)
+            op_add_RV8( REG_ECX, sizeof(long) );
+        }
+        pRelative->offset+=sizeof(long);
+        SetWholeVariable(sizeof(long),DEF_LONG,pRelative);
+        pRelative->offset-=sizeof(long);
+
+        return;
+    }
+
+    if(pRelative->dwKind==VAR_GLOBAL){
+        if(pRelative->bOffsetOffset){
+            //mov ptr[ecx+offset],eax/ax/al
+            op_mov_MR(var_size,REG_EAX,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32);
+        }
+        else{
+            //mov ptr[offset],eax/ax/al
+            op_mov_MR(var_size,REG_EAX,0,(int)pRelative->offset,MOD_DISP32);
+        }
+        obp-=sizeof(long);
+        pobj_GlobalVarSchedule->add();
+        obp+=sizeof(long);
+    }
+    else if(pRelative->dwKind==VAR_REFGLOBAL){
+        if(pRelative->bOffsetOffset){
+            //add ecx,qword ptr[offset]
+            op_add_RM(var_size,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
+        }
+        else{
+            //mov ecx,qword ptr[offset]
+            op_mov_RM(var_size,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
+        }
+        obp-=sizeof(long);
+        pobj_GlobalVarSchedule->add();
+        obp+=sizeof(long);
+
+        goto directmem;
+    }
+    else if(pRelative->dwKind==VAR_LOCAL){
+        if(pRelative->bOffsetOffset){
+            //mov ptr[ebp+ecx+offset],eax/ax/al
+            op_mov_MR_ex(var_size,REG_EAX,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET);
+        }
+        else{
+            //mov ptr[ebp+offset],eax/ax/al
+            op_mov_MR(var_size,REG_EAX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
+        }
+        obp-=sizeof(long);
+        AddLocalVarAddrSchedule();
+        obp+=sizeof(long);
+    }
+    else if(pRelative->dwKind==VAR_REFLOCAL){
+        if(pRelative->bOffsetOffset){
+            //add ecx,qword ptr[ebp+offset]
+            op_add_RM(var_size,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
+        }
+        else{
+            //mov ecx,qword ptr[ebp+offset]
+            op_mov_RM(var_size,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
+        }
+        obp-=sizeof(long);
+        AddLocalVarAddrSchedule();
+        obp+=sizeof(long);
+
+        goto directmem;
+    }
+    else if(pRelative->dwKind==VAR_DIRECTMEM){
+directmem:
+
+        //mov ptr[ecx],eax/ax/al
+        op_mov_MR(var_size,REG_EAX,REG_ECX,0,MOD_BASE);
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+TODO: 消す
 void SetDoubleVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset){
     ChangeTypeToDouble(type);
@@ -972 +1307 @@
     }
 }
-void SetBooleanVariable(int type,RELATIVE_VAR *pRelative){
-    if(type==DEF_DOUBLE){
-        // TODO: 実装
-    }
-    else if(type==DEF_SINGLE){
-        // TODO: 実装
-    }
-    else if(type==DEF_INT64||type==DEF_QWORD){
-        // TODO: 実装
-
-        //pop eax
-        op_pop(REG_EAX);
-
-        //cmp eax,0
-        op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
-
-        //setne al
-        op_setne( REG_EAX );
-
-        //pop ecx
-        op_pop(REG_ECX);
-
-        //cmp ecx,0
-        op_cmp_value(GetTypeSize(type,-1),REG_ECX,0);
-
-        //setne cl
-        op_setne( REG_ECX );
-
-        //or al,cl
-        op_or_RR( sizeof( _int8 ), REG_EAX, REG_ECX );
-    }
-    else{
-        if(!IsWholeNumberType(type)){
-            //不正な型の場合
-            SetError(9,NULL,cp);
-            return;
-        }
-
-        //pop eax
-        op_pop(REG_EAX);
-    }
-
-    //cmp eax,0
-    op_cmp_value(GetTypeSize(type,-1),REG_EAX,0);
-
-    //setne al
-    op_setne( REG_EAX );
-
-    //push eax
-    op_push(REG_EAX);
-
-    Set8Variable(DEF_BYTE,pRelative->dwKind,pRelative->offset,pRelative->bOffsetOffset);
-}
+*/

BasicCompiler32/Compile_Statement.cpp

@@ -105 +105 @@
             OpBuffer[obp++]=(char)0xD8;
         }
-        if(i2==DEF_OBJECT){
+        if(i2==DEF_STRUCT){
             //mov ebx,eax
             op_mov_RR(REG_EBX,REG_EAX);
@@ -1336 +1336 @@
             else temp=pCompilingSubInfo->name;
 
+            /*
+            TODO: 消す
             if( pCompilingSubInfo->isReturnRef ){
                 //参照型
@@ -1341 +1343 @@
             }
             else{
-                //値型
+                //値型*/
                 char temporary[VN_SIZE];
                 sprintf(temporary,"%s=%s",temp,Parameter);
                 OpcodeCalc(temporary);
-            }
+            //}
         }
 
@@ -1353 +1355 @@
 }
 
-void Opcode_Input(char *Parameter){
+void Opcode_Input(const char *Parameter){
     extern int cp;
     int i2,i3,i4,i5,type;
     BOOL bFile;
     char temporary[VN_SIZE],temp2[VN_SIZE],buffer[VN_SIZE];
-
-    KillStringSpaces(Parameter);
 
     if(Parameter[0]=='#'){
@@ -1469 +1469 @@
     Opcode_CallProc(buffer,psi,0,"",0);
 }
-void Opcode_PrintUsing(char *Parameter,char *buffer,BOOL bFile){
+void Opcode_PrintUsing(const char *Parameter,char *buffer,BOOL bFile){
     extern int cp;
     int i2,i3,i4,i5;
@@ -1475 +1475 @@
     BOOL bReturnLine;
 
-    i2=lstrlen(Parameter);
-    if(Parameter[i2-1]==';'){
+    char parms[8192];
+    lstrcpy( parms, Parameter );
+
+    i2=lstrlen(parms);
+    if(parms[i2-1]==';'){
         bReturnLine=0;
-        Parameter[i2-1]=0;
+        parms[i2-1]=0;
     }
     else bReturnLine=1;
@@ -1484 +1487 @@
     i3=lstrlen(buffer);
     for(i2=0;;i2++,i3++){
-        if(Parameter[i2]==';'){
+        if(parms[i2]==';'){
             buffer[i3]=0;
             break;
         }
-        buffer[i3]=Parameter[i2];
-        if(Parameter[i2]=='\0') break;
-    }
-    if(Parameter[i2]==';') i2++;
+        buffer[i3]=parms[i2];
+        if(parms[i2]=='\0') break;
+    }
+    if(parms[i2]==';') i2++;
 
     if(bReturnLine) lstrcat(buffer,"+Ex\"\\r\\n\"");
@@ -1499 +1502 @@
     while(1){
         for(i3=0;;i2++,i3++){
-            if(Parameter[i2]=='\"'){
-                temporary[i3]=Parameter[i2];
+            if(parms[i2]=='\"'){
+                temporary[i3]=parms[i2];
                 for(i2++,i3++;;i2++,i3++){
-                    temporary[i3]=Parameter[i2];
-                    if(Parameter[i2]=='\"') break;
+                    temporary[i3]=parms[i2];
+                    if(parms[i2]=='\"') break;
                 }
                 continue;
             }
-            if(Parameter[i2]=='('){
-                i5=GetStringInPare(temporary+i3,Parameter+i2);
+            if(parms[i2]=='('){
+                i5=GetStringInPare(temporary+i3,parms+i2);
                 i2+=i5-1;
                 i3+=i5-1;
                 continue;
             }
-            if(Parameter[i2]=='['){
-                i5=GetStringInBracket(temporary+i3,Parameter+i2);
+            if(parms[i2]=='['){
+                i5=GetStringInBracket(temporary+i3,parms+i2);
                 i2+=i5-1;
                 i3+=i5-1;
                 continue;
             }
-            if(Parameter[i2]==','){
+            if(parms[i2]==','){
                 temporary[i3]=0;
                 i2++;
                 break;
             }
-            temporary[i3]=Parameter[i2];
-            if(Parameter[i2]=='\0') break;
+            temporary[i3]=parms[i2];
+            if(parms[i2]=='\0') break;
         }
         if(temporary[0]=='\0'){
@@ -1554 +1557 @@
 
         i4++;
-        if(Parameter[i2]=='\0') break;
+        if(parms[i2]=='\0') break;
     }
     sprintf(temp2,"_System_UsingDataType[%d]=-1",i4);
@@ -1568 +1571 @@
     Opcode_CallProc(buffer,psi,0,"",0);
 }
-void Opcode_Print(char *Parameter,BOOL bWrite){
+void Opcode_Print(const char *Parameter,BOOL bWrite){
     int i2,i3,i4,sw;
     char temporary[VN_SIZE],buffer[VN_SIZE];
     BOOL bFile;
-
-    KillStringSpaces(Parameter);
 
     if(Parameter[0]=='#'){

BasicCompiler32/Compile_Var.cpp

@@ -23 +23 @@
 
     if(PTR_LEVEL(*pType)){
-        *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
-        if((*pType)==DEF_OBJECT){
-            CClass *pClass = (CClass *)lpIndex;
-            int objsize = pClass->GetSize();
-
-            //imul ebx,objsize
-            OpBuffer[obp++]=(char)0x69;
-            OpBuffer[obp++]=(char)0xDB;
-            *((long *)(OpBuffer+obp))=objsize;
-            obp+=sizeof(long);
-        }
-        else{
-            i2=GetTypeSize(*pType,-1);
-            if(i2>=2){
-                //imul ebx,i2
-                OpBuffer[obp++]=(char)0x6B;
-                OpBuffer[obp++]=(char)0xDB;
-                OpBuffer[obp++]=(char)i2;
-            }
+        *pType = PTR_LEVEL_DOWN( *pType );
+
+        i2=GetTypeSize(*pType,-1);
+        if(i2>=2){
+            //imul ebx,i2
+            op_imul_RV( REG_EBX, i2 );
         }
     }
@@ -56 +43 @@
     OpBuffer[obp++]=(char)0x03;
     OpBuffer[obp++]=(char)0xCB;
+}
+void SetRelativeOffset( RELATIVE_VAR &relativeVar ){
+    if(relativeVar.dwKind==VAR_DIRECTMEM){
+        //mov ecx,dword ptr[ecx]
+        op_mov_RM( sizeof(long), REG_ECX, REG_ECX, 0, MOD_BASE );
+    }
+    else{
+        //直接参照に切り替え
+        SetVarPtrToEax(&relativeVar);
+        relativeVar.dwKind=VAR_DIRECTMEM;
+
+        //mov ecx,dword ptr[eax]
+        op_mov_RM( sizeof(long), REG_ECX, REG_EAX, 0, MOD_BASE );
+    }
 }
 BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
@@ -168 +169 @@
     char lpPtrOffset[VN_SIZE];  //第2次配列
     char NestMember[VN_SIZE];   //入れ子メンバ
-    int RefType;                //"."参照のときは0、"->"参照のときは1
+    CClass::RefType refType;
     lstrcpy(VarName,member);
-    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;
+    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
 
     ////////////////////////////
@@ -251 +252 @@
         //入れ子構造の場合
 
-        if(*pType==DEF_OBJECT){
-            if(RefType!=DEF_OBJECT){
+        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
+            if( refType != CClass::Dot ){
                 if(isErrorEnabled) SetError(104,member,cp);
                 return 0;
             }
-        }
-        else if(*pType==DEF_PTR_OBJECT){
+
+            if( *pType==DEF_OBJECT ){
+                // 参照内容へのポインタを抽出
+                SetRelativeOffset( *pRelativeVar );
+            }
+        }
+        else if(*pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT){
             //構造体ポインタ型メンバ変数
 
             if(lpPtrOffset[0]){
                 //pObj[n].member
-                if(RefType!=DEF_OBJECT){
+                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Dot ){
                     if(isErrorEnabled) SetError(104,member,cp);
                     return 0;
@@ -275 +281 @@
             else{
                 //pObj->member
-                if(RefType!=DEF_PTR_OBJECT){
+                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Pointer ){
                     if(isErrorEnabled) SetError(104,member,cp);
                     return 0;
                 }
 
-                if(pRelativeVar->dwKind==VAR_DIRECTMEM){
-                    //mov ecx,dword ptr[ecx]
-                    OpBuffer[obp++]=(char)0x8B;
-                    OpBuffer[obp++]=(char)0x09;
-                }
-                else{
-                    //直接参照に切り替え
-                    SetVarPtrToEax(pRelativeVar);
-                    pRelativeVar->dwKind=VAR_DIRECTMEM;
-
-                    //mov ecx,dword ptr[eax]
-                    OpBuffer[obp++]=(char)0x8B;
-                    OpBuffer[obp++]=(char)0x08;
-                }
-            }
-        }
-        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
+                SetRelativeOffset( *pRelativeVar );
+            }
+        }
+        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
             //構造体ポインタのポインタ型メンバ変数
 
             if(lpPtrOffset[0]){
                 //ppObj[n]->member
-                if(RefType!=DEF_PTR_OBJECT){
+                if( refType != CClass::Pointer ){
                     if(isErrorEnabled) SetError(104,member,cp);
                     return 0;
@@ -364 +357 @@
 BOOL GetVarOffset(bool isErrorEnabled, bool isWriteAccess, const char *NameBuffer, int *pType, RELATIVE_VAR *pRelativeVar, LONG_PTR *plpIndex, int *pss){
     extern BOOL bCompilingGlobal;
-    int i,RefType;
+    int i;
     LONG_PTR lpIndex;
     char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
@@ -374 +367 @@
     else lstrcpy(variable,NameBuffer);
 
-
-    if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
+    CClass::RefType refType;
+    if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){
         // 戻り値オブジェクトのメンバを直接参照しているとき
         //例: func().member
@@ -410 +403 @@
 
     lstrcpy(VarName,variable);
-    GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
+    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
 
     int *pSubScripts;
@@ -546 +539 @@
     if(member[0]){
         lstrcpy(temporary,member);
+
         char tempMember[VN_SIZE];
         char tempArray[VN_SIZE];
-        GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);
+        {
+            CClass::RefType refType;
+            GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
+        }
 
         char temp2[VN_SIZE];
@@ -665 +662 @@
     }
     if(member[0]){
-        if(*pType==DEF_OBJECT){
+        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
             //実態オブジェクトのメンバを参照（obj.member）
-            if(RefType!=DEF_OBJECT){
+            if( refType != CClass::Dot ){
                 SetError(104,VarName,cp);
                 pRelativeVar->dwKind=NON_VAR;
                 return 0;
             }
-        }
-        else if(*pType==DEF_PTR_OBJECT){
+
+            if( *pType==DEF_OBJECT ){
+                // 参照内容へのポインタを抽出
+                SetRelativeOffset( *pRelativeVar );
+            }
+        }
+        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
             //ポインタオブジェクトが示すメンバを参照
             if(lpPtrOffset[0]){
                 //pObj[n].member
-                if(RefType!=DEF_OBJECT){
+                if( refType != CClass::Dot ){
                     SetError(104,VarName,cp);
                     pRelativeVar->dwKind=NON_VAR;
@@ -687 +689 @@
             else{
                 //pObj->member
-                if(RefType!=DEF_PTR_OBJECT){
+                if( refType != CClass::Pointer ){
                     SetError(104,VarName,cp);
                     pRelativeVar->dwKind=NON_VAR;
@@ -701 +703 @@
             }
         }
-        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
+        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
             //ポインタオブジェクトが示すメンバを参照
             if(lpPtrOffset[0]){
                 //ppObj[n]->member
-                if(RefType!=DEF_PTR_OBJECT){
+                if( refType != CClass::Pointer ){
                     SetError(104,VarName,cp);
                     pRelativeVar->dwKind=NON_VAR;
@@ -785 +787 @@
         }
 
-        if(type==DEF_OBJECT){
+        if(type==DEF_STRUCT){
             CClass *pobj_c;
             pobj_c=(CClass *)lpIndex;
@@ -818 +820 @@
     ///////////////////////////////////////
 
-    if( type == DEF_OBJECT){
-        //オブジェクトの場合はありえない
+    if( type == DEF_OBJECT || type == DEF_STRUCT ){
+        //オブジェクトまたは構造体の場合はありえない
         SetError(300,NULL,cp);
         return 0;
@@ -855 +857 @@
         *(_int64 *)(initGlobalBuf+offset)=i64data;
     else if(type==DEF_LONG||type==DEF_DWORD||IsPtrType(type)){
-        if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
+        if(type==DEF_PTR_CHAR&&lpCalcIndex==LITERAL_STRING){
             //文字列定数のとき
 
@@ -918 +920 @@
         }
 
-        if(type==DEF_OBJECT){
+        if(type==DEF_STRUCT){
             CClass *pobj_c;
             pobj_c=(CClass *)lpIndex;
@@ -1045 +1047 @@
     }
     else if(type==DEF_LONG||type==DEF_DWORD||IsPtrType(type)){
-        if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
+        if(type==DEF_PTR_CHAR&&lpCalcIndex==LITERAL_STRING){
             //文字列定数のとき
 
@@ -1102 +1104 @@
 }
 
+void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
+    extern BOOL bCompilingGlobal;
+    if(bCompilingGlobal){
+        /////////////////////////
+        // グローバル変数
+        /////////////////////////
+
+        AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
+    }
+    else{
+        /////////////////
+        // ローカル変数
+        /////////////////
+
+        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%4) VarSize+=4-(VarSize%4);
+
+        //変数データを追加
+        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;
+        AllLocalVarSize+=VarSize;
+        pVar->offset=AllLocalVarSize;
+
+        //レキシカルスコープ
+        pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
+        pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
+        pVar->bLiving=TRUE;
+
+        if(InitBuf[0]){
+            //初期代入時のみ、書き込みアクセスを許可する
+            bool bConstBack = pVar->bConst;
+            pVar->bConst = false;
+
+            int result = 0;
+            if( pVar->type != DEF_OBJECT ){
+                result = InitLocalVar(-pVar->offset,
+                    pVar->type,
+                    pVar->u.index,
+                    pVar->SubScripts,
+                    InitBuf);
+            }
+
+            if(!result){
+                //動的な式だった場合は代入演算を行う
+                char temporary[8192];
+                sprintf(temporary,"%s=%s",VarName,InitBuf);
+                OpcodeCalc(temporary);
+            }
+
+            pVar->bConst = bConstBack;
+        }
+        else{
+            //push 0
+            op_push_value(0);
+
+            //push VarSize
+            op_push_value(VarSize);
+
+            //mov eax,ebp
+            OpBuffer[obp++]=(char)0x8B;
+            OpBuffer[obp++]=(char)0xC5;
+
+            //add eax,offset
+            OpBuffer[obp++]=(char)0x05;
+            *((long *)(OpBuffer+obp))=-pVar->offset;
+            AddLocalVarAddrSchedule();
+            obp+=sizeof(long);
+
+            //push eax
+            op_push(REG_EAX);
+
+            //call FillMemory
+            OpBuffer[obp++]=(char)0xFF;
+            OpBuffer[obp++]=(char)0x15;
+            DECLAREINFO *pdi;
+            pdi=GetDeclareHash("FillMemory");
+            pdi->bUse=1;
+            pobj_ImportAddrSchedule->add(pdi);
+            obp+=sizeof(long);
+        }
+    }
+
+    //New呼び出し
+    if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
+        char objectSize[255];
+        if( SubScripts[0] == -1 ){
+            objectSize[0] = 0;
+        }
+        else{
+            if( SubScripts[1] != -1 ){
+                SetError(300,NULL,cp);
+            }
+            sprintf( objectSize, "%d", SubScripts[0] );
+        }
+        Operator_New( *TypeInfo.u.pobj_Class, objectSize, ConstractParameter, TypeInfo );
+
+        //pop eax
+        op_pop( REG_EAX );
+
+        int type;
+        LONG_PTR lpIndex;
+        RELATIVE_VAR RelativeVar;
+        GetVarOffset( true, false, VarName, &type, &RelativeVar, &lpIndex );
+        if( RelativeVar.dwKind == VAR_DIRECTMEM ){
+            SetError();
+        }
+        SetVariableFromEax( DEF_OBJECT, DEF_OBJECT, &RelativeVar );
+    }
+
+    if(TypeInfo.type==DEF_OBJECT){
+        if(TypeInfo.u.pobj_Class->IsAbstract()){
+            //抽象クラスだったとき
+            SetError(125,TypeInfo.u.pobj_Class->name,cp);
+        }
+    }
+}
 void dim(char *Parameter,DWORD dwFlags){
     extern BOOL bCompilingGlobal;
     extern HANDLE hHeap;
-    int i2,i3,VarSize;
+    int i2;
     char VarName[VN_SIZE];
 
@@ -1187 +1340 @@
         GetNowStaticVarFullName(VarName,temporary);
 
-        AddGlobalVariable(isRef, temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
+        dim( isRef,temporary,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
 
         /*
@@ -1195 +1348 @@
     }
     else{
-        if(bCompilingGlobal){
-            /////////////////////////
-            // グローバル変数
-            /////////////////////////
-
-            AddGlobalVariable(isRef, VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
-        }
-        else{
-            /////////////////
-            // ローカル変数
-            /////////////////
-
-            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;
-            }
-            VarSize=TypeSize*i2;
-            if(VarSize%4) VarSize+=4-(VarSize%4);
-
-            //変数データを追加
-            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;
-            AllLocalVarSize+=VarSize;
-            pVar->offset=AllLocalVarSize;
-
-            //レキシカルスコープ
-            pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
-            pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
-            pVar->bLiving=TRUE;
-
-            if(InitBuf[0]){
-                //初期代入時のみ、書き込みアクセスを許可する
-                bool bConstBack = pVar->bConst;
-                pVar->bConst = false;
-
-                int result = InitLocalVar(-pVar->offset,
-                    pVar->type,
-                    pVar->u.index,
-                    pVar->SubScripts,
-                    InitBuf);
-
-                if(!result){
-                    if( isRef ){
-                        SetRefVariable( VarName, InitBuf );
-                    }
-                    else{
-                        char temporary[8192];
-                        sprintf(temporary,"%s=%s",VarName,InitBuf);
-                        OpcodeCalc(temporary);
-                    }
-                }
-
-                pVar->bConst = bConstBack;
-            }
-            else{
-                //push 0
-                op_push_value(0);
-
-                //push VarSize
-                op_push_value(VarSize);
-
-                //mov eax,ebp
-                OpBuffer[obp++]=(char)0x8B;
-                OpBuffer[obp++]=(char)0xC5;
-
-                //add eax,offset
-                OpBuffer[obp++]=(char)0x05;
-                *((long *)(OpBuffer+obp))=-pVar->offset;
-                AddLocalVarAddrSchedule();
-                obp+=sizeof(long);
-
-                //push eax
-                op_push(REG_EAX);
-
-                //call FillMemory
-                OpBuffer[obp++]=(char)0xFF;
-                OpBuffer[obp++]=(char)0x15;
-                DECLAREINFO *pdi;
-                pdi=GetDeclareHash("FillMemory");
-                pdi->bUse=1;
-                pobj_ImportAddrSchedule->add(pdi);
-                obp+=sizeof(long);
-            }
-        }
-
-        //コンストラクタ呼び出し
-        if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
-            CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
-        }
-    }
-
-    if(TypeInfo.type==DEF_OBJECT){
-        if(TypeInfo.u.pobj_Class->IsAbstract()){
-            //抽象クラスだったとき
-            SetError(125,TypeInfo.u.pobj_Class->name,cp);
-        }
+        dim( isRef,VarName,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
     }
 }

BasicCompiler32/MakePeHdr.cpp

@@ -22 +22 @@
     *pSub_realloc,
     *pSub_free,
+    *pSub_System_GC_malloc_ForObject,
+    *pSub_System_GC_malloc_ForObjectPtr,
+    *pSub_System_GC_free_for_SweepingDelete,
 
     *pSub_allrem,
@@ -30 +33 @@
     *pSub_allshl,
     *pSub_allshr,
-    *pSub_aullshr;
+    *pSub_aullshr,
+    
+    *pSub_esp_error;
 
 
@@ -227 +232 @@
         pSub_free->bUse=1;
 
+    if( pSub_System_GC_malloc_ForObject = GetSubHash( "_System_GC_malloc_ForObject",1 ) )
+        pSub_System_GC_malloc_ForObject->bUse = 1;
+
+    if( pSub_System_GC_malloc_ForObjectPtr = GetSubHash( "_System_GC_malloc_ForObjectPtr",1 ) )
+        pSub_System_GC_malloc_ForObjectPtr->bUse = 1;
+
+    if( pSub_System_GC_free_for_SweepingDelete = GetSubHash( "_System_GC_free_for_SweepingDelete",1 ) )
+        pSub_System_GC_free_for_SweepingDelete->bUse = 1;
+
     pSub_allrem=GetSubHash("_allrem");
     pSub_allrem->bUse=1;
@@ -258 +272 @@
     pSub_aullshr->bUse=1;
     pSub_aullshr->bSystem=1;
+
+    pSub_esp_error=GetSubHash("_esp_error");
+    pSub_esp_error->bUse=1;
+
+
 
 

BasicCompiler32/NumOpe.cpp

@@ -6 +6 @@
     //※この処理内では、esi、ediは使用不可
 
-    if(type==DEF_OBJECT){
+    if(type==DEF_OBJECT || type==DEF_STRUCT){
         //push eax
         op_push(REG_EAX);
@@ -62 +62 @@
         op_push(REG_EAX);
     }
-    else if(type==DEF_PTR_BYTE){
-        //push eax
-        op_push(REG_EAX);
+    else{
+        SetError();
     }
 }
@@ -71 +70 @@
     ///////////////////////////////////////////////////////
     // lpszTextを元にStringオブジェクトを生成し、
-    // オブジェクトポインタをスタックに格納する
+    // オブジェクトポインタをregに格納する
     ///////////////////////////////////////////////////////
 
+    char *parameter = (char *)malloc( lstrlen( lpszText ) + 3 );
+    lstrcpy( parameter, lpszText );
+    SetStringQuotes( parameter );
+
     extern CClass *pobj_StringClass;
-    int object_size = pobj_StringClass->GetSize();
-
-    //push object_size
-    op_push_value(object_size);
-
-    //call calloc
-    extern SUBINFO *pSub_calloc;
-    op_call(pSub_calloc);
-
-    //push eax
-    op_push(REG_EAX);
-
-    //push eax
-    op_push(REG_EAX);
-
-    {
-        //push eax
-        op_push(REG_EAX);
-
-        //call constructor
-        op_call(pobj_StringClass->GetConstructorMethod()->psi);
-    }
-
-    // TODO: Ex表記による文字列長に対応する
-    int i2 = dataTable.AddString( lpszText );
-
-    //push lpszPtr
-    OpBuffer[obp++]=(char)0x68;
-    *((long *)(OpBuffer+obp))=i2;
-    pobj_DataTableSchedule->add();
-    obp+=sizeof(long);
-
-
-    SetObjectVariable((LONG_PTR)pobj_StringClass,DEF_PTR_BYTE,-1,0);
+    TYPEINFO baseTypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
+    Operator_New( *pobj_StringClass, "", parameter, baseTypeInfo );
+
+    free( parameter );
 }
 
@@ -122 +95 @@
     }
 
-    if(Command[0]==1&&Command[1]==ESC_NEW){
+    if(Command[0]==1&& Command[1]==ESC_NEW ){
         //New演算子（オブジェクト生成）
-        return Operator_New(Command+2,plpIndex);
+        TYPEINFO baseTypeInfo = { BaseType, lpBaseIndex };
+        int resultType = Operator_New(Command+2,plpIndex, baseTypeInfo );
+
+        return resultType;
     }
 
@@ -221 +197 @@
                         TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
                         if(IsStringSubsituation(pobj_Class)
-                            || IsStringObjectType(&BaseTypeInfo)){
+                            || IsStringObjectType(BaseTypeInfo)){
                             //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
 
@@ -239 +215 @@
 
 
-                    type[sp]=DEF_PTR_BYTE;
+                    type[sp]=DEF_PTR_CHAR;
                     index_stack[sp]=LITERAL_STRING;
                     bLiteralCalculation=0;
@@ -329 +305 @@
                             }
 
-                            if(i2==DEF_OBJECT){
-                                //Object型が戻ったときはヒープ領域にインスタンスが格納されている
+                            if(i2==DEF_STRUCT){
+                                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
                                 //※後にfreeする必要あり
                                 bUseHeap[sp]=1;
@@ -413 +389 @@
                         }
                         else if(i2==DEF_LONG||i2==DEF_DWORD||i2==DEF_SINGLE||
-                            IsPtrType(i2)){
+                            IsPtrType(i2) || i2==DEF_OBJECT){
                             //32ビット型
                             PushLongVariable(&RelativeVar);
@@ -429 +405 @@
                             PushByteVariable(&RelativeVar);
                         }
-                        else if(i2==DEF_OBJECT){
-                            //オブジェクト ポインタをeaxへ格納
+                        else if(i2==DEF_STRUCT){
+                            //構造体ポインタをeaxへ格納（構造体は値型）
                             SetVarPtrToEax(&RelativeVar);
 
@@ -436 +412 @@
                             op_push(REG_EAX);
                         }
+                        else SetError(11,term,cp);
 
                         if(Is64Type(type[sp])&&IsWholeNumberType(i2)&&GetTypeSize(i2,-1)<=sizeof(long)){
@@ -517 +494 @@
                         PushReturnValue(RetTypeInfo.type);
 
-                        if(type[sp]==DEF_OBJECT){
-                            //Object型が戻ったときはヒープ領域にインスタンスが格納されている
+                        if(type[sp]==DEF_STRUCT){
+                            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
                             //※後にfreeする必要あり
                             bUseHeap[sp]=1;

BasicCompiler32/NumOpe_Relation.cpp

@@ -1313 +1313 @@
         OpBuffer[obp++]=(char)0xC3;
 
-        //jnz 4（次のxorとjmpを飛び越す）
+        //jz 4（次のxorとjmpを飛び越す）
         OpBuffer[obp++]=(char)0x74;
         OpBuffer[obp++]=(char)0x04;

BasicCompiler32/Opcode.h

@@ -97 +97 @@
 void ChangeTypeToInteger(int OldType);
 void ChangeTypeToByte(int OldType);
+void SetVariableFromEax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar);
 void OpcodeCalc(char *Command);
-void SetRefVariable( const char *varname, const char *expression );
 
 //NumOpe.cpp
@@ -136 +136 @@
 //Compile_Set_Var.cpp
 BOOL IsUse_ecx(RELATIVE_VAR *pRelativeVar);
-void SetObjectVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap);
+void SetStructVariable(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,BOOL bUseHeap);
+void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar);
+void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative);
+
 void SetDoubleVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
 void SetSingleVariable(int type,DWORD VarKind,DWORD offset,BOOL bOffsetOffset);
@@ -171 +174 @@
 
 //Compile_Object.cpp
-int Operator_New(const char *Parameter,LONG_PTR *plpIndex);
-void OpcodeDelete(char *Parameter);
+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 OpcodeDelete(const char *Parameter, bool isSweeping);
 
 //Compile_Var.cpp
@@ -183 +187 @@
 #define DIMFLAG_STATIC                  4
 #define DIMFLAG_CONST                   8
+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 SetVarPtrToEax(RELATIVE_VAR *pRelativeVar);
 
 //CParameter.cpp
+#define OVERLOAD_MIN_LEVEL 0
+#define OVERLOAD_MAX_LEVEL 3
+#define OVERLOAD_LEVEL0 0
 #define OVERLOAD_LEVEL1 1
 #define OVERLOAD_LEVEL2 2
@@ -216 +224 @@
     BOOL ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
     void MacroParameterSupport(PARAMETER_INFO *ppi);
-    void SetObjectParameter(CClass *pobj_Class,LPSTR Parameter);
+    void SetStructParameter(CClass *pobj_Class,LPSTR Parameter);
     int SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
 
     //一時オブジェクトパラメータの生成と破棄
-    void NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
+    int NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
     void DeleteTempParameters();
 };
@@ -228 +236 @@
 #define PROCFLAG_NEW    1
 int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex);
-void Opcode_CallProc(char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType);
+void Opcode_CallProc(const char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType);
 int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex);
 
@@ -258 +266 @@
 void OpcodeGosub(char *Parameter);
 void OpcodeReturn(char *Parameter);
-void Opcode_Input(char *Parameter);
-void Opcode_Print(char *Parameter,BOOL bWrite);
+void Opcode_Input(const char *Parameter);
+void Opcode_Print(const char *Parameter,BOOL bWrite);
 void OpcodeCallPtr(char *Parameter);
 void OpcodeSetPtrData(char *Parameter,int type);
@@ -300 +308 @@
 void op_sbb_RV8         (int reg,char cValue);
 void op_sbb_RR          ( int reg1, int reg2 );
+void op_imul_RR         (int reg1,int reg2);
+void op_imul_RV         (int reg,int i32data);
 void op_and_RV          (int reg,int value);
 void op_or_RR           ( int op_size, int reg1, int reg2 );
@@ -312 +322 @@
 void op_add_esp(int num);
 void op_sub_esp(int num);
+void op_cmp_RR( int reg1, int reg2 );
 void op_cmp_value(int op_size,int reg,char byte_data);
 void op_setne( int reg );

BasicCompiler32/OperatorProc.cpp

@@ -50 +50 @@
         if(pBaseTypeInfo){
             if(pBaseTypeInfo->type==DEF_OBJECT){
-                bReturnTypeIsObject=1;
                 ReturnType.u.lpIndex=pBaseTypeInfo->u.lpIndex;
             }
@@ -107 +106 @@
     HeapDefaultFree(ppi);
 
-    int right_side_size;
-    if(type[sp-1]==DEF_OBJECT) right_side_size=PTR_SIZE;
-    else right_side_size=GetTypeSize(type[sp-1],index_stack[sp-1]);
-
-    if(bTwoTerm){
-        if(psi->pParmInfo[1].type==DEF_OBJECT&&psi->pParmInfo[1].bByVal){
+    int right_side_size = GetTypeSize(type[sp-1],index_stack[sp-1]);
+
+    if(bTwoTerm){
+        if(psi->pRealParmInfo[1].type==DEF_STRUCT&&psi->pRealParmInfo[1].bByVal){
             //一時オブジェクトはメソッド内で破棄される
             bUseHeap[sp-1]=0;
@@ -119 +116 @@
 
 
-    if(psi->ReturnType==DEF_OBJECT){
+    if(psi->ReturnType==DEF_STRUCT){
         //////////////////////////////////////////////////////
-        // 戻り値にオブジェクト インスタンスを持つ場合
-        // ※ByRef _System_ReturnObject パラメータ用領域を取得
+        // 戻り値に構造体インスタンスを持つ場合
+        // ※ByRef _System_ReturnValue パラメータ用領域を取得
         //////////////////////////////////////////////////////
 
@@ -182 +179 @@
             op_push(REG_EAX);
         }
-    }
-
-    if(psi->ReturnType==DEF_OBJECT){
+
+        if( !psi->pRealParmInfo[1].bByVal ){
+            //一時参照を作成
+
+            //mov eax,esp
+            op_mov_RR( REG_EAX, REG_ESP );
+
+            //push eax
+            op_push( REG_EAX );
+        }
+    }
+
+    if(psi->ReturnType==DEF_STRUCT){
         //push ebx
         op_push(REG_EBX);
@@ -195 +202 @@
     op_call(psi);
 
-    if(psi->ReturnType!=-1){
+    if(bTwoTerm){
+        if( !psi->pRealParmInfo[1].bByVal ){
+            //一時参照を破棄
+            op_pop( REG_NON );
+        }
+    }
+
+    if(psi->ReturnType!=DEF_NON){
         //スタックへプッシュ
         PushReturnValue(psi->ReturnType);
@@ -211 +225 @@
     index_stack[sp-1]=psi->u.ReturnIndex;
 
-    if(psi->ReturnType==DEF_OBJECT){
-        //Object型が戻ったときはヒープ領域にインスタンスが格納されている
+    if(psi->ReturnType==DEF_STRUCT){
+        //構造体が戻ったときはヒープ領域にインスタンスが格納されている
         //※後にfreeする必要あり
         bUseHeap[sp-1]=1;

BasicCompiler32/VarList.cpp

@@ -20 +20 @@
     HTREEITEM hParent;
 
-    if(type==DEF_OBJECT){
+    if(type==DEF_OBJECT||type==DEF_STRUCT){
+        if( type==DEF_OBJECT ){
+            // 参照型ということを考慮する
+            ReadProcessMemory(hDebugProcess,(void *)offset,&dwData,sizeof(void *),&dwAccessByte);
+            offset = dwData;
+        }
+
         sprintf(lptv->item.pszText,"%s %s(&H%X)",VarName,STRING_OBJECT,offset);
         lptv->item.iImage=1;
@@ -29 +35 @@
         return;
     }
-    if(type==DEF_PTR_OBJECT){
+    if(type==DEF_PTR_OBJECT||type==DEF_PTR_STRUCT){
         i2=ReadProcessMemory(hDebugProcess,(void *)offset,&dwData,sizeof(DWORD),&dwAccessByte);
 
@@ -41 +47 @@
     }
     else{
-        if(type==DEF_PTR_BYTE){
+        if(type==DEF_PTR_CHAR||type==MAKE_PTR_TYPE(DEF_BYTE,1)){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&dwData,sizeof(DWORD),&dwAccessByte)){
                 for(i2=0;;i2++){

BasicCompiler32/WatchList.cpp

@@ -78 +78 @@
     if(PTR_LEVEL(*pType)){
         *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
-        if((*pType)==DEF_OBJECT){
-            CClass *pClass = (CClass *)lpIndex;
-            array_num *= pClass->GetSize();
-        }
-        else{
-            array_num *= GetTypeSize(*pType,-1);
-        }
+        array_num *= GetTypeSize(*pType,-1);
     }
     else{
@@ -114 +108 @@
     char lpPtrOffset[VN_SIZE];  //第2次配列
     char NestMember[VN_SIZE];   //入れ子メンバ
-    int RefType;                //"."参照のときは0、"->"参照のときは1
+    CClass::RefType refType;
     lstrcpy(VarName,member);
-    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;
+    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
 
 
@@ -175 +169 @@
         //入れ子構造の場合
 
-        if(*pType==DEF_OBJECT){
-            if(RefType!=DEF_OBJECT) return 0;
-        }
-        else if(*pType==DEF_PTR_OBJECT){
+        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
+            if( refType != CClass::Dot ) return 0;
+
+            if( *pType==DEF_OBJECT ){
+                extern HANDLE hDebugProcess;
+                LONG_PTR lpData;
+                SIZE_T stAccBytes;
+                lpData=Debugging_GetVarPtr(pRelativeVar);
+                if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&stAccBytes)) return -1;
+                pRelativeVar->dwKind=VAR_DIRECTMEM;
+            }
+        }
+        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
             //構造体ポインタ型メンバ変数
 
             if(lpPtrOffset[0]){
-                if(RefType!=DEF_OBJECT) return 0;
+                if( refType != CClass::Dot ) return 0;
 
                 //直接参照に切り替え
@@ -190 +193 @@
             }
             else{
-                if(RefType!=DEF_PTR_OBJECT) return 0;
+                if( refType != CClass::Pointer ) return 0;
 
                 extern HANDLE hDebugProcess;
@@ -319 +322 @@
 int Debugging_GetVarOffset(char *variable,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
     extern HANDLE hDebugProcess;
-    int i,i2,i3,RefType;
+    int i,i2,i3;
     char member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
     ULONG_PTR lpData;
@@ -325 +328 @@
 
     lstrcpy(VarName,variable);
-    GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
+    CClass::RefType refType;
+    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
 
     LONG_PTR lpIndex;
@@ -470 +474 @@
     }
     if(member[0]){
-        if(*pType==DEF_OBJECT){
+        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
             //実態オブジェクトのメンバを参照（obj.member）
-            if(RefType!=DEF_OBJECT){
+            if( refType != CClass::Dot ){
                 return 0;
             }
@@ -489 +493 @@
             *plpIndex=lp2;
         }
-        else if(*pType==DEF_PTR_OBJECT){
+        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
             //ポインタオブジェクトが示すメンバを参照
             if(lpPtrOffset[0]){
                 //pObj[n].member
-                if(RefType!=DEF_OBJECT) return 0;
+                if( refType != CClass::Dot ) return 0;
                 Debugging_SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
 
@@ -511 +515 @@
             else{
                 //pObj->member
-                if(RefType!=DEF_PTR_OBJECT) return 0;
+                if( refType != CClass::Pointer ) return 0;
 
                 pRelativeVar->offset=Debugging_GetVarPtr(pRelativeVar);

BasicCompiler32/commandvalue.h

@@ -19 +19 @@
 #define COM_LET     0x1066
 #define COM_DELETE  0x1068
+#define COM_SWEEPINGDELETE  0x1069
 
 //その他

BasicCompiler32/increment.cpp

@@ -1 +1 @@
 #include "../BasicCompiler_Common/common.h"
 #include "Opcode.h"
-
-
-void SetRealVariable(int type,RELATIVE_VAR *pRelativeVar){
-    if(pRelativeVar->dwKind==VAR_GLOBAL){
-        if(pRelativeVar->bOffsetOffset){
-            //fstp ptr[ecx+offset]
-            op_fstp_base_offset(type,REG_ECX,(int)pRelativeVar->offset);
-            obp-=sizeof(long);
-            pobj_GlobalVarSchedule->add();
-            obp+=sizeof(long);
-        }
-        else{
-            //mov ecx,offset
-            op_mov_RV(REG_ECX,(int)pRelativeVar->offset);
-            obp-=sizeof(long);
-            pobj_GlobalVarSchedule->add();
-            obp+=sizeof(long);
-
-            //fstp ptr[ecx]
-            op_fstp_basereg(type,REG_ECX);
-        }
-    }
-    else if(pRelativeVar->dwKind==VAR_REFGLOBAL){
-        if(pRelativeVar->bOffsetOffset){
-            //add ecx,qword ptr[offset]
-            op_add_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
-        }
-        else{
-            //mov ecx,qword ptr[offset]
-            op_mov_RM(sizeof(long),REG_ECX,REG_NON,(int)pRelativeVar->offset,MOD_DISP32);
-        }
-        obp-=sizeof(long);
-        pobj_GlobalVarSchedule->add();
-        obp+=sizeof(long);
-
-        goto directmem;
-    }
-    else if(pRelativeVar->dwKind==VAR_LOCAL){
-        if(pRelativeVar->bOffsetOffset){
-            //fstp ptr[ebp+ecx+offset]
-            op_fstp_base_offset_ex(type,REG_EBP,REG_ECX,(int)pRelativeVar->offset,USE_OFFSET);
-        }
-        else{
-            //fstp ptr[ebp+offset]
-            op_fstp_base_offset(type,REG_EBP,(int)pRelativeVar->offset);
-        }
-        obp-=sizeof(long);
-        AddLocalVarAddrSchedule();
-        obp+=sizeof(long);
-    }
-    else if(pRelativeVar->dwKind==VAR_REFLOCAL){
-        if(pRelativeVar->bOffsetOffset){
-            //add ecx,qword ptr[ebp+offset]
-            op_add_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
-        }
-        else{
-            //mov ecx,qword ptr[ebp+offset]
-            op_mov_RM(sizeof(long),REG_ECX,REG_EBP,(int)pRelativeVar->offset,MOD_BASE_DISP32);
-        }
-        obp-=sizeof(long);
-        AddLocalVarAddrSchedule();
-        obp+=sizeof(long);
-
-        goto directmem;
-    }
-    else if(pRelativeVar->dwKind==VAR_DIRECTMEM){
-directmem:
-        //fstp ptr[ecx]
-        op_fstp_basereg(type,REG_ECX);
-    }
-}
-
-void ExtendTypeTo32(int type,int reg);
-void ExtendTypeTo64(int type){
-    if(Is64Type(type)) return;
-
-    ExtendTypeTo32(type,REG_EAX);
-
-    if(IsSignedType(type)){
-        //cdq
-        op_cdq();
-    }
-    else{
-        //xor edx,edx
-        op_zero_reg(REG_EDX);
-    }
-}
-void ExtendTypeTo32(int type,int reg){
-    if(type==DEF_INTEGER || (isUnicode&&type==DEF_CHAR)){
-        //movsx reg32,reg16
-        op_movsx_R32R16(reg,reg);
-    }
-    else if(type==DEF_WORD){
-        //and reg,0000FFFFh
-        op_and_RV(reg,(int)0x0000FFFF);
-    }
-    else if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
-        //movsx reg32,reg8
-        op_movsx_R32R8(reg,reg);
-    }
-    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
-        //and reg,000000FFh
-        op_and_RV(reg,(int)0xFF);
-    }
-}
-void ExtendTypeTo16(int type,int reg){
-    if(type==DEF_SBYTE || (isUnicode==false&&type==DEF_CHAR)){
-        //movsx reg16,reg8
-        op_movsx_R16R8(reg,reg);
-    }
-    else if(type==DEF_BYTE||type==DEF_BOOLEAN){
-        //and reg,000000FFh
-        op_and_RV(reg,(int)0xFF);
-    }
-}
-
-void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative,int reg){
-    if(type==DEF_DOUBLE){
-        //Double型
-
-    }
-    else if(type==DEF_SINGLE){
-        //Single型
-
-    }
-    else{
-        //その他の整数
-
-        if(var_size==sizeof(_int64)){
-            //eaxの値を64ビット（edx:eax）に拡張する
-            ExtendTypeTo64(type);
-        }
-        else if(var_size==sizeof(long)){
-            //レジスタの値を32ビット（eax）に拡張する
-            ExtendTypeTo32(type,reg);
-        }
-        else if(var_size==sizeof(short)){
-            //レジスタの値を16ビット（ax）に拡張する
-            ExtendTypeTo16(type,reg);
-        }
-        //8ビットは拡張なし
-    }
-
-    if(var_size==sizeof(_int64)){
-        //下位32ビット
-        SetWholeVariable(sizeof(long),DEF_LONG,pRelative,REG_EAX);
-
-        //上位32ビット
-        pRelative->offset+=sizeof(long);
-        SetWholeVariable(sizeof(long),DEF_LONG,pRelative,REG_EDX);
-        pRelative->offset-=sizeof(long);
-
-        return;
-    }
-
-    if(pRelative->dwKind==VAR_GLOBAL){
-        if(pRelative->bOffsetOffset){
-            //mov ptr[ecx+offset],eax/ax/al
-            op_mov_MR(var_size,reg,REG_ECX,(int)pRelative->offset,MOD_BASE_DISP32);
-        }
-        else{
-            //mov ptr[offset],eax/ax/al
-            op_mov_MR(var_size,reg,0,(int)pRelative->offset,MOD_DISP32);
-        }
-        obp-=sizeof(long);
-        pobj_GlobalVarSchedule->add();
-        obp+=sizeof(long);
-    }
-    else if(pRelative->dwKind==VAR_REFGLOBAL){
-        if(pRelative->bOffsetOffset){
-            //add ecx,qword ptr[offset]
-            op_add_RM(var_size,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
-        }
-        else{
-            //mov ecx,qword ptr[offset]
-            op_mov_RM(var_size,REG_ECX,REG_NON,(int)pRelative->offset,MOD_DISP32);
-        }
-        obp-=sizeof(long);
-        pobj_GlobalVarSchedule->add();
-        obp+=sizeof(long);
-
-        goto directmem;
-    }
-    else if(pRelative->dwKind==VAR_LOCAL){
-        if(pRelative->bOffsetOffset){
-            //mov ptr[ebp+ecx+offset],eax/ax/al
-            op_mov_MR_ex(var_size,reg,REG_EBP,REG_ECX,(int)pRelative->offset,USE_OFFSET);
-        }
-        else{
-            //mov ptr[ebp+offset],eax/ax/al
-            op_mov_MR(var_size,reg,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
-        }
-        obp-=sizeof(long);
-        AddLocalVarAddrSchedule();
-        obp+=sizeof(long);
-    }
-    else if(pRelative->dwKind==VAR_REFLOCAL){
-        if(pRelative->bOffsetOffset){
-            //add ecx,qword ptr[ebp+offset]
-            op_add_RM(var_size,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
-        }
-        else{
-            //mov ecx,qword ptr[ebp+offset]
-            op_mov_RM(var_size,REG_ECX,REG_EBP,(int)pRelative->offset,MOD_BASE_DISP32);
-        }
-        obp-=sizeof(long);
-        AddLocalVarAddrSchedule();
-        obp+=sizeof(long);
-
-        goto directmem;
-    }
-    else if(pRelative->dwKind==VAR_DIRECTMEM){
-directmem:
-
-        //mov ptr[ecx],eax/ax/al
-        op_mov_MR(var_size,reg,REG_ECX,0,MOD_BASE);
-    }
-}
-
-void SetVariableFromReg(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar){
-    /////////////////////////////////////////////////
-    // raxの内容を変数にコピーするコードを抽出
-    /////////////////////////////////////////////////
-
-    if(VarType==DEF_DOUBLE){
-        //Double型変数へスタックの内容を格納する
-        SetRealVariable(VarType,pRelativeVar);
-    }
-    else if(VarType==DEF_SINGLE){
-        //Single型変数へスタックの内容を格納する
-        SetRealVariable(VarType,pRelativeVar);
-    }
-    else{
-        //整数型
-        SetWholeVariable(GetTypeSize(VarType,-1),CalcType,pRelativeVar,REG_EAX);
-    }
-}
-
 
 void IncDec(int idCalc, char *lpszLeft, char *lpszRight){
@@ -438 +200 @@
     }
 
-    SetVariableFromReg(VarType,VarType,&VarRelativeVar);
+    SetVariableFromEax(VarType,VarType,&VarRelativeVar);
 }

BasicCompiler32/op32_main.cpp

@@ -372 +372 @@
 
 
+////////////////////////
+// imul関連
+////////////////////////
+
+void op_imul_RR(int reg1,int reg2){
+    //imul reg1,reg2
+
+    //オペコード
+    OpBuffer[obp++]=(char)0x0F;
+    OpBuffer[obp++]=(char)0xAF;
+
+    //レジスタ
+    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
+}
+
+void op_imul_RV(int reg,int i32data){
+    //imul reg,i32data
+
+    if(-128<=i32data&&i32data<=127){
+        //オペコード
+        OpBuffer[obp++]=(char)0x6B;
+
+        //レジスタ
+        OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg));
+
+        //値
+        OpBuffer[obp++]=(char)i32data;
+    }
+    else{
+        //オペコード
+        OpBuffer[obp++]=(char)0x69;
+
+        //レジスタ
+        OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg)<<3 | REGISTER_OPERAND(reg));
+
+        //値
+        *((long *)(OpBuffer+obp))=i32data;
+        obp+=sizeof(long);
+    }
+}
+
+
 
 //////////////////////
@@ -468 +510 @@
 void op_push(int reg){
     //push reg
+
+    if( reg == REG_NON ){
+        op_sub_esp( PTR_SIZE );
+        return;
+    }
 
     //オペコード、レジスタ
@@ -489 +536 @@
     //pop reg
 
+    if( reg == REG_NON ){
+        op_add_esp( PTR_SIZE );
+        return;
+    }
+
     //オペコード、レジスタ
     __op_format(0,(char)0x58,reg);
@@ -532 +584 @@
 // cmp関連
 /////////////////////
+void op_cmp_RR( int reg1, int reg2 ){
+    //オペコード
+    OpBuffer[obp++]=(char)0x3B;
+
+    //レジスタ
+    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
+}
 void op_cmp_value(int op_size,int reg,char byte_data){
     //cmp reg,byte_data

BasicCompiler64/CParameter.cpp

@@ -2 +2 @@
 #include "opcode.h"
 
-void CParameter::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
+int CParameter::NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum ){
     ///////////////////////////////////////////////////////
     // 一時オブジェクトをあらかじめスタックに積んでおく
     ///////////////////////////////////////////////////////
+
+    int stackItemNum = 0;
 
     useTempObject = false;
@@ -60 +62 @@
                 int type = NumOpe( &reg, Parms[i2], DummyTypeInfo.type, DummyTypeInfo.u.lpIndex, &lpVarIndex );
 
+                if( type == DEF_OBJECT ){
+                    //一時参照を作成
+                    pobj_sf->push( reg );
+                    pobj_sf->mov_sp( reg );
+
+                    stackItemNum++;
+                }
+
                 //スタックフレームへコピー
                 StackOffsetOfTempObject[i2] = pobj_sf->push(reg);
+
+                stackItemNum++;
 
                 bool result = CheckDifferentType(
@@ -81 +93 @@
         }
     }
+
+    return stackItemNum * PTR_SIZE;
 }
 void CParameter::DeleteTempParameters(){
@@ -90 +104 @@
     for(int i2=ParmsNum-1;i2>=0;i2--){
         if( useTempParameters[i2] ){
-            //スタックフレームから取得
-            pobj_sf->ref(REG_RCX);
-
-            //デストラクタを呼び出す
-
-            //call destructor
-            CMethod *method = types[i2].u.pobj_Class->GetDestructorMethod();
-            if( method ){
-                op_call( method->psi );
-            }
-
-            //メモリを解放する
-
-            pobj_sf->pop(REG_RCX);
-
-            //call free
-            extern SUBINFO *pSub_free;
-            op_call(pSub_free);
+            if( types[i2].type == DEF_STRUCT ){
+                // 構造体の一時メモリ
+
+                //メモリを解放する
+
+                pobj_sf->pop( REG_RCX );
+
+                //call free
+                extern SUBINFO *pSub_free;
+                op_call(pSub_free);
+            }
+            else if( types[i2].type == DEF_OBJECT ){
+                pobj_sf->pop();
+                pobj_sf->pop();
+            }
+            else{
+                SetError(300,NULL,cp);
+            }
         }
     }
 }
 
-void CParameter::SetObjectParameter(int reg,CClass *pobj_Class,LPSTR Parameter){
+void CParameter::SetStructParameter(int reg,CClass *pobj_Class,LPSTR Parameter){
     //////////////////////////////////////////////////////
     /////    レジスタ資源のバックアップ
@@ -133 +147 @@
         pobj_sf->push(REG_R11);
 
-        TYPEINFO BaseType={DEF_OBJECT,(LONG_PTR)pobj_Class};
+        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){
@@ -178 +194 @@
                 op_call(pobj_Class->GetConstructorMethod()->psi);
             }
+            */
 
 
             BOOL bUseHeap;
             int temp_reg=REG_RAX;
-            CalcType.type=NumOpe(&temp_reg,Parameter,DEF_OBJECT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
+            CalcType.type=NumOpe(&temp_reg,Parameter,DEF_STRUCT,(LONG_PTR)pobj_Class,&CalcType.u.lpIndex,&bUseHeap);
 
 
@@ -194 +211 @@
             RelativeVar.dwKind=VAR_DIRECTMEM;
 
-            SetObjectVariableFromRax((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,&RelativeVar,bUseHeap);
-
-        }
+            SetStructVariableFromRax((LONG_PTR)pobj_Class,CalcType.type,CalcType.u.lpIndex,&RelativeVar,bUseHeap);
+
+        //}
 
         //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
@@ -209 +226 @@
     op_mov_RR(reg,REG_R11);
 }
+
 
 void CParameter::SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){
@@ -298 +316 @@
             }
 
-            if(DummyTypeInfo.type==DEF_OBJECT){
-                SetObjectParameter(reg,DummyTypeInfo.u.pobj_Class,Parms[i2]);
+            if(DummyTypeInfo.type==DEF_STRUCT){
+                SetStructParameter(reg,DummyTypeInfo.u.pobj_Class,Parms[i2]);
                 goto next;
             }
@@ -318 +336 @@
 
             if(CalcType==DEF_OBJECT){
-                //キャスト演算子のオーバーロードに対応する
-                CallCastOperatorProc(reg,CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
+                if( DummyTypeInfo.type != DEF_OBJECT
+                    ||
+                    DummyTypeInfo.type == DEF_OBJECT &&
+                    !DummyTypeInfo.u.pobj_Class->IsEqualsOrSubClass( (CClass *)lpCalcIndex ) ){
+                        //キャスト演算子のオーバーロードに対応する
+                        CallCastOperatorProc(reg,CalcType,lpCalcIndex,bCalcUseHeap,DummyTypeInfo.type,DummyTypeInfo.u.lpIndex);
+                }
             }
 
@@ -419 +442 @@
                                     }
                                 }
+                                else if(DummyTypeInfo.type==DEF_STRUCT){
+                                    if( !DummyTypeInfo.u.pobj_Class->IsEquals( (CClass *)lpVarIndex ) ){
+                                        SetError(11,Parms[i2],cp);
+                                    }
+                                }
                             }
                             else if((VarType&FLAG_PTR)&&((VarType^FLAG_PTR)==DummyTypeInfo.type)){
@@ -442 +470 @@
             }
         }
+
 next:
+
         if(reg==REG_RAX){
             //スタックフレームへコピー

BasicCompiler64/CommandValue.h

@@ -19 +19 @@
 #define COM_LET     0x1066
 #define COM_DELETE  0x1068
+#define COM_SWEEPINGDELETE  0x1069
 
 //その他

BasicCompiler64/Compile_Calc.cpp

@@ -11 +11 @@
         SetBooleanVariable(CalcType,pRelativeVar);
     }
-    else if(VarType==DEF_SBYTE||VarType==DEF_BYTE || (isUnicode==false&&VarType==DEF_CHAR)){
-        //8ビット変数へalレジスタの内容を格納する
-        SetWholeVariable(sizeof(char),CalcType,pRelativeVar);
-    }
-    else if(VarType==DEF_INTEGER||VarType==DEF_WORD || (isUnicode&&VarType==DEF_CHAR)){
-        //16ビット変数へaxレジスタの内容を格納する
-        SetWholeVariable(sizeof(short),CalcType,pRelativeVar);
-    }
-    else if(VarType==DEF_LONG||VarType==DEF_DWORD){
-        //32ビット変数へeaxレジスタの内容を格納する
-        SetWholeVariable(sizeof(long),CalcType,pRelativeVar);
-    }
-    else if(VarType==DEF_INT64||VarType==DEF_QWORD||IsPtrType(VarType)){
-        //64ビット変数へraxレジスタの内容を格納する
-        SetWholeVariable(sizeof(_int64),CalcType,pRelativeVar);
-    }
-    else if(VarType==DEF_DOUBLE){
-        //Double型変数へスタックの内容を格納する
-        SetDoubleVariable(CalcType,pRelativeVar);
-    }
-    else if(VarType==DEF_SINGLE){
-        //Single型変数へスタックの内容を格納する
-        SetSingleVariable(CalcType,pRelativeVar);
+    else if( IsRealNumberType( VarType ) ){
+        // Double/Single型変数へレジスタの値を代入
+        SetRealVariable(VarType, CalcType, pRelativeVar);
+    }
+    else if( IsWholeNumberType( VarType ) || VarType == DEF_OBJECT ){
+        int typeSize = GetTypeSize( VarType, -1 );
+
+        //整数変数へraxの値を格納する
+        SetWholeVariable( typeSize, CalcType, pRelativeVar );
     }
     else{
@@ -165 +151 @@
 
 
+    if( lstrcmpi( variable, "This" ) == 0 ){
+        SetError(133,NULL,cp);
+        return;
+    }
+
 
     ////////////////////////////////////////
@@ -195 +186 @@
     CalcType=NumOpe(&reg,Command+i+1,VarType,lpVarIndex,&lpCalcIndex,&bCalcUseHeap);
 
+    if(reg!=REG_RAX&&IsWholeNumberType(CalcType)){
+        SetError(300,NULL,cp);
+    }
+
+    if(VarType==-1||CalcType==-1) return;
+
     //結果を格納しているレジスタをブロッキング
     pobj_BlockReg->lock(reg);
-
-    if(VarType==-1||CalcType==-1) return;
 
     //変数アドレスを取得
@@ -206 +201 @@
         &VarType,
         &VarRelativeVar,
-        &lpVarIndex)) return;
+        &lpVarIndex,
+        NULL)) return;
 
     //レジスタのブロッキングを解除
@@ -216 +212 @@
     }
 
-    if(VarType==DEF_OBJECT){
-        //オブジェクトインスタンスへの代入
-        SetObjectVariableFromRax(lpVarIndex,CalcType,lpCalcIndex,&VarRelativeVar,bCalcUseHeap);
-        return;
-    }
-
-    if(CalcType==DEF_OBJECT){
+    if(VarType==DEF_STRUCT ){
+        //構造体インスタンスへの代入
+        SetStructVariableFromRax(lpVarIndex,CalcType,lpCalcIndex,&VarRelativeVar,bCalcUseHeap);
+        return;
+    }
+
+    if(CalcType==DEF_OBJECT && (CalcType!=VarType || lpCalcIndex!=lpVarIndex) ){
         //キャスト演算子のオーバーロードに対応する
         CallCastOperatorProc(REG_RAX,CalcType,lpCalcIndex,bCalcUseHeap,VarType,lpVarIndex);
@@ -241 +237 @@
 }
 
+// TODO: 消す
+/*
 void SetRefVariable( const char *varname, const char *expression ){
     ////////////////////////////////////////
@@ -320 +318 @@
     SetVariableFromRax(VarType,CalcType,&VarRelativeVar);
 }
+*/

BasicCompiler64/Compile_CallProc.cpp

@@ -12 +12 @@
 
     //mov rdx,rax
-    op_mov64_ToReg_FromReg(REG_RDX,REG_RAX);
+    op_mov_RR(REG_RDX,REG_RAX);
 
     //mov rcx,rsp
-    op_mov64_ToReg_FromReg(REG_RCX,REG_RSP);
+    op_mov_RR(REG_RCX,REG_RSP);
 
     //call _DebugSys_SaveContext
@@ -96 +96 @@
 }
 
-void Opcode_CallProc(char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType){
+void Opcode_CallProc(const char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType){
     int i2;
 
@@ -207 +207 @@
 
     ///////////////////////////////////////////////////////////////
-    // _System_LocalThis、_System_ReturnObjectのダミーをセット
+    // _System_LocalThisのダミーをセット
     ///////////////////////////////////////////////////////////////
 
@@ -216 +216 @@
     }
 
-    if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false ){
-        //_System_ReturnObject（第一または第二パラメータのダミーを作成）
-        sprintf(temporary+lstrlen(temporary),"%c%c0,",1,ESC_BYVAL);
-    }
-
     if(Parameter[0]=='\0'&&temporary[0])
         temporary[lstrlen(temporary)-1]=0;
     else lstrcat(temporary,Parameter);
+
+
+    //パラメータセット前のspオフセットを取得（Newの場合はここにThisポインタが格納されている）
+    int this_sp_offset = pobj_sf->GetNowSp();
 
 
@@ -254 +253 @@
     pobj_parameter->SetParameter(psi->name,psi->pRealParmInfo,psi->RealParmNum,psi->RealSecondParmNum);
 
-
-    if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
+    if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
         //////////////////////////////////////////////////////
-        // 戻り値にオブジェクト インスタンスを持つ場合
-        // ※ByRef _System_ReturnObject パラメータをセット
+        // 戻り値に構造体インスタンスを持つ場合
+        // ※ByRef _System_ReturnValue パラメータをセット
         //////////////////////////////////////////////////////
 
@@ -316 +314 @@
                 SetVarPtrToReg(REG_RCX,&RelativeVar);
 
-                //参照タイプが "->" の場合
-                if(RefType==DEF_PTR_OBJECT){
-                    //mov rcx,qword ptr[rcx]
-                    op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
-                }
+                // 参照を実体ポインタにする
+                //mov rcx,qword ptr[rcx]
+                op_mov_RM(sizeof(_int64),REG_RCX,REG_RCX,0,MOD_BASE);
             }
         }
@@ -329 +325 @@
 
                 //mov rcx,qword ptr[rsp+offset]     ※スタックフレームを利用
-                pobj_sf->ref(REG_RCX);
+                pobj_sf->ref_offset_data(REG_RCX, this_sp_offset);
             }
             else{

BasicCompiler64/Compile_Func.cpp

@@ -62 +62 @@
 
     TYPEINFO TypeInfo={type,lpIndex};
-    if(IsStringObjectType(&TypeInfo)){
+    if(IsStringObjectType(TypeInfo)){
         //Stringオブジェクトの場合
         sprintf(temporary,"%s.Length",tempParm);
@@ -195 +195 @@
 }
 void Opcode_Func_SizeOf( const char *Parameter ){
-    int type,size;
     LONG_PTR lpIndex;
-
-    type=GetTypeFixed(Parameter,&lpIndex);
-    size=GetTypeSize(type,lpIndex);
+    int type = GetTypeFixed(Parameter,&lpIndex);
+
+    int size;
+    if( type == DEF_OBJECT ){
+        CClass *pClass = (CClass *)lpIndex;
+        size = pClass->GetSize();
+    }
+    else{
+        size=GetTypeSize(type,lpIndex);
+    }
 
     //mov rax,size
@@ -210 +216 @@
     if(!GetVarOffsetReadOnly( Parameter, &ReturnTypeInfo.type, &RelativeVar, &ReturnTypeInfo.u.lpIndex )) return;
 
+    int beforeType = ReturnTypeInfo.type;
+
     PTR_LEVEL_UP( ReturnTypeInfo.type );
 
     SetVarPtrToReg(REG_RAX,&RelativeVar);
+
+    if( beforeType == DEF_OBJECT && lstrcmpi( Parameter, "This" ) != 0 ){
+        //参照をオブジェクトポインタに変更
+
+        //mov rax,qword ptr[rax]
+        op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
+    }
 }
 void Opcode_Func_GetPtrData( const char *Parameter, const int type ){

BasicCompiler64/Compile_Object.cpp

@@ -2 +2 @@
 #include "opcode.h"
 
-void _call_constructor(CClass *pobj_c,char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
+void _call_constructor(CClass *pobj_c,const char *CreateParameter,int ObjectSize,BOOL bSomeObjects){
     ////////////////////////////
     // コンストラクタの呼び出し
@@ -73 +73 @@
     }
 }
-int Operator_New(const char *Parameter,LONG_PTR *plpIndex){
-    char TypeName[VN_SIZE],CreateParameter[VN_SIZE],ObjectSize[VN_SIZE];
+void Operator_New( CClass &classObj, const char *objectSizeStr, const char *parameter, const TYPEINFO &baseTypeInfo ){
+    int typeSize = classObj.GetSize();
+
+    if(classObj.IsAbstract()){
+        //抽象クラスだったとき
+        SetError(125,classObj.name,cp);
+    }
+
+    BOOL bSomeObjects=0;
+    if(objectSizeStr[0]){
+        bSomeObjects=1;
+
+        int reg=REG_RAX;
+        int type = NumOpe(&reg,objectSizeStr,0,0,0);
+        if(!IsWholeNumberType(type)) SetError(49,NULL,cp);
+
+        //※添え字上限値であることを考慮
+        //add rax,1
+        op_add_RV(REG_RAX,1);
+
+        //オブジェクトの個数をrbxに一時保持
+        //※rbxは関数が呼ばれても不変
+        //mov rbx,rax
+        op_mov_RR(REG_RBX,REG_RAX);
+
+        //imul rax,size
+        op_imul_RV(sizeof(_int64),REG_RAX,typeSize);
+
+        //add rax,PTR_SIZE*3
+        op_add_RV(REG_RAX,PTR_SIZE*3);
+
+        //mov rcx,rax
+        op_mov_RR(REG_RCX,REG_RAX);
+    }
+    else{
+        //オブジェクトの個数をrbxに一時保持
+        //※rbxは関数が呼ばれても不変
+        //mov rbx,1
+        op_mov_RV(sizeof(_int64),REG_RBX,1);
+
+        //mov rcx,typeSize+PTR_SIZE*3
+        op_mov_RV(sizeof(_int64),REG_RCX,typeSize+PTR_SIZE*3);
+    }
+
+    if( baseTypeInfo.type == DEF_OBJECT ){
+        //DeleteはGCで処理
+
+        //call _System_GC_malloc_ForObject
+        extern SUBINFO *pSub_System_GC_malloc_ForObject;
+        op_call(pSub_System_GC_malloc_ForObject);
+    }
+    else{
+        //明示的なDeleteが必要
+
+        //call _System_GC_malloc_ForObjectPtr
+        extern SUBINFO *pSub_System_GC_malloc_ForObjectPtr;
+        op_call(pSub_System_GC_malloc_ForObjectPtr);
+    }
+
+
+    /*
+    確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
+    pPtr-=sizeof(DWORD)*3
+    pPtr[0]=オブジェクトの個数
+    pPtr[1]=オブジェクトのサイズ
+    pPtr[2]=デストラクタの関数ポインタ
+    */
+
+
+    //mov qword ptr[rax],rbx（オブジェクトの個数）
+    op_mov_MR(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);
+
+    //add rax,PTR_SIZE
+    op_add_RV(REG_RAX,PTR_SIZE);
+
+
+    //mov qword ptr[rax],typeSize（オブジェクトのサイズ）
+    op_mov_MV(sizeof(_int64),REG_RAX,0,NON_OFFSET,typeSize);
+
+    //add rax,PTR_SIZE
+    op_add_RV(REG_RAX,PTR_SIZE);
+
+
+    CMethod *method = classObj.GetDestructorMethod();
+    if( method == NULL ) return;
+
+    //mov rcx,DestructorProcAddr
+    op_mov_RV(sizeof(_int64),REG_RCX,0);
+    obp-=sizeof(long);
+    pobj_SubAddrSchedule->add(method->psi,0);
+    method->psi->bUse=1;
+    obp+=sizeof(long);
+
+    //mov qword ptr[rax],rcx
+    op_mov_MR(sizeof(_int64),REG_RCX,REG_RAX,0,MOD_BASE);
+
+    //add rax,PTR_SIZE
+    op_add_RV(REG_RAX,PTR_SIZE);
+
+
+    // ※ここでプッシュされた値はNew演算子の戻り値となる
+    //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
+    pobj_sf->push(REG_RAX);
+
+
+    /////////////////////////////////////////////////////////////////////
+
+    ////////////////////////////
+    // コンストラクタの呼び出し
+    ////////////////////////////
+
+    _call_constructor(&classObj,parameter,typeSize,bSomeObjects);
+
+
+    //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
+    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;
-    int reg;
 
     i=0;
 
     if(Parameter[0]=='['){
-        i=GetStringInBracket(ObjectSize,Parameter);
-
-        SlideString(ObjectSize+1,-1);
-        ObjectSize[i-2]=0;
-    }
-    else ObjectSize[0]=0;
+        i=GetStringInBracket(objectSizeStr,Parameter);
+
+        SlideString(objectSizeStr+1,-1);
+        objectSizeStr[i-2]=0;
+    }
+    else objectSizeStr[0]=0;
 
     for(i2=0;;i++,i2++){
@@ -109 +225 @@
     }
 
-    int type,TypeSize;
+    int type;
     type=GetTypeFixed(TypeName,plpIndex);
     if(type==-1){
@@ -115 +231 @@
         return 0;
     }
-    TypeSize=GetTypeSize(type,*plpIndex);
 
     if(type!=DEF_OBJECT){
@@ -129 +244 @@
     pobj_c=(CClass *)*plpIndex;
 
-    if(pobj_c->IsAbstract()){
-        //抽象クラスだったとき
-        SetError(125,pobj_c->name,cp);
-    }
-
-    BOOL bSomeObjects=0;
-    if(ObjectSize[0]){
-        bSomeObjects=1;
-
-        reg=REG_RAX;
-        i2=NumOpe(&reg,ObjectSize,0,0,0);
-        if(!IsWholeNumberType(i2)) SetError(49,NULL,cp);
-
-        //※添え字上限値であることを考慮
-        //add rax,1
-        op_add64_value(REG_RAX,1);
-
-        //オブジェクトの個数をrbxに一時保持
-        //※rbxは関数が呼ばれても不変
-        //mov rbx,rax
-        op_mov64_ToReg_FromReg(REG_RBX,REG_RAX);
-
-        //imul rax,size
-        op_imul_value(sizeof(_int64),REG_RAX,TypeSize);
-
-        //add rax,PTR_SIZE*3
-        op_add64_value(REG_RAX,PTR_SIZE*3);
-
-        //mov rcx,rax
-        op_mov64_ToReg_FromReg(REG_RCX,REG_RAX);
-    }
-    else{
-        //オブジェクトの個数をrbxに一時保持
-        //※rbxは関数が呼ばれても不変
-        //mov rbx,1
-        op_mov_RV(sizeof(_int64),REG_RBX,1);
-
-        //mov rcx,TypeSize+PTR_SIZE*3
-        op_mov_RV(sizeof(_int64),REG_RCX,TypeSize+PTR_SIZE*3);
-    }
-
-    //call calloc
-    extern SUBINFO *pSub_calloc;
-    op_call(pSub_calloc);
-
-
-    /*
-    確保されたヒープ領域のポインタ（callocの戻り値eax）をpPtrとすると、
-    pPtr-=sizeof(DWORD)*3
-    pPtr[0]=オブジェクトの個数
-    pPtr[1]=オブジェクトのサイズ
-    pPtr[2]=デストラクタの関数ポインタ
-    */
-
-
-    //mov qword ptr[rax],rbx（オブジェクトの個数）
-    op_mov_MR(sizeof(_int64),REG_RBX,REG_RAX,0,MOD_BASE);
-
-    //add rax,PTR_SIZE
-    op_add64_value(REG_RAX,PTR_SIZE);
-
-
-    //mov qword ptr[rax],TypeSize（オブジェクトのサイズ）
-    op_mov_MV(sizeof(_int64),REG_RAX,0,NON_OFFSET,TypeSize);
-
-    //add rax,PTR_SIZE
-    op_add64_value(REG_RAX,PTR_SIZE);
-
-
-    CMethod *method = pobj_c->GetDestructorMethod();
-    if( method == NULL ) return 0;
-
-    //mov rcx,DestructorProcAddr
-    op_mov_RV(sizeof(_int64),REG_RCX,0);
-    obp-=sizeof(long);
-    pobj_SubAddrSchedule->add(method->psi,0);
-    method->psi->bUse=1;
-    obp+=sizeof(long);
-
-    //mov qword ptr[rax],rcx
-    op_mov_MR(sizeof(_int64),REG_RCX,REG_RAX,0,MOD_BASE);
-
-    //add rax,PTR_SIZE
-    op_add64_value(REG_RAX,PTR_SIZE);
-
-
-    // ※ここでプッシュされた値はNew演算子の戻り値となる
-    //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
-    pobj_sf->push(REG_RAX);
-
-
-    /////////////////////////////////////////////////////////////////////
-
-    ////////////////////////////
-    // コンストラクタの呼び出し
-    ////////////////////////////
-
-    _call_constructor(pobj_c,CreateParameter,TypeSize,bSomeObjects);
-
-
-    //mov rax,qword ptr[rsp+offset]     ※スタックフレームを利用
-    pobj_sf->pop(REG_RAX);
-
+    Operator_New( *pobj_c, objectSizeStr, CreateParameter, baseTypeInfo );
+
+    if( baseTypeInfo.type == DEF_OBJECT ){
+        return DEF_OBJECT;
+    }
     return DEF_PTR_OBJECT;
 }
 
-void OpcodeDelete(const char *Parameter){
+void OpcodeDelete(const char *Parameter, bool isSweeping){
     int type;
 
@@ -254 +271 @@
 
     //add rax,PTR_SIZE
-    op_add64_value(REG_RAX,PTR_SIZE);
+    op_add_RV(REG_RAX,PTR_SIZE);
 
 
@@ -261 +278 @@
 
     //add rax,PTR_SIZE
-    op_add64_value(REG_RAX,PTR_SIZE);
+    op_add_RV(REG_RAX,PTR_SIZE);
 
 
@@ -268 +285 @@
 
     //add rax,PTR_SIZE
-    op_add64_value(REG_RAX,PTR_SIZE);
+    op_add_RV(REG_RAX,PTR_SIZE);
 
 
     //mov rcx,rax
-    op_mov64_ToReg_FromReg(REG_RCX,REG_RAX);
+    op_mov_RR(REG_RCX,REG_RAX);
 
 
@@ -279 +296 @@
     jnz_back=obp;
 
-    //mov qword ptr[rsp+offset],rax     ※スタックフレームを利用
-    pobj_sf->push(REG_RAX);
+    //mov qword ptr[rsp+offset],rcx     ※スタックフレームを利用
+    pobj_sf->push(REG_RCX);
 
     //call rdi
@@ -309 +326 @@
     pobj_sf->pop(REG_RCX);
 
-    //call free
-    extern SUBINFO *pSub_free;
-    op_call(pSub_free);
+    if( isSweeping ){
+        //call _System_GC_free_for_SweepingDelete
+        extern SUBINFO *pSub_System_GC_free_for_SweepingDelete;
+        op_call(pSub_System_GC_free_for_SweepingDelete);
+    }
+    else{
+        //call free
+        extern SUBINFO *pSub_free;
+        op_call(pSub_free);
+    }
 }

BasicCompiler64/Compile_ProcOp.cpp

@@ -51 +51 @@
 
         //add rsp,スタックフレームサイズ
-        op_add64_value(REG_RSP,pobj_sf->GetFrameSize());
+        op_add_RV(REG_RSP,pobj_sf->GetFrameSize());
 
         //スタックフレームスケジュール（subコマンドに渡す値）
@@ -94 +94 @@
 
         //add rsp,スタックフレームサイズ
-        op_add64_value(REG_RSP,pobj_sf->GetFrameSize());
+        op_add_RV(REG_RSP,pobj_sf->GetFrameSize());
 
         //スタックフレームスケジュール（subコマンドに渡す値）
@@ -118 +118 @@
 
         //add rsp,8
-        op_add64_value(REG_RSP,0x8);
+        op_add_RV(REG_RSP,0x8);
 
         //ret
@@ -128 +128 @@
 
         //add rax,PTR_SIZE
-        op_add64_value(REG_RAX,PTR_SIZE);
+        op_add_RV(REG_RAX,PTR_SIZE);
 
         //ret
@@ -337 +337 @@
 
         LocalVar[MaxLocalVarNum].type=psi->pRealParmInfo[i3].type;
-        if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT){
-            if(psi->bExport)
-                SetError(24,NULL,cp);
+        if(LocalVar[MaxLocalVarNum].type==DEF_OBJECT
+            ||LocalVar[MaxLocalVarNum].type==DEF_STRUCT){
+                if(psi->bExport)
+                    SetError(24,NULL,cp);
         }
 
         LocalVar[MaxLocalVarNum].u.index=psi->pRealParmInfo[i3].u.index;
 
-        if(psi->pRealParmInfo[i3].bByVal&&psi->pRealParmInfo[i3].type==DEF_OBJECT){
-            //実態オブジェクトのByValパラメータ
+        if(psi->pRealParmInfo[i3].bByVal&&psi->pRealParmInfo[i3].type==DEF_STRUCT){
+            //構造体のByValパラメータ
             LocalVar[MaxLocalVarNum].fRef=REF_PARAMETER | OBJECT_PARAMETER;
             VarSize=PTR_SIZE;
@@ -457 +458 @@
     BaseLocalVar=AllLocalVarSize;
 
-    if(psi->ReturnType!=-1){
+    if(psi->ReturnType!=DEF_NON){
         //戻り値が存在するとき
 
@@ -464 +465 @@
         else temp=psi->name;
 
-        if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
-            //戻り値用オブジェクトのコンストラクタを呼び出す
-            if( psi->u.Return_pobj_c->GetConstructorMethod() ){
-                sprintf(temporary,"%s.%s()",temp,psi->u.Return_pobj_c->name);
-                OpcodeOthers(temporary);
-            }
+        if(psi->ReturnType==DEF_STRUCT && psi->isReturnRef == false){
+            //戻り値用の構造体（値型）はパラメータで引き渡される
         }
         else{
@@ -493 +490 @@
 
         //mov rcx,rsp
-        op_mov64_ToReg_FromReg(REG_RCX,REG_RSP);
+        op_mov_RR(REG_RCX,REG_RSP);
 
         //add rcx,スタックフレームサイズ+sizeof(_int64) ※ret用のサイズを考慮
-        op_add64_value(REG_RCX,0);
+        op_add_RV(REG_RCX,0);
         RspOffsetSchedule2=obp-sizeof(long);
 
@@ -571 +568 @@
             for(i3=0;i3<pobj_CompilingClass->iMemberNum;i3++){
                 CMember *pMember = pobj_CompilingClass->ppobj_Member[i3];
-                int MemberTypeSize=
-                    GetTypeSize(pMember->TypeInfo.type,
-                        pMember->TypeInfo.u.lpIndex);
-
-                int MemberObjectNum=
-                    JumpSubScripts(pMember->SubScripts);
-
-                int offset = pobj_CompilingClass->GetMemberOffset( pMember->name, NULL );
-
-                if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef() == false){
-                    CMethod *method = pMember->TypeInfo.u.pobj_Class->GetConstructorMethod();
-                    if( method ){
-                        if( method->psi->RealParmNum == 1 ){    //Thisポインタを第一引数に持ち合わせるため、引数なしの場合はこの値が1になる
-                            for(i4=0;i4<MemberObjectNum;i4++){
-                                //Thisポインタをrcxにコピー
-                                SetThisPtrToReg(REG_RCX);
-
-                                //add rcx,offset
-                                op_add64_value(REG_RCX,offset+i4*MemberTypeSize);
-
-                                //call constructor
-                                op_call( method->psi );
-                            }
-                        }
-                    }
+                if(pMember->TypeInfo.type==DEF_OBJECT){
+                    // オブジェクトメンバを発見したとき
+
+                    sprintf(temporary, "This.%s=%c%c%s()",
+                        pMember->name,
+                        1, ESC_NEW,
+                        pMember->TypeInfo.u.pobj_Class->name );
+                    OpcodeCalc( temporary );
                 }
             }
@@ -665 +645 @@
             }
 
-            //実体クラスを持つメンバのデストラクタを呼び出す
+            //実体クラスを持つメンバのデストラクタ呼び出しはGCに任せる
+            /*
             //※コンストラクタと逆順序で呼び出す
             for(i3=pobj_CompilingClass->iMemberNum-1;i3>=0;i3--){
@@ -678 +659 @@
                 int offset = pobj_CompilingClass->GetMemberOffset( pMember->name, NULL );
 
-                if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef() == false){
+                if(pMember->TypeInfo.type==DEF_OBJECT){
                     CMethod *method = pMember->TypeInfo.u.pobj_Class->GetDestructorMethod();
                     if( method ){
@@ -686 +667 @@
 
                             //add rcx,offset
-                            op_add64_value(REG_RCX,offset+i4*MemberTypeSize);
+                            op_add_RV(REG_RCX,offset+i4*MemberTypeSize);
 
                             //call destructor
@@ -693 +674 @@
                     }
                 }
-            }
+            }*/
         }
     }
@@ -743 +724 @@
     }
 
-    if(psi->ReturnType!=-1){
+    if(psi->ReturnType!=DEF_NON){
         //////////////////////////////////
         // 戻り値をraxまたはxmm0に設定
@@ -759 +740 @@
         i3=psi->ReturnType;
 
-        if(i3==DEF_OBJECT){
+        if(i3==DEF_OBJECT || i3==DEF_STRUCT){
             SetVarPtrToReg(REG_RAX,&RelativeVar);
+            if( i3==DEF_OBJECT ){
+                //mov rax,qword ptr[rax]
+                op_mov_RM( sizeof(_int64), REG_RAX, REG_RAX, 0, MOD_BASE );
+            }
         }
         else if(i3==DEF_DOUBLE){

BasicCompiler64/Compile_Set_Var.cpp

@@ -7 +7 @@
 }
 
-void SetObjectVariableFromRax(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,RELATIVE_VAR *pRelativeVar,BOOL bUseHeap){
+void SetStructVariableFromRax(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,RELATIVE_VAR *pRelativeVar,BOOL bUseHeap){
     int RightTermReg;
     pobj_reg=new CRegister(REG_RCX);
@@ -36 +36 @@
     }
 
-
+/*
+    TODO: 消す
     ///////////////////////////////////////////////////////////////////
     // オペレータ '=' のオーバーロード関数を呼ぶ
@@ -59 +60 @@
     int iRet;
     iRet=CallOperatorProc(CALC_SUBSITUATION,NULL,type,index_stack,array_bUseHeap,sp);
-
+*/
     //右辺用レジスタを解除
     if(IsRealNumberType(CalcType)) pobj_reg->UnlockXmmReg();
@@ -71 +72 @@
     pobj_reg=0;
 
-    if(iRet==-1||iRet==1){
-        //成功したとき、またはエラーが発行されたとき
-        return;
-    }
-
-
-    if( CalcType == DEF_OBJECT ){
+
+    if( CalcType == DEF_STRUCT ){
         CClass *pVarClass = (CClass *)lpVarIndex;
         CClass *pCalcClass = (CClass *)lpCalcIndex;
 
-        if( pVarClass->IsEquals( pCalcClass )           //等しい
-            || pVarClass->IsSubClass( pCalcClass ) ){   //派生・継承関係
+        if( pVarClass->IsEquals( pCalcClass ) ){            //等しい
 
                 //双方のオブジェクト型が一致、または派生・継承関係にあるとき
@@ -122 +117 @@
     SetError(1,NULL,cp);
 }
+
 
 void SetDoubleVariable(int type,RELATIVE_VAR *pRelative){
@@ -305 +301 @@
     }
 }
+void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar){
+    if(VarType==DEF_DOUBLE){
+        //Double型変数へスタックの内容を格納する
+        SetDoubleVariable(CalcType,pRelativeVar);
+    }
+    else if(VarType==DEF_SINGLE){
+        //Single型変数へスタックの内容を格納する
+        SetSingleVariable(CalcType,pRelativeVar);
+    }
+}
 void SetBooleanVariable(int type,RELATIVE_VAR *pRelative){
     if(type==DEF_DOUBLE){

BasicCompiler64/Compile_Statement.cpp

@@ -99 +99 @@
         /////////////////////
 
-        if(i2==DEF_OBJECT){
+        if(i2==DEF_STRUCT){
             //mov r14,rax
             op_mov_RR(REG_R14,REG_RAX);
@@ -888 +888 @@
     //add rax,offset（Gosubステートメントの最終ポイント）
     int schedule=obp,schedule2;
-    op_add64_value(REG_RAX,0);
+    op_add_RV(REG_RAX,0);
     schedule2=obp-sizeof(long);
 
@@ -951 +951 @@
             else temp=pCompilingSubInfo->name;
 
+            /*
+            TODO: 消す
             if( pCompilingSubInfo->isReturnRef ){
                 //参照型
@@ -956 +958 @@
             }
             else{
-                //値型
+                //値型*/
                 char temporary[VN_SIZE];
                 sprintf(temporary,"%s=%s",temp,Parameter);
                 OpcodeCalc(temporary);
-            }
+            //}
         }
 
@@ -968 +970 @@
 }
 
-void Opcode_Input(char *Parameter){
+void Opcode_Input(const char *Parameter){
     extern int cp;
     int i2,i3,i4,i5,type;
     BOOL bFile;
     char temporary[VN_SIZE],temp2[VN_SIZE],buffer[VN_SIZE];
-
-    KillStringSpaces(Parameter);
 
     if(Parameter[0]=='#'){
@@ -1084 +1084 @@
     Opcode_CallProc(buffer,psi,0,"",0);
 }
-void Opcode_PrintUsing(char *Parameter,char *buffer,BOOL bFile){
+void Opcode_PrintUsing(const char *Parameter,char *buffer,BOOL bFile){
     extern int cp;
     int i2,i3,i4,i5;
@@ -1090 +1090 @@
     BOOL bReturnLine;
 
-    i2=lstrlen(Parameter);
-    if(Parameter[i2-1]==';'){
+    char parms[8192];
+    lstrcpy( parms, Parameter );
+
+    i2=lstrlen(parms);
+    if(parms[i2-1]==';'){
         bReturnLine=0;
-        Parameter[i2-1]=0;
+        parms[i2-1]=0;
     }
     else bReturnLine=1;
@@ -1099 +1102 @@
     i3=lstrlen(buffer);
     for(i2=0;;i2++,i3++){
-        if(Parameter[i2]==';'){
+        if(parms[i2]==';'){
             buffer[i3]=0;
             break;
         }
-        buffer[i3]=Parameter[i2];
-        if(Parameter[i2]=='\0') break;
-    }
-    if(Parameter[i2]==';') i2++;
+        buffer[i3]=parms[i2];
+        if(parms[i2]=='\0') break;
+    }
+    if(parms[i2]==';') i2++;
 
     if(bReturnLine) lstrcat(buffer,"+Ex\"\\r\\n\"");
@@ -1114 +1117 @@
     while(1){
         for(i3=0;;i2++,i3++){
-            if(Parameter[i2]=='\"'){
-                temporary[i3]=Parameter[i2];
+            if(parms[i2]=='\"'){
+                temporary[i3]=parms[i2];
                 for(i2++,i3++;;i2++,i3++){
-                    temporary[i3]=Parameter[i2];
-                    if(Parameter[i2]=='\"') break;
+                    temporary[i3]=parms[i2];
+                    if(parms[i2]=='\"') break;
                 }
                 continue;
             }
-            if(Parameter[i2]=='('){
-                i5=GetStringInPare(temporary+i3,Parameter+i2);
+            if(parms[i2]=='('){
+                i5=GetStringInPare(temporary+i3,parms+i2);
                 i2+=i5-1;
                 i3+=i5-1;
                 continue;
             }
-            if(Parameter[i2]=='['){
-                i5=GetStringInBracket(temporary+i3,Parameter+i2);
+            if(parms[i2]=='['){
+                i5=GetStringInBracket(temporary+i3,parms+i2);
                 i2+=i5-1;
                 i3+=i5-1;
                 continue;
             }
-            if(Parameter[i2]==','){
+            if(parms[i2]==','){
                 temporary[i3]=0;
                 i2++;
                 break;
             }
-            temporary[i3]=Parameter[i2];
-            if(Parameter[i2]=='\0') break;
+            temporary[i3]=parms[i2];
+            if(parms[i2]=='\0') break;
         }
         if(temporary[0]=='\0'){
@@ -1169 +1172 @@
 
         i4++;
-        if(Parameter[i2]=='\0') break;
+        if(parms[i2]=='\0') break;
     }
     sprintf(temp2,"_System_UsingDataType[%d]=-1",i4);
@@ -1183 +1186 @@
     Opcode_CallProc(buffer,psi,0,"",0);
 }
-void Opcode_Print(char *Parameter,BOOL bWrite){
+void Opcode_Print(const char *Parameter,BOOL bWrite){
     int i2,i3,i4,sw;
     char temporary[VN_SIZE],buffer[VN_SIZE];
     BOOL bFile;
-
-    KillStringSpaces(Parameter);
 
     if(Parameter[0]=='#'){

BasicCompiler64/Compile_Var.cpp

@@ -41 +41 @@
 
     if(PTR_LEVEL(*pType)){
-        *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
-        if((*pType)==DEF_OBJECT){
-            CClass *pClass = (CClass *)lpIndex;
-            //imul reg,objsize
-            op_imul_value( sizeof(_int64), reg, pClass->GetSize() );
-        }
-        else{
-            i2=GetTypeSize(*pType,-1);
-            if(i2>=2){
-                //imul reg,i2
-                op_imul_value(sizeof(_int64),reg,i2);
-            }
+        *pType = PTR_LEVEL_DOWN( *pType );
+
+        i2=GetTypeSize(*pType,-1);
+        if(i2>=2){
+            //imul reg,i2
+            op_imul_RV(sizeof(_int64),reg,i2);
         }
     }
@@ -71 +65 @@
     //add r11,reg
     op_add64_reg(REG_R11,reg);
+}
+void SetRelativeOffset( RELATIVE_VAR &relativeVar ){
+    if(relativeVar.dwKind==VAR_DIRECTMEM){
+        //mov r11,qword ptr[r11]
+        op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
+    }
+    else{
+        //直接参照に切り替え
+        SetVarPtrToReg(REG_R12,&relativeVar);
+        relativeVar.dwKind=VAR_DIRECTMEM;
+
+        //mov r11,qword ptr[r12]
+        op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
+    }
 }
 BOOL GetArrayOffset(int *SubScripts,char *array,int type,LONG_PTR lpIndex){
@@ -153 +161 @@
 
         //imul reg,i4
-        op_imul_value(sizeof(_int64),reg,i4);
+        op_imul_RV(sizeof(_int64),reg,i4);
 
         //add r12,reg
@@ -192 +200 @@
     char lpPtrOffset[VN_SIZE];  //第2次配列
     char NestMember[VN_SIZE];   //入れ子メンバ
-    int RefType;                //"."参照のときは0、"->"参照のときは1
+    CClass::RefType refType;
     lstrcpy(VarName,member);
-    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;
+    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
 
 
@@ -279 +287 @@
         //入れ子構造の場合
 
-        if(*pType==DEF_OBJECT && pMember->IsRef() == false){
-            if(RefType!=DEF_OBJECT){
+        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
+            if( refType != CClass::Dot ){
                 if(isErrorEnabled) SetError(104,member,cp);
                 return 0;
             }
-        }
-        else if(*pType==DEF_PTR_OBJECT || ( *pType==DEF_OBJECT && pMember->IsRef() )){
+
+            if( *pType==DEF_OBJECT ){
+                // 参照内容へのポインタを抽出
+                SetRelativeOffset( *pRelativeVar );
+            }
+        }
+        else if(*pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT){
             //構造体ポインタ型メンバ変数
 
             if(lpPtrOffset[0]){
                 //pObj[n].member
-                if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_OBJECT){
+                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Dot ){
                     if(isErrorEnabled) SetError(104,member,cp);
                     return 0;
@@ -303 +316 @@
             else{
                 //pObj->member
-                if(*pType==DEF_PTR_OBJECT&&RefType!=DEF_PTR_OBJECT){
+                if( ( *pType==DEF_PTR_OBJECT||*pType==DEF_PTR_STRUCT )&& refType != CClass::Pointer ){
                     if(isErrorEnabled) SetError(104,member,cp);
                     return 0;
                 }
 
-                if(pRelativeVar->dwKind==VAR_DIRECTMEM){
-                    //mov r11,qword ptr[r11]
-                    op_mov_RM(sizeof(_int64),REG_R11,REG_R11,0,MOD_BASE);
-                }
-                else{
-                    //直接参照に切り替え
-                    SetVarPtrToReg(REG_R12,pRelativeVar);
-                    pRelativeVar->dwKind=VAR_DIRECTMEM;
-
-                    //mov r11,qword ptr[r12]
-                    op_mov_RM(sizeof(_int64),REG_R11,REG_R12,0,MOD_BASE);
-                }
-            }
-        }
-        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
+                SetRelativeOffset( *pRelativeVar );
+            }
+        }
+        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
             //構造体ポインタのポインタ型メンバ変数
 
             if(lpPtrOffset[0]){
                 //ppObj[n]->member
-                if(RefType!=DEF_PTR_OBJECT){
+                if( refType != CClass::Pointer ){
                     if(isErrorEnabled) SetError(104,member,cp);
                     return 0;
@@ -388 +390 @@
 BOOL GetVarOffset(bool isErrorEnabled,bool isWriteAccess,const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
     extern BOOL bCompilingGlobal;
-    int i,RefType;
+    int i;
     LONG_PTR lpIndex;
     char variable[VN_SIZE],member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
@@ -398 +400 @@
     else lstrcpy(variable,NameBuffer);
 
-    if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
+    CClass::RefType refType;
+    if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){
         // 戻り値オブジェクトのメンバを直接参照しているとき
         //例: func().member
@@ -442 +445 @@
 
     lstrcpy(VarName,variable);
-    GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
+    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
 
     int *pSubScripts;
@@ -581 +584 @@
         char tempMember[VN_SIZE];
         char tempArray[VN_SIZE];
-        GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);
+        {
+            CClass::RefType refType;
+            GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember, refType );
+        }
 
         char temp2[VN_SIZE];
@@ -697 +703 @@
     }
     if(member[0]){
-        if(*pType==DEF_OBJECT){
+        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
             //実態オブジェクトのメンバを参照（obj.member）
-            if(RefType!=DEF_OBJECT){
+            if( refType != CClass::Dot ){
                 SetError(104,VarName,cp);
                 pRelativeVar->dwKind=NON_VAR;
                 return 0;
             }
-        }
-        else if(*pType==DEF_PTR_OBJECT){
+
+            if( *pType==DEF_OBJECT ){
+                // 参照内容へのポインタを抽出
+                SetRelativeOffset( *pRelativeVar );
+            }
+        }
+        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
             //ポインタオブジェクトが示すメンバを参照
             if(lpPtrOffset[0]){
                 //pObj[n].member
-                if(RefType!=DEF_OBJECT){
+                if( refType != CClass::Dot ){
                     SetError(104,VarName,cp);
                     pRelativeVar->dwKind=NON_VAR;
@@ -719 +730 @@
             else{
                 //pObj->member
-                if(RefType!=DEF_PTR_OBJECT){
+                if( refType != CClass::Pointer ){
                     SetError(104,VarName,cp);
                     pRelativeVar->dwKind=NON_VAR;
@@ -732 +743 @@
             }
         }
-        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2)){
+        else if(*pType==MAKE_PTR_TYPE(DEF_OBJECT,2) || *pType==MAKE_PTR_TYPE(DEF_STRUCT,2)){
             //ポインタオブジェクトが示すメンバを参照
             if(lpPtrOffset[0]){
                 //ppObj[n]->member
-                if(RefType!=DEF_PTR_OBJECT){
+                if( refType != CClass::Pointer ){
                     SetError(104,VarName,cp);
                     pRelativeVar->dwKind=NON_VAR;
@@ -815 +826 @@
         }
 
-        if(type==DEF_OBJECT){
+        if(type==DEF_STRUCT){
             CClass *pobj_c;
             pobj_c=(CClass *)lpIndex;
@@ -848 +859 @@
     ///////////////////////////////////////
 
-    if( type == DEF_OBJECT){
-        //オブジェクトの場合はありえない
+    if( type == DEF_OBJECT || type == DEF_STRUCT ){
+        //オブジェクトまたは構造体の場合はありえない
         SetError(300,NULL,cp);
         return 0;
@@ -888 +899 @@
             *(float *)(initGlobalBuf+offset)=(float)dbl;
     else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
-        if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
+        if(type==DEF_PTR_CHAR&&lpCalcIndex==LITERAL_STRING){
             //文字列定数のとき
 
@@ -953 +964 @@
         }
 
-        if(type==DEF_OBJECT){
+        if(type==DEF_STRUCT){
             CClass *pobj_c;
             pobj_c=(CClass *)lpIndex;
@@ -1037 +1048 @@
     }
     else if(type==DEF_INT64||type==DEF_QWORD||IsPtrType(type)){
-        if(type==DEF_PTR_BYTE&&lpCalcIndex==LITERAL_STRING){
+        if(type==DEF_PTR_CHAR&&lpCalcIndex==LITERAL_STRING){
             //文字列定数のとき
 
@@ -1101 +1112 @@
 }
 
-
+void dim(bool isRef, char *VarName,int *SubScripts,TYPEINFO &TypeInfo,int TypeSize,char *InitBuf,char *ConstractParameter,DWORD dwFlags){
+    extern BOOL bCompilingGlobal;
+    if(bCompilingGlobal){
+        /////////////////////////
+        // グローバル変数
+        /////////////////////////
+
+        AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
+    }
+    else{
+        /////////////////
+        // ローカル変数
+        /////////////////
+
+        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( pVar->type==DEF_STRUCT ){
+            int alignment = pVar->u.pobj_c->iAlign;
+            if( alignment ){
+                if( AllLocalVarSize % alignment ){
+                    AllLocalVarSize += alignment - (AllLocalVarSize % alignment);
+                }
+            }
+        }
+
+        AllLocalVarSize+=VarSize;
+        pVar->offset=AllLocalVarSize;
+
+        //レキシカルスコープ
+        pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
+        pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
+        pVar->bLiving=TRUE;
+
+        if(InitBuf[0]){
+            //初期代入時のみ、書き込みアクセスを許可する
+            bool bConstBack = pVar->bConst;
+            pVar->bConst = false;
+
+            int result = 0;
+            if( pVar->type != DEF_OBJECT ){
+                result = InitLocalVar(-pVar->offset,
+                    pVar->type,
+                    pVar->u.index,
+                    pVar->SubScripts,
+                    InitBuf);
+            }
+
+            if(!result){
+                //動的な式だった場合は代入演算を行う
+                char temporary[8192];
+                sprintf(temporary,"%s=%s",VarName,InitBuf);
+                OpcodeCalc(temporary);
+            }
+
+            pVar->bConst = bConstBack;
+        }
+        else{
+            //0初期化
+
+            //mov r8, 0
+            op_zero_reg( REG_R8 );
+
+            //mov rdx, VarSize
+            op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
+
+            //mov rcx, rsp
+            op_mov_RR( REG_RCX, REG_RSP );
+
+            //add rcx, offset
+            op_add_RV( REG_RCX, -pVar->offset );
+            obp-=sizeof(long);
+            AddLocalVarAddrSchedule();
+            obp+=sizeof(long);
+
+            //call FillMemory
+            DECLAREINFO *pdi;
+            pdi=GetDeclareHash("FillMemory");
+            op_call( pdi );
+        }
+    }
+
+    //コンストラクタ呼び出し
+    if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&&InitBuf[0]=='\0'){
+        char objectSize[255];
+        if( SubScripts[0] == -1 ){
+            objectSize[0] = 0;
+        }
+        else{
+            if( SubScripts[1] != -1 ){
+                SetError(300,NULL,cp);
+            }
+            sprintf( objectSize, "%d", SubScripts[0] );
+        }
+        Operator_New( *TypeInfo.u.pobj_Class, objectSize, ConstractParameter, TypeInfo );
+
+        int type;
+        LONG_PTR lpIndex;
+        RELATIVE_VAR RelativeVar;
+        GetVarOffset( true, false, VarName, &type, &RelativeVar, &lpIndex );
+        if( RelativeVar.dwKind == VAR_DIRECTMEM ){
+            SetError();
+        }
+        SetVariableFromRax( DEF_OBJECT, DEF_OBJECT, &RelativeVar );
+    }
+
+    if(TypeInfo.type==DEF_OBJECT){
+        if(TypeInfo.u.pobj_Class->IsAbstract()){
+            //抽象クラスだったとき
+            SetError(125,TypeInfo.u.pobj_Class->name,cp);
+        }
+    }
+}
 void dim(char *Parameter,DWORD dwFlags){
     extern BOOL bCompilingGlobal;
     extern HANDLE hHeap;
-    int i2,i3,VarSize;
+    int i2;
     char VarName[VN_SIZE];
 
@@ -1172 +1335 @@
     TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
 
+    extern BOOL bCompilingGlobal;
     if(dwFlags&DIMFLAG_STATIC){
         if(bCompilingGlobal){
@@ -1186 +1350 @@
         GetNowStaticVarFullName(VarName,temporary);
 
-        AddGlobalVariable(isRef,temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
+        dim( isRef,temporary,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
 
         /*
@@ -1194 +1358 @@
     }
     else{
-        if(bCompilingGlobal){
-            /////////////////////////
-            // グローバル変数
-            /////////////////////////
-
-            AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags);
-        }
-        else{
-            /////////////////
-            // ローカル変数
-            /////////////////
-
-            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;
-            }
-            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;
-            AllLocalVarSize+=VarSize;
-            pVar->offset=AllLocalVarSize;
-
-            //レキシカルスコープ
-            pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
-            pVar->ScopeStartAddress=obj_LexScopes.GetStartAddress();
-            pVar->bLiving=TRUE;
-
-            if(InitBuf[0]){
-                //初期代入時のみ、書き込みアクセスを許可する
-                bool bConstBack = pVar->bConst;
-                pVar->bConst = false;
-
-                int result = InitLocalVar(-pVar->offset,
-                    pVar->type,
-                    pVar->u.index,
-                    pVar->SubScripts,
-                    InitBuf);
-
-                if(!result){
-                    //動的な式だった場合は代入演算を行う
-                    if( isRef ){
-                        SetRefVariable( VarName, InitBuf );
-                    }
-                    else{
-                        char temporary[8192];
-                        sprintf(temporary,"%s=%s",VarName,InitBuf);
-                        OpcodeCalc(temporary);
-                    }
-                }
-
-                pVar->bConst = bConstBack;
-            }
-            else{
-                //0初期化
-
-                //mov r8, 0
-                op_zero_reg( REG_R8 );
-
-                //mov rdx, VarSize
-                op_mov_RV( sizeof(_int64), REG_RDX, VarSize );
-
-                //mov rcx, rsp
-                op_mov_RR( REG_RCX, REG_RSP );
-
-                //add rcx, offset
-                op_add64_value( REG_RCX, -pVar->offset );
-                obp-=sizeof(long);
-                AddLocalVarAddrSchedule();
-                obp+=sizeof(long);
-
-                //call FillMemory
-                DECLAREINFO *pdi;
-                pdi=GetDeclareHash("FillMemory");
-                op_call( pdi );
-            }
-        }
-
-        //コンストラクタ呼び出し
-        if(TypeInfo.type==DEF_OBJECT&&(dwFlags&DIMFLAG_NONCALL_CONSTRACTOR)==0&& isRef == false ){
-            CallConstructor(VarName,SubScripts,TypeInfo,ConstractParameter);
-        }
-    }
-
-    if(TypeInfo.type==DEF_OBJECT){
-        if(TypeInfo.u.pobj_Class->IsAbstract()){
-            //抽象クラスだったとき
-            SetError(125,TypeInfo.u.pobj_Class->name,cp);
-        }
+        dim( isRef,VarName,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags );
     }
 }
@@ -1362 +1407 @@
 
             //mov reg,r11
-            op_mov64_ToReg_FromReg(reg,REG_R11);
+            op_mov_RR(reg,REG_R11);
         }
         else{
@@ -1404 +1449 @@
 
             //mov reg,r11
-            op_mov64_ToReg_FromReg(reg,REG_R11);
+            op_mov_RR(reg,REG_R11);
         }
         else{
             //mov reg,rsp
-            op_mov64_ToReg_FromReg(reg,REG_RSP);
+            op_mov_RR(reg,REG_RSP);
 
             //add reg,offset
-            op_add64_value(reg,(int)pRelativeVar->offset);
+            op_add_RV(reg,(int)pRelativeVar->offset);
             obp-=sizeof(long);
             AddLocalVarAddrSchedule();
@@ -1441 +1486 @@
 directmem:
         //mov reg,r11
-        op_mov64_ToReg_FromReg(reg,REG_R11);
+        op_mov_RR(reg,REG_R11);
     }
 }

BasicCompiler64/MakePeHdr.cpp

@@ -19 +19 @@
     *pSub_calloc,
     *pSub_realloc,
-    *pSub_free;
+    *pSub_free,
+    *pSub_System_GC_malloc_ForObject,
+    *pSub_System_GC_malloc_ForObjectPtr,
+    *pSub_System_GC_free_for_SweepingDelete;
 
 
@@ -215 +218 @@
         pSub_free->bUse=1;
 
+    if( pSub_System_GC_malloc_ForObject = GetSubHash( "_System_GC_malloc_ForObject",1 ) )
+        pSub_System_GC_malloc_ForObject->bUse = 1;
+
+    if( pSub_System_GC_malloc_ForObjectPtr = GetSubHash( "_System_GC_malloc_ForObjectPtr",1 ) )
+        pSub_System_GC_malloc_ForObjectPtr->bUse = 1;
+
+    if( pSub_System_GC_free_for_SweepingDelete = GetSubHash( "_System_GC_free_for_SweepingDelete",1 ) )
+        pSub_System_GC_free_for_SweepingDelete->bUse = 1;
+
 
 
@@ -345 +357 @@
 
         //add rsp,スタックフレームサイズ
-        op_add64_value(REG_RSP,pobj_sf->GetFrameSize());
+        op_add_RV(REG_RSP,pobj_sf->GetFrameSize());
 
         //xor rax,rax（raxを0に初期化する）

BasicCompiler64/NumOpe.cpp

@@ -14 +14 @@
     //////////////////////////////////////////////////////
 
+        char *parameter = (char *)malloc( lstrlen( lpszText ) + 3 );
+        lstrcpy( parameter, lpszText );
+        SetStringQuotes( parameter );
+
         extern CClass *pobj_StringClass;
-        int object_size = pobj_StringClass->GetSize();
-
-        //mov rcx,object_size
-        op_mov_RV(sizeof(_int64),REG_RCX,object_size);
-
-        //call calloc
-        extern SUBINFO *pSub_calloc;
-        op_call(pSub_calloc);
-
-        //mov r11,rax
-        op_mov_RR(REG_R11,REG_RAX);
-
-        //mov qword ptr[rsp+offset],r11     ※スタックフレームを利用
-        pobj_sf->push(REG_R11);
-
-        //mov rcx,rax
-        op_mov_RR(REG_RCX,REG_RAX);
-
-        //call constructor
-        op_call(pobj_StringClass->GetConstructorMethod()->psi);
-
-        // TODO: Ex表記による文字列長に対応する
-        int i2 = dataTable.AddString( lpszText );
-
-        //mov rax,i2
-        op_mov_RV(sizeof(_int64),REG_RAX,i2);
-        obp-=sizeof(long);
-        pobj_DataTableSchedule->add();
-        obp+=sizeof(long);
-
-
-        //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
-        pobj_sf->ref(REG_R11);
-
-
-        RELATIVE_VAR RelativeVar;
-        RelativeVar.bOffsetOffset=0;
-        RelativeVar.offset=0;
-        RelativeVar.dwKind=VAR_DIRECTMEM;
-
-        SetObjectVariableFromRax((LONG_PTR)pobj_StringClass,DEF_PTR_BYTE,-1,&RelativeVar,0);
-
-        //mov r11,qword ptr[rsp+offset]     ※スタックフレームを利用
-        pobj_sf->pop(REG_R11);
-
+        TYPEINFO baseTypeInfo = { DEF_OBJECT, (LONG_PTR)pobj_StringClass };
+        Operator_New( *pobj_StringClass, "", parameter, baseTypeInfo );
+
+        free( parameter );
+
+        //mov reg,rax
+        op_mov_RR( reg, REG_RAX );
 
     /////////////////////////////////////////////
@@ -65 +31 @@
         RESTORE_REGISTER_RESOURCE
     }////////////////////////////////////////////
-
-    //mov reg,r11
-    op_mov_RR(reg,REG_R11);
 }
 
@@ -102 +65 @@
         else{
             //mov reg,rax
-            op_mov64_ToReg_FromReg(UseReg,REG_RAX);
+            op_mov_RR(UseReg,REG_RAX);
         }
     }
@@ -117 +80 @@
     }
 
-    if(Command[0]==1&&Command[1]==ESC_NEW){
+    if(Command[0]==1&& Command[1]==ESC_NEW ){
         //New演算子（オブジェクト生成）
-        return Operator_New(Command+2,plpIndex);
+        TYPEINFO baseTypeInfo = { BaseType, lpBaseIndex };
+        int resultType = Operator_New(Command+2,plpIndex, baseTypeInfo );
+
+        //mov reg,rax
+        op_mov_RR( *pReg, REG_RAX );
+
+        return resultType;
     }
 
@@ -245 +214 @@
                         TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex};
                         if(IsStringSubsituation(pobj_Class)
-                            || IsStringObjectType(&BaseTypeInfo)){
+                            || IsStringObjectType(BaseTypeInfo)){
                             //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
 
@@ -265 +234 @@
                     }
 
-                    type[sp]=DEF_PTR_BYTE;
+                    type[sp]=DEF_PTR_CHAR;
                     bLiteralCalculation=0;
 
@@ -375 +344 @@
                             else pobj_reg->LockReg();
 
-                            if(i2==DEF_OBJECT){
-                                //Object型が戻ったときはヒープ領域にインスタンスが格納されている
+                            if(i2==DEF_STRUCT){
+                                //構造体が戻ったときはヒープ領域にインスタンスが格納されている
                                 //※後にfreeする必要あり
                                 bUseHeap[sp]=1;
@@ -469 +438 @@
                                 SetXmmReg_SingleVariable(&RelativeVar,XmmReg);
                         }
-                        else if(IsWholeNumberType(i2)){
+                        else if(IsWholeNumberType(i2) || i2==DEF_OBJECT){
                             //整数型
                             SetReg_WholeVariable(i2,&RelativeVar,UseReg);
                         }
-                        else if(i2==DEF_OBJECT){
-                            //オブジェクト ポインタをUseRegへ格納
+                        else if(i2==DEF_STRUCT){
+                            //構造体ポインタをUseRegへ格納（構造体は値型）
                             SetVarPtrToReg(UseReg,&RelativeVar);
                         }
@@ -585 +554 @@
                         }////////////////////////////////////////////
 
-                        if(type[sp]==DEF_OBJECT){
-                            //Object型が戻ったときはヒープ領域にインスタンスが格納されている
+                        if(type[sp]==DEF_STRUCT){
+                            //構造体が戻ったときはヒープ領域にインスタンスが格納されている
                             //※後にfreeする必要あり
                             bUseHeap[sp]=1;

BasicCompiler64/NumOpe_Arithmetic.cpp

@@ -108 +108 @@
         else if(idCalc==CALC_PRODUCT){
             //mul reg1,reg2
-            op_imul_reg(sizeof(_int64),reg1,reg2);
+            op_imul_RR(sizeof(_int64),reg1,reg2);
         }
 
@@ -131 +131 @@
         else if(idCalc==CALC_PRODUCT){
             //mul reg1,reg2
-            op_imul_reg(sizeof(long),reg1,reg2);
+            op_imul_RR(sizeof(long),reg1,reg2);
         }
 
@@ -177 +177 @@
     if(reg2==REG_RAX||reg2==REG_RDX){
         //mov r15,reg2
-        op_mov64_ToReg_FromReg(REG_R15,reg2);
+        op_mov_RR(REG_R15,reg2);
 
         reg2=REG_R15;
@@ -203 +203 @@
 
         //mov rax,reg1
-        op_mov64_ToReg_FromReg(REG_RAX,reg1);
+        op_mov_RR(REG_RAX,reg1);
 
         if(IsSignedType(type[sp-2])){
@@ -231 +231 @@
 
         //mov reg1,rdx
-        op_mov64_ToReg_FromReg(reg1,REG_RDX);
+        op_mov_RR(reg1,REG_RDX);
 
     }
@@ -353 +353 @@
     if(reg2==REG_RAX||reg2==REG_RDX){
         //mov r15,reg2
-        op_mov64_ToReg_FromReg(REG_R15,reg2);
+        op_mov_RR(REG_R15,reg2);
 
         reg2=REG_R15;
@@ -379 +379 @@
 
         //mov rax,reg1
-        op_mov64_ToReg_FromReg(REG_RAX,reg1);
+        op_mov_RR(REG_RAX,reg1);
 
         if(IsSignedType(type[sp-2])){
@@ -407 +407 @@
 
         //mov reg1,rax
-        op_mov64_ToReg_FromReg(reg1,REG_RAX);
+        op_mov_RR(reg1,REG_RAX);
 
     }
@@ -495 +495 @@
 
         //imul reg,-1
-        op_imul_value(sizeof(_int64),reg,-1);
+        op_imul_RV(sizeof(_int64),reg,-1);
 
         if(reg==REG_R14){
@@ -508 +508 @@
 
         //imul reg,-1
-        op_imul_value(sizeof(long),reg,-1);
+        op_imul_RV(sizeof(long),reg,-1);
 
         if(reg==REG_R14){
@@ -617 +617 @@
     if(reg1==REG_RCX){
         //mov r15,rcx
-        op_mov64_ToReg_FromReg(REG_R15,REG_RCX);
+        op_mov_RR(REG_R15,REG_RCX);
 
         reg1=REG_R15;
@@ -629 +629 @@
 
     //mov rcx,reg2
-    op_mov64_ToReg_FromReg(REG_RCX,reg2);
+    op_mov_RR(REG_RCX,reg2);
 
     if(idCalc==CALC_SHL){
@@ -662 +662 @@
     if(sw==0){
         //mov rcx,r15
-        op_mov64_ToReg_FromReg(REG_RCX,REG_R15);
+        op_mov_RR(REG_RCX,REG_R15);
     }
     else{

BasicCompiler64/NumOpe_Logical.cpp

@@ -112 +112 @@
 
         //add rax, 1
-        op_add64_value( REG_RAX, 1 );
+        op_add_RV( REG_RAX, 1 );
 
         if( reg != REG_RAX ){

BasicCompiler64/Opcode.h

@@ -125 +125 @@
     void SetLocalParmSize(int size);
     int GetFrameSize();
+    int GetNowSp();
+    void mov_sp( int reg );
     int push(int reg);
     void push(int xmm_reg,int var_size);
@@ -130 +132 @@
     void ref(int reg);
     void ref(int xmm_reg,int var_size);
-    void pop(int reg);
+    void pop(int reg = REG_NON);
     void pop(int xmm_reg,int var_size);
     void parameter_allocate(int size);
@@ -247 +249 @@
 void SetVariableFromRax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar);
 void OpcodeCalc(char *Command);
-void SetRefVariable( const char *varname, const char *expression );
 
 //NumOpe.cpp
@@ -285 +286 @@
 //Compile_Set_Var.cpp
 BOOL IsUse_r11(RELATIVE_VAR *pRelativeVar);
-void SetObjectVariableFromRax(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,RELATIVE_VAR *pRelativeVar,BOOL bUseHeap);
-void SetDoubleVariable(int type,RELATIVE_VAR *pRelative);
-void SetSingleVariable(int type,RELATIVE_VAR *pRelative);
+void SetStructVariableFromRax(LONG_PTR lpVarIndex,int CalcType,LONG_PTR lpCalcIndex,RELATIVE_VAR *pRelativeVar,BOOL bUseHeap);
+void SetRealVariable(int VarType, int CalcType, RELATIVE_VAR *pRelativeVar);
 void SetBooleanVariable(int type,RELATIVE_VAR *pRelative);
 void SetWholeVariable(int var_size,int type,RELATIVE_VAR *pRelative);
@@ -307 +307 @@
 
 //Compile_Object.cpp
-int Operator_New(const char *Parameter,LONG_PTR *plpIndex);
-void OpcodeDelete(const char *Parameter);
+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 OpcodeDelete(const char *Parameter, bool isSweeping);
 
 //Compile_Var.cpp
@@ -319 +320 @@
 #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 SetVarPtrToReg(int reg,RELATIVE_VAR *pRelativeVar);
 
 //CParameter.cpp
+#define OVERLOAD_MIN_LEVEL 0
+#define OVERLOAD_MAX_LEVEL 3
+#define OVERLOAD_LEVEL0 0
 #define OVERLOAD_LEVEL1 1
 #define OVERLOAD_LEVEL2 2
@@ -352 +357 @@
     BOOL ErrorCheck(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum);
     void MacroParameterSupport(PARAMETER_INFO *ppi);
-    void SetObjectParameter(int reg,CClass *pobj_Class,LPSTR Parameter);
+    void SetStructParameter(int reg,CClass *pobj_Class,LPSTR Parameter);
 
     //一時オブジェクトパラメータの生成と破棄
-    void NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
+    int NewTempParameters( const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum );
     void DeleteTempParameters();
 
@@ -380 +385 @@
 #define PROCFLAG_NEW    1
 int Opcode_CallProcPtr(char *variable,char *Parameter,PROCPTRINFO *pi,LONG_PTR *plpIndex);
-void Opcode_CallProc(char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType);
+void Opcode_CallProc(const char *Parameter,SUBINFO *psi,DWORD dwFlags,char *ObjectName,int RefType);
 int Opcode_CallDllProc(char *Parameter,DECLAREINFO *pdi,LONG_PTR *plpIndex);
 
@@ -410 +415 @@
 void OpcodeGosub(char *Parameter);
 void OpcodeReturn(char *Parameter);
-void Opcode_Input(char *Parameter);
-void Opcode_Print(char *Parameter,BOOL bWrite);
+void Opcode_Input(const char *Parameter);
+void Opcode_Print(const char *Parameter,BOOL bWrite);
 void OpcodeCallPtr(char *Parameter);
 void OpcodeSetPtrData(char *Parameter,int type);
@@ -450 +455 @@
 void op_mov64_ToReg             (int reg,_int64 i64data);
 void op_mov64_ToReg             (int reg,int i32data);
-void op_mov64_ToReg_FromReg     (int reg1,int reg2);
 void op_movsxd                  (int reg64,int reg32);
 void op_movsx64_FromReg16       (int reg64,int reg16);
@@ -460 +464 @@
 void op_dec                     (int reg);
 void op_add_RM                  (int op_size,int reg,int base_reg,int offset,char mod);
-void op_add64_value             (int reg,int offset);
+void op_add_RV              (int reg,int offset);
 void op_add64_reg               (int reg1,int reg2);
 void op_add32_reg               (int reg1,int reg2);
@@ -467 +471 @@
 void op_sub32_reg               (int reg1,int reg2);
 void op_sbb_RR                  ( int op_size, int reg1, int reg2 );
-void op_imul_reg                (int op_size,int reg1,int reg2);
-void op_imul_value              (int op_size,int reg,int i32data);
+void op_imul_RR             (int op_size,int reg1,int reg2);
+void op_imul_RV             (int op_size,int reg,int i32data);
 void op_div64_reg               (int reg);
 void op_idiv64_reg              (int reg);

BasicCompiler64/OperatorProc.cpp

@@ -55 +55 @@
         if(pBaseTypeInfo){
             if(pBaseTypeInfo->type==DEF_OBJECT){
-                bReturnTypeIsObject=1;
                 ReturnType.u.lpIndex=pBaseTypeInfo->u.lpIndex;
             }
@@ -113 +112 @@
     HeapDefaultFree(ppi);
 
-    int right_side_size;
-    if(type[sp-1]==DEF_OBJECT) right_side_size=PTR_SIZE;
-    else right_side_size=GetTypeSize(type[sp-1],index_stack[sp-1]);
-
     if(bTwoTerm){
-        if(psi->pParmInfo[1].type==DEF_OBJECT&&psi->pParmInfo[1].bByVal){
+        if(psi->pRealParmInfo[1].type==DEF_STRUCT&&psi->pRealParmInfo[1].bByVal){
             //一時オブジェクトはメソッド内で破棄される
             bUseHeap[sp-1]=0;
@@ -124 +119 @@
     }
 
-
-    if(psi->ReturnType==DEF_OBJECT){
-        //////////////////////////////////////////////////////
-        // 戻り値にオブジェクト インスタンスを持つ場合
-        // ※ByRef _System_ReturnObject パラメータ用領域を取得
+    if(psi->ReturnType==DEF_STRUCT){
+        //////////////////////////////////////////////////////
+        // 戻り値に構造体インスタンスを持つ場合
+        // ※ByRef _System_ReturnValue パラメータ用領域を取得
         //////////////////////////////////////////////////////
 
@@ -154 +148 @@
         }////////////////////////////////////////////
     }
-
 
     int reg1,reg2;
@@ -161 +154 @@
         SetOneTermToReg_Whole64Calc(type[sp-1],&reg2);
         pobj_reg->UnlockReg();
+        if( !psi->pRealParmInfo[1].bByVal ){
+            //一時参照を作成
+            pobj_sf->push( reg2 );
+            pobj_sf->mov_sp( reg2 );
+        }
     }
 
@@ -192 +190 @@
 
         if(bTwoTerm){
-            if(psi->ReturnType==DEF_OBJECT){
+            if(psi->ReturnType==DEF_STRUCT){
                 //mov r8,reg2
                 op_mov_RR(REG_R8,reg2);
@@ -202 +200 @@
         }
 
-        if(psi->ReturnType==DEF_OBJECT){
+        if(psi->ReturnType==DEF_STRUCT){
             //mov rdx,r13
             op_mov_RR(REG_RDX,REG_R13);
@@ -213 +211 @@
         op_call(psi);
 
-        if(psi->ReturnType!=-1){
+        if(psi->ReturnType!=DEF_NON){
             //戻り値を一時的に退避
 
@@ -254 +252 @@
     }
 
-    if(psi->ReturnType!=-1){
+    if(bTwoTerm){
+        if( !psi->pRealParmInfo[1].bByVal ){
+            //一時参照を破棄
+            pobj_sf->pop();
+        }
+    }
+
+    if(psi->ReturnType!=DEF_NON){
         //戻り値をreg1にセット
         reg1=pobj_reg->LockReg();
@@ -266 +271 @@
     index_stack[sp-1]=psi->u.ReturnIndex;
 
-    if(psi->ReturnType==DEF_OBJECT){
-        //Object型が戻ったときはヒープ領域にインスタンスが格納されている
+    if(psi->ReturnType==DEF_STRUCT){
+        //構造体が戻ったときはヒープ領域にインスタンスが格納されている
         //※後にfreeする必要あり
         bUseHeap[sp-1]=1;

BasicCompiler64/WatchList.cpp

@@ -78 +78 @@
     if(PTR_LEVEL(*pType)){
         *pType=MAKE_PTR_TYPE(NATURAL_TYPE(*pType),PTR_LEVEL(*pType)-1);
-        if((*pType)==DEF_OBJECT){
-            CClass *pClass = (CClass *)lpIndex;
-            array_num *= pClass->GetSize();
-        }
-        else{
-            array_num *= GetTypeSize(*pType,-1);
-        }
+        array_num *= GetTypeSize(*pType,-1);
     }
     else{
@@ -114 +108 @@
     char lpPtrOffset[VN_SIZE];  //第2次配列
     char NestMember[VN_SIZE];   //入れ子メンバ
-    int RefType;                //"."参照のときは0、"->"参照のときは1
+    CClass::RefType refType;
     lstrcpy(VarName,member);
-    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&RefType)) return 0;
+    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember, refType ) ) return 0;
 
 
@@ -175 +169 @@
         //入れ子構造の場合
 
-        if(*pType==DEF_OBJECT){
-            if(RefType!=DEF_OBJECT) return 0;
-        }
-        else if(*pType==DEF_PTR_OBJECT){
+        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
+            if( refType != CClass::Dot ) return 0;
+
+            if( *pType==DEF_OBJECT ){
+                extern HANDLE hDebugProcess;
+                LONG_PTR lpData;
+                SIZE_T stAccBytes;
+                lpData=Debugging_GetVarPtr(pRelativeVar);
+                if(!ReadProcessMemory(hDebugProcess,(void *)lpData,&pRelativeVar->offset,sizeof(LONG_PTR),&stAccBytes)) return -1;
+                pRelativeVar->dwKind=VAR_DIRECTMEM;
+            }
+        }
+        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
             //構造体ポインタ型メンバ変数
 
             if(lpPtrOffset[0]){
-                if(RefType!=DEF_OBJECT) return 0;
+                if( refType != CClass::Dot ) return 0;
 
                 //直接参照に切り替え
@@ -190 +193 @@
             }
             else{
-                if(RefType!=DEF_PTR_OBJECT) return 0;
+                if( refType != CClass::Pointer ) return 0;
 
                 extern HANDLE hDebugProcess;
@@ -320 +323 @@
 int Debugging_GetVarOffset(char *variable,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
     extern HANDLE hDebugProcess;
-    int i,i2,i3,RefType;
+    int i,i2,i3;
     char member[VN_SIZE],VarName[VN_SIZE],array[VN_SIZE],lpPtrOffset[VN_SIZE];
     LONG_PTR lpData;
@@ -326 +329 @@
 
     lstrcpy(VarName,variable);
-    GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
+    CClass::RefType refType;
+    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
 
     LONG_PTR lpIndex;
@@ -474 +478 @@
     }
     if(member[0]){
-        if(*pType==DEF_OBJECT){
+        if(*pType==DEF_OBJECT || *pType==DEF_STRUCT){
             //実態オブジェクトのメンバを参照（obj.member）
-            if(RefType!=DEF_OBJECT){
+            if( refType != CClass::Dot ){
                 return 0;
             }
@@ -493 +497 @@
             *plpIndex=lp2;
         }
-        else if(*pType==DEF_PTR_OBJECT){
+        else if(*pType==DEF_PTR_OBJECT || *pType==DEF_PTR_STRUCT){
             //ポインタオブジェクトが示すメンバを参照
             if(lpPtrOffset[0]){
                 //pObj[n].member
-                if(RefType!=DEF_OBJECT) return 0;
+                if( refType != CClass::Dot ) return 0;
                 Debugging_SetRelativeOffset(pType,lpIndex,pRelativeVar,lpPtrOffset);
 
@@ -515 +519 @@
             else{
                 //pObj->member
-                if(RefType!=DEF_PTR_OBJECT) return 0;
+                if( refType != CClass::Pointer ) return 0;
 
                 pRelativeVar->offset=Debugging_GetVarPtr(pRelativeVar);

BasicCompiler64/amd64_main.cpp

@@ -424 +424 @@
 
 void op_mov_RR(int reg1,int reg2){
-    op_mov64_ToReg_FromReg(reg1,reg2);
+    //mov reg1,reg2
+    char RexByte=-1;
+
+    if(reg1==reg2) return;
+
+    if(REG_RAX<=reg1&&reg1<=REG_RDI){
+        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
+        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
+    }
+    if(REG_R8<=reg1&&reg1<=REG_R15){
+        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
+        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x4D;
+    }
+
+    if(RexByte==-1) SetError(300,NULL,cp);
+
+    // [8bit rex] 1000 1011 11xx xbbb
+    OpBuffer[obp++]=RexByte;
+    OpBuffer[obp++]=(char)0x8B;
+    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
 }
 
@@ -475 +494 @@
     }
 }
-void op_mov64_ToReg_FromReg(int reg1,int reg2){
-    //mov reg1,reg2
-    char RexByte=-1;
-
-    if(reg1==reg2) return;
-
-    if(REG_RAX<=reg1&&reg1<=REG_RDI){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x48;
-        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x49;
-    }
-    if(REG_R8<=reg1&&reg1<=REG_R15){
-        if(REG_RAX<=reg2&&reg2<=REG_RDI) RexByte=(char)0x4C;
-        if(REG_R8<=reg2&&reg2<=REG_R15) RexByte=(char)0x4D;
-    }
-
-    if(RexByte==-1) SetError(300,NULL,cp);
-
-    // [8bit rex] 1000 1011 11xx xbbb
-    OpBuffer[obp++]=RexByte;
-    OpBuffer[obp++]=(char)0x8B;
-    OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
-}
 void op_movsxd(int reg64,int reg32){
     //movsxd reg64,reg32
@@ -686 +683 @@
 }
 
-void op_add64_value(int reg,int offset){
+void op_add_RV(int reg,int offset){
     //add reg,offset
     char RexByte=-1;
@@ -843 +840 @@
 ////////////////////////
 
-void op_imul_reg(int op_size,int reg1,int reg2){
+void op_imul_RR(int op_size,int reg1,int reg2){
     //imul reg1,reg2
     char RexByte=-1;
@@ -881 +878 @@
     OpBuffer[obp++]=(char)(0xC0| REGISTER_OPERAND(reg1)<<3 | REGISTER_OPERAND(reg2));
 }
-void op_imul_value(int op_size,int reg,int i32data){
+void op_imul_RV(int op_size,int reg,int i32data){
     //imul reg,i32data
     char RexByte=-1;

BasicCompiler64/stack_frame.cpp

@@ -38 +38 @@
     }
     return -(answer_sp-0x08);
+}
+int CStackFrame::GetNowSp(){
+    return now_sp;
+}
+void CStackFrame::mov_sp( int reg ){
+    //mov reg,rsp
+    op_mov_RR( reg, REG_RSP );
+
+    //add reg,now_sp
+    op_add_RV( reg, now_sp );
+
+    //スケジュールをセット
+    obp-=sizeof(long);
+    add();
+    obp+=sizeof(long);
 }
 int CStackFrame::push(int reg){

BasicCompiler64/varlist.cpp

@@ -22 +22 @@
     _int64 i64data;
 
-    if(type==DEF_OBJECT){
+    if(type==DEF_OBJECT||type==DEF_STRUCT){
+        if( type==DEF_OBJECT ){
+            // 参照型ということを考慮する
+            ReadProcessMemory(hDebugProcess,(void *)offset,&pData,sizeof(void *),&stAccBytes);
+            offset = pData;
+        }
+
         sprintf(lptv->item.pszText,"%s %s(&H%X)",VarName,STRING_OBJECT,(DWORD64)offset);
         lptv->item.iImage=1;
@@ -31 +37 @@
         return;
     }
-    if(type==DEF_PTR_OBJECT){
+    if(type==DEF_PTR_OBJECT||type==DEF_PTR_STRUCT){
         i2=ReadProcessMemory(hDebugProcess,(void *)offset,&pData,sizeof(void *),&stAccBytes);
 
@@ -43 +49 @@
     }
     else{
-        if(type==DEF_PTR_BYTE){
+        if(type==DEF_PTR_CHAR||type==MAKE_PTR_TYPE(DEF_BYTE,1)){
             if(ReadProcessMemory(hDebugProcess,(void *)offset,&pData,sizeof(void *),&stAccBytes)){
                 for(i2=0;;i2++){

BasicCompiler_Common/BasicFixed.h

@@ -13 +13 @@
 // 型
 ////////////////
+
+#define DEF_NON         -1
 
 /* basic\command.sbp内の "_System_Type_***" 定数と同期が必要 */
@@ -48 +50 @@
 #define DEF_ANY         0x00000015
 #define DEF_OBJECT      0x00000016
+#define DEF_STRUCT      0x00000017
 #define DEF_ELLIPSE     0x00000018
 
@@ -60 +63 @@
 #define PTR_LEVEL_DOWN(t)   t = MAKE_PTR_TYPE(NATURAL_TYPE(t),PTR_LEVEL(t)-1)
 
-#define DEF_PTR_BYTE    MAKE_PTR_TYPE(DEF_BYTE,1)
+#define DEF_PTR_CHAR    MAKE_PTR_TYPE(DEF_CHAR,1)
 #define DEF_PTR_OBJECT  MAKE_PTR_TYPE(DEF_OBJECT,1)
+#define DEF_PTR_STRUCT  MAKE_PTR_TYPE(DEF_STRUCT,1)
 
 
@@ -191 +195 @@
 #define ESC_ENDINTERFACE    (char)0xAA
 #define ESC_OPERATOR        (char)0xAB
-

BasicCompiler_Common/Class.cpp

@@ -101 +101 @@
 
 int CMember::GetSize(){
-    if( IsRef() ){
-        // 参照型
-        return PTR_SIZE;
-    }
-
     //メンバサイズを取得
     return GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex);
@@ -126 +121 @@
             char temporary[VN_SIZE];
             sprintf(temporary,"%s.%s",pobj_c->name,member->name);
-            AddGlobalVariable(
+            dim(
                 false,
                 temporary,
                 member->SubScripts,
-                &member->TypeInfo,
+                member->TypeInfo,
                 GetTypeSize(member->TypeInfo.type,member->TypeInfo.u.lpIndex),
                 member->InitBuf,
                 member->ConstractParameter,
                 0);
-
-            if(member->TypeInfo.type==DEF_OBJECT){
-                //エラー用
-                cp=member->source_code_address;
-
-                CallConstructor(temporary,
-                    member->SubScripts,
-                    member->TypeInfo,
-                    member->ConstractParameter);
-            }
 
             //ネイティブコードバッファの再確保
@@ -220 +205 @@
     }
 }
+
+bool CClass::IsStructure() const
+{
+    return classType == CClass::Structure;
+}
+
 void CClass::Inherits( CClass *pInheritsClass ){
     int i3;
@@ -437 +428 @@
         //アラインメントを算出
         int member_size;
-        if(pMember->TypeInfo.type==DEF_OBJECT){
+        if(pMember->TypeInfo.type==DEF_STRUCT){
             //メンバクラスのアラインメントを取得
             member_size=pMember->TypeInfo.u.pobj_Class->GetAlignment();
@@ -500 +491 @@
         CMember *pMember = ppobj_Member[i];
 
-        if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef() == false){
+        if(pMember->TypeInfo.type==DEF_STRUCT){
             //メンバクラスのアラインメントを取得
             member_size=pMember->TypeInfo.u.pobj_Class->GetAlignment();
@@ -598 +589 @@
     //コンポジションの関係にあるメンバも検査する
     for(int i=0;i < iMemberNum;i++){
-        if(ppobj_Member[i]->TypeInfo.type==DEF_OBJECT && ppobj_Member[i]->IsRef() == false){
+        if(ppobj_Member[i]->TypeInfo.type==DEF_OBJECT){
             if(ppobj_Member[i]->TypeInfo.u.pobj_Class->IsAbstract())
                 return true;
@@ -805 +796 @@
 
                 //クラスを追加
-                pobj_DBClass->AddClass(temporary,NowLine);
+                CClass *pClass = pobj_DBClass->AddClass(temporary,NowLine);
+                if( pClass ){
+                    if( basbuf[NowLine+1] == ESC_CLASS ){
+                        pClass->classType = CClass::Class;
+                    }
+                    else if( basbuf[NowLine+1] == ESC_INTERFACE ){
+                        pClass->classType = CClass::Interface;
+                    }
+                    else{
+                        pClass->classType = CClass::Structure;
+                    }
+                }
         }
     }
@@ -843 +845 @@
         if(psi->ParmNum==0) fConstructor=1;
 
+        // TODO: 消す
         //コピーコンストラクタ
         if(psi->ParmNum==1){
@@ -953 +956 @@
     for(i=0;i<pobj_c->iMemberNum;i++){
         CMember *pMember = pobj_c->ppobj_Member[i];
-        if(pMember->TypeInfo.type==DEF_OBJECT && pMember->IsRef()==false ){
+        if(pMember->TypeInfo.type==DEF_OBJECT){
             //循環参照でないかをチェック
             if(pobj_LoopRefCheck->check(pMember->TypeInfo.u.pobj_Class->name)){
@@ -976 +979 @@
     extern char *basbuf;
     int i,i2,i3,sub_address,top_pos;
-    DWORD dwClassType;
     DWORD dwAccess;
     char temporary[8192];
@@ -1132 +1134 @@
             top_pos=i;
 
-            dwClassType=basbuf[i+1];
+            const DWORD dwClassType=basbuf[i+1];
 
             i+=2;
@@ -1263 +1265 @@
                     i += 2;
                 }
-
+/*
                 //Ref修飾子
                 bool isRef = false;
@@ -1269 +1271 @@
                     isRef = true;
                     i += 2;
-                }
+                }*/
 
                 if(basbuf[i]==1&&(
@@ -1348 +1350 @@
                         //静的メンバを追加
                         cp=i;   //エラー用
-                        pobj_c->AddStaticMember( dwAccess, isConst, isRef, temporary, i);
+                        pobj_c->AddStaticMember( dwAccess, isConst, false, temporary, i);
                     }
                     else{
                         //メンバを追加
                         cp=i;   //エラー用
-                        pobj_c->AddMember( dwAccess, isConst, isRef, temporary );
-
-
-                        if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_OBJECT){
+                        pobj_c->AddMember( dwAccess, isConst, false, temporary );
+
+
+                        if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_OBJECT||
+                            pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.type==DEF_STRUCT){
                             if(pobj_c->ppobj_Member[pobj_c->iMemberNum-1]->TypeInfo.u.pobj_Class->ppobj_Member==0){
                                 //参照先が読み取られていないとき
@@ -1376 +1379 @@
                 }
                 else{
-                    // 文法エラーチェック
-                    if( isRef ){
-                        SetError(1,NULL,cp);
-                    }
-
                     //メソッドを追加
                     cp=i;   //エラー用

BasicCompiler_Common/Class.h

@@ -79 +79 @@
     std::vector<CMethod *> staticMethods;
 
+    enum ClassType{
+        Class,
+        Structure,
+        Interface,
+    };
+
+    ClassType classType;
+
 public:
     //クラス名
@@ -100 +108 @@
     CClass(const char *name);
     ~CClass();
+
+    bool IsStructure() const;
 
     //継承させる
@@ -186 +196 @@
     //線形リスト用
     CClass *pobj_NextClass;
+
+
+    //メンバの参照方法
+    enum RefType{
+        Dot,            // obj.member
+        Pointer,        // obj->member
+        Non,            // no reference member
+    };
 };
 

BasicCompiler_Common/Compile.cpp

@@ -243 +243 @@
             break;
         case COM_DELETE:
-            OpcodeDelete(Command+2);
+            OpcodeDelete(Command+2, false);
+            break;
+        case COM_SWEEPINGDELETE:
+            OpcodeDelete(Command+2, true);
             break;
 

BasicCompiler_Common/DebugMiddleFile.cpp

@@ -11 +11 @@
 
 void SetLpIndex_DebugFile(char *buffer,int *p,int type,LONG_PTR lpIndex){
-    if(NATURAL_TYPE(type)==DEF_OBJECT){
+    if(NATURAL_TYPE(type)==DEF_OBJECT || NATURAL_TYPE(type)==DEF_STRUCT){
         lstrcpy(buffer+(*p),((CClass *)lpIndex)->name);
         (*p)+=lstrlen(buffer+(*p))+1;
@@ -23 +23 @@
 
 void GetLpIndex_DebugFile(char *buffer,int *p,int type,LONG_PTR *plpIndex){
-    if(NATURAL_TYPE(type)==DEF_OBJECT){
+    if(NATURAL_TYPE(type)==DEF_OBJECT || NATURAL_TYPE(type)==DEF_STRUCT){
         char szClassName[VN_SIZE];
         lstrcpy(szClassName,buffer+(*p));

BasicCompiler_Common/Intermediate_Step1.cpp

@@ -2 +2 @@
 
 void ChangeReturnCode(char *buffer){
+
+#ifdef _DEBUG
+    //改行コードの整合性チェック
+    for( int i=0; ; i++ ){
+        if( buffer[i] == '\0' ){
+            break;
+        }
+        if( buffer[i]!='\r' && buffer[i+1]=='\n'
+            ||  buffer[i]=='\r' && buffer[i+1]!='\n' ){
+                char temporary[255];
+                strncpy( temporary, buffer + i-100, 130 );
+                temporary[130] = 0;
+                for(int i2=0; ;i2++){
+                    if(temporary[i2]=='\r') temporary[i2]='A';
+                    if(temporary[i2]=='\n') temporary[i2]='B';
+                    if(temporary[i2]=='\0') break;
+                }
+                MessageBox( hOwnerEditor, temporary, "改行コードの整合性チェック", MB_OK | MB_ICONEXCLAMATION );
+        }
+    }
+#endif
+
     //改行コードのCRLFをLFに変換
-    int i,i2;
-    for(i=0,i2=0;;i++,i2++){
+    for(int i=0,i2=0;;i++,i2++){
         if(buffer[i]=='\r'&&buffer[i+1]=='\n') i++;
         buffer[i2]=buffer[i];

BasicCompiler_Common/Intermediate_Step2.cpp

@@ -582 +582 @@
         ComNum=COM_DELETE;
     }
+    else if( lstrcmpi( com, "_System_SweepingDelete" ) == 0 ){
+        KillSpaces(Command+i,pam);
+        ComNum=COM_SWEEPINGDELETE;
+    }
 
     //その他

BasicCompiler_Common/LexicalScoping.cpp

@@ -182 +182 @@
 
 
-    int i3,i4;
+    int i3;
     int indexSystemGC=-1;
     for( i3 = num - 1; i3 >= 0; i3-- ){     //確保したのと逆順序で解放するため、バックサーチにする
@@ -197 +197 @@
         if( pVar[i3].ScopeLevel != GetNowLevel() ) continue;
 
-        if(pVar[i3].type==DEF_OBJECT&&pVar[i3].fRef&OBJECT_PARAMETER){
-            //実態オブジェクトのパラメータを持つとき
-
-            //デストラクタを呼び出す
-            CMethod *method = pVar[i3].u.pobj_c->GetDestructorMethod();
-            if( method ){
-                Opcode_CallProc("", method->psi,0,pVar[i3].name,DEF_OBJECT);
-            }
+        if(pVar[i3].type==DEF_STRUCT&&pVar[i3].fRef&OBJECT_PARAMETER){
+            //構造体パラメータを持つとき
 
             //メモリを解放する
@@ -241 +235 @@
             }
         }
+
+        /*
+        TODO: 消す
         else if(pVar[i3].type==DEF_OBJECT&&pVar[i3].fRef==0){
             //デストラクタの呼び出し
@@ -285 +282 @@
             }
         }
+        */
     }
 

BasicCompiler_Common/NumOpe_GetType.cpp

@@ -255 +255 @@
 }
 
+int Operator_New_GetType(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( baseTypeInfo.type == DEF_OBJECT ){
+        return DEF_OBJECT;
+    }
+    return DEF_PTR_OBJECT;
+}
+
 int NumOpe_GetType(char *Command,TYPEINFO *pBaseType,LONG_PTR *plpIndex){
     extern int cp;
@@ -265 +309 @@
     }
 
-    if(Command[0]==1&&Command[1]==ESC_NEW){
+    if(Command[0]==1&& Command[1]==ESC_NEW ){
         //New演算子（オブジェクト生成）
-        return DEF_PTR_OBJECT;
+        return Operator_New_GetType(Command+2,plpIndex, *pBaseType );
     }
 
@@ -333 +377 @@
                         if(pBaseType->type==DEF_OBJECT){
                             if(IsStringSubsituation(pBaseType->u.pobj_Class)
-                                || IsStringObjectType(pBaseType)){
+                                || IsStringObjectType(*pBaseType)){
                                 //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合
                                 extern CClass *pobj_StringClass;
@@ -346 +390 @@
                     }
 
-                    type[sp]=DEF_PTR_BYTE;
+                    type[sp]=DEF_PTR_CHAR;
                     bLiteralCalculation=0;
                 }

BasicCompiler_Common/Overload.cpp

@@ -28 +28 @@
         char MethodName[VN_SIZE];
         if( !SplitMemberName( name, NULL, MethodName ) ) lstrcpy( MethodName, name );
-
+/*
         //メソッドの場合は静的かどうかを調べる
         bool isStatic = false;
@@ -35 +35 @@
             isStatic = pClass->IsExistStaticMethod( MethodName );
         }
-
+*/
         //パラメータオブジェクトを生成
         pobj_parameter=new CParameter(Parameter);

BasicCompiler_Common/Parameter.cpp

@@ -58 +58 @@
     }
 
-    ReturnTypeInfo.type=0;
-    ReturnTypeInfo.u.lpIndex=0;
+    ReturnTypeInfo.type=DEF_NON;
+    ReturnTypeInfo.u.lpIndex=-1;
 }
 CParameter::CParameter(const PARAMETER_INFO *pParamInfo,const int ParmNum){
@@ -70 +70 @@
     this->ParmsNum=ParmNum;
 
-    ReturnTypeInfo.type=0;
-    ReturnTypeInfo.u.lpIndex=0;
+    ReturnTypeInfo.type=DEF_NON;
+    ReturnTypeInfo.u.lpIndex=-1;
 }
 CParameter::~CParameter(){
@@ -99 +99 @@
         if(Parms[i]){
             TYPEINFO BaseType={ppi[i].type,ppi[i].u.index};
-            type=NumOpe_GetType(Parms[i],&BaseType,&lpIndex);
+            type=NumOpe_GetType(Parms[i],
+                (overload_level==OVERLOAD_LEVEL0) ? NULL : &BaseType,
+                &lpIndex);
         }
         else{
@@ -107 +109 @@
 
         if(type!=ppi[i].type){
-            if(overload_level==OVERLOAD_LEVEL1){
+            if(overload_level==OVERLOAD_LEVEL1 || overload_level == OVERLOAD_LEVEL0){
                 return 0;
             }
@@ -121 +123 @@
         }
         else{
-            if(NATURAL_TYPE(type)==DEF_OBJECT){
+            if(NATURAL_TYPE(type)==DEF_OBJECT || NATURAL_TYPE(type)==DEF_STRUCT){
                 if(lpIndex!=ppi[i].u.index) return 0;
             }
@@ -130 +132 @@
         //戻り値も比較対象にする
         if(ReturnTypeInfo.type==pReturnTypeInfo->type){
-            if(NATURAL_TYPE(ReturnTypeInfo.type)==DEF_OBJECT){
-                if(ReturnTypeInfo.u.lpIndex != pReturnTypeInfo->u.lpIndex) return 0;
+            if(NATURAL_TYPE(ReturnTypeInfo.type)==DEF_OBJECT
+                || NATURAL_TYPE(ReturnTypeInfo.type)==DEF_STRUCT ){
+                    if(ReturnTypeInfo.u.lpIndex != pReturnTypeInfo->u.lpIndex) return 0;
             }
         }
@@ -145 +148 @@
     psi=0;
 
-    foreach( psi, subs ){
-
-        TYPEINFO ReturnTypeInfo;
-        ReturnTypeInfo.type=psi->ReturnType;
-        ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
-
-        //エラーチェック
-        if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL1)){
-            if(sw){
-                SetError(52,name,cp);
-                return 0;
-            }
-            sw=1;
-            break;
-        }
-    }
-
-    if(!sw){
-        foreach( psi, subs ){
+    for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
+        foreach( SUBINFO *temp_psi, subs ){
 
             TYPEINFO ReturnTypeInfo;
-            ReturnTypeInfo.type=psi->ReturnType;
-            ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
+            ReturnTypeInfo.type=temp_psi->ReturnType;
+            ReturnTypeInfo.u.lpIndex=temp_psi->u.ReturnIndex;
 
             //エラーチェック
-            if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL2)){
+            if(_overload_check(temp_psi->pParmInfo,temp_psi->ParmNum,&ReturnTypeInfo,level)){
                 if(sw){
                     SetError(52,name,cp);
@@ -176 +162 @@
                 }
                 sw=1;
+
+                psi = temp_psi;
                 break;
             }
         }
-    }
-
-    if(!sw){
-        foreach( psi, subs ){
-
-            TYPEINFO ReturnTypeInfo;
-            ReturnTypeInfo.type=psi->ReturnType;
-            ReturnTypeInfo.u.lpIndex=psi->u.ReturnIndex;
-
-            //エラーチェック
-            if(_overload_check(psi->pParmInfo,psi->ParmNum,&ReturnTypeInfo,OVERLOAD_LEVEL3)){
-                if(sw){
-                    SetError(52,name,cp);
-                    return 0;
-                }
-                sw=1;
-                break;
-            }
-        }
+
+        if( sw ) break;
     }
 
@@ -212 +183 @@
     psi=0;
 
-    foreach( psi, subs ){
-
-        //エラーチェック
-        if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL1)){
-            if(sw){
-                return OverloadSolutionWithReturnType(name,subs);
-            }
-            sw=1;
-            break;
-        }
-    }
-
-    if(!sw){
-        foreach( psi, subs ){
+    for( int level=OVERLOAD_MIN_LEVEL; level<=OVERLOAD_MAX_LEVEL; level++ ){
+
+        foreach( SUBINFO *temp_psi, subs ){
 
             //エラーチェック
-            if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL2)){
+            if(_overload_check(temp_psi->pParmInfo,temp_psi->ParmNum,NULL,level)){
                 if(sw){
                     return OverloadSolutionWithReturnType(name,subs);
                 }
                 sw=1;
-                break;
-            }
-        }
-    }
-
-    if(!sw){
-        foreach( psi, subs ){
-
-            //エラーチェック
-            if(_overload_check(psi->pParmInfo,psi->ParmNum,NULL,OVERLOAD_LEVEL3)){
-                if(sw){
-                    return OverloadSolutionWithReturnType(name,subs);
-                }
-                sw=1;
-                break;
-            }
-        }
+
+                psi = temp_psi;
+            }
+        }
+
+        if( sw ) break;
     }
 

BasicCompiler_Common/Subroutine.cpp

@@ -460 +460 @@
     _int64 i64data;
     type = StaticCalculation( true, temporary, 0, &i64data, &lpIndex );
-    if( type != DEF_PTR_BYTE ){
+    if( type != DEF_PTR_CHAR ){
         SetError(1,NULL,NowLine);
         return;
@@ -483 +483 @@
     if( temporary[0] ){
         type = StaticCalculation( true, temporary, 0, &i64data, &lpIndex );
-        if( type != DEF_PTR_BYTE ){
+        if( type != DEF_PTR_CHAR ){
             SetError(1,NULL,NowLine);
             return;
@@ -604 +604 @@
         i+=2;
         pdi->ReturnType=GetTypeFixed(buffer+i,&pdi->u.ReturnIndex);
-        if(pdi->ReturnType==-1) SetError(3,buffer+i,NowLine);
+        if(pdi->ReturnType==DEF_NON) SetError(3,buffer+i,NowLine);
         if(pdi->ReturnType==DEF_OBJECT) SetError(40,NULL,NowLine);
     }
     else if(buffer[i]) SetError(1,NULL,NowLine);
-    else pdi->ReturnType=-1;
+    else pdi->ReturnType=DEF_NON;
 
     pdi->pos=NowLine;
@@ -635 +635 @@
         }
         else{
-            if(NATURAL_TYPE(ppi1[i].type)==DEF_OBJECT){
+            if(NATURAL_TYPE(ppi1[i].type)==DEF_OBJECT
+                || NATURAL_TYPE(ppi1[i].type)==DEF_STRUCT ){
                 if(ppi1[i].u.index!=ppi2[i].u.index) return 1;
             }
@@ -827 +828 @@
                 }
                 psi->ReturnType=GetTypeFixed(temporary,&psi->u.ReturnIndex);
-                if(psi->ReturnType==-1) SetError(3,temporary,NowLine);
+                if(psi->ReturnType==DEF_NON) SetError(3,temporary,NowLine);
 
                 sw_as=1;
@@ -842 +843 @@
     else{
         //戻り値なしのSub定義
-        psi->ReturnType=-1;
+        psi->ReturnType=DEF_NON;
         psi->u.ReturnIndex=-1;
     }
@@ -1129 +1130 @@
     }
 
-    //リアルパラメータ領域を取得（_System_LocalThis、_System_ReturnValueを考慮して2つだけ多く確保する）
+    //リアルパラメータ領域を取得（_System_LocalThisを考慮して2つだけ多く確保する）
     psi->pRealParmInfo=(PARAMETER_INFO *)HeapAlloc(hHeap,0,(psi->ParmNum+2)*sizeof(PARAMETER_INFO));
     psi->RealParmNum=0;
@@ -1147 +1148 @@
     }
 
-    if(psi->ReturnType==DEF_OBJECT && psi->isReturnRef == false){
+    if(psi->ReturnType==DEF_STRUCT){
         i = psi->RealParmNum;
 
-        //実体オブジェクトを戻り値として持つ場合
+        //構造体を戻り値として持つ場合
         //※第一パラメータ（Thisポインタありの場合は第二パラメータ）を戻り値用の参照宣言にする
 
@@ -1156 +1157 @@
             psi->pRealParmInfo[i].name="_System_ReturnValue";
         else psi->pRealParmInfo[i].name=psi->name;
-        psi->pRealParmInfo[i].type=DEF_OBJECT;
+        psi->pRealParmInfo[i].type=DEF_STRUCT;
         psi->pRealParmInfo[i].u.index=psi->u.ReturnIndex;
         psi->pRealParmInfo[i].bByVal=0;
@@ -1521 +1522 @@
             }
             pi->ReturnType=GetTypeFixed(temporary,&pi->u.ReturnIndex);
-            if(pi->ReturnType==-1) SetError(3,temporary,cp);
-            if(pi->ReturnType==DEF_OBJECT) SetError(40,NULL,cp);
+            if(pi->ReturnType==DEF_NON) SetError(3,temporary,cp);
         }
         else pi->ReturnType=DEF_DOUBLE;
     }
-    else pi->ReturnType=-1;
+    else pi->ReturnType=DEF_NON;
 
     return ProcPtrInfoNum-1;

BasicCompiler_Common/Variable.cpp

@@ -157 +157 @@
     else if(IsPtrType(type))        return PTR_SIZE;
 
-    else if(type==DEF_OBJECT){
+    else if( type == DEF_STRUCT ){
         CClass *pobj_c;
         pobj_c=(CClass *)lpIndex;
-        if(!pobj_c) return 0;
+        if(!pobj_c){
+            SetError(300,NULL,cp);
+            return 0;
+        }
+
         return pobj_c->GetSize();
+    }
+
+    else if(type==DEF_OBJECT){
+        return PTR_SIZE;
     }
     else{
@@ -232 +240 @@
     if(pobj_c){
         *lpNum=(LONG_PTR)pobj_c;
-        return DEF_OBJECT;
+
+        if( pobj_c->IsStructure() ){
+            return DEF_STRUCT;
+        }
+        else{
+            return DEF_OBJECT;
+        }
     }
 
@@ -282 +296 @@
 
     //オブジェクト
-    else if(type==DEF_OBJECT){
+    else if(type==DEF_OBJECT || type==DEF_STRUCT){
         if(lpIndex==0) lstrcpy(name,"non");
         else{
@@ -296 +310 @@
         else{
             extern PROCPTRINFO *pProcPtrInfo;
-            if(pProcPtrInfo[lpIndex].ReturnType==-1)
+            if(pProcPtrInfo[lpIndex].ReturnType==DEF_NON)
                 lstrcpy(name,"*Sub");
             else lstrcpy(name,"*Function");
@@ -316 +330 @@
 }
 
-bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, int &RefType, char *member ){
+bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member ){
     int p1 = 0, p2 = 0;
 
@@ -323 +337 @@
         if( term[i] == '[' ){
             i = JumpStringInBracket( term, i + 1 );
+            if( term[i] == '\0' ) break;
             continue;
         }
@@ -328 +343 @@
             int temp_p = i;
             i = JumpStringInPare( term, i + 1 ) + 1;
+            if( term[i] == '\0' ) break;
             if( term[i] == '.'
                 || term[i] == 1 && term[i] == ESC_PSMEM ){
@@ -348 +364 @@
     //参照タイプ
     if( term[p2] == '.' ){
-        RefType = DEF_OBJECT;
+        refType = CClass::Dot;
     }
     else{
-        RefType = DEF_PTR_OBJECT;
+        refType = CClass::Pointer;
         p2++;
     }
@@ -361 +377 @@
 }
 
-BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember,int *pRefType){
+BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember,CClass::RefType &refType){
     extern int cp;
     int i,i2,i3;
@@ -369 +385 @@
     array2[0]=0;
     NestMember[0]=0;
-    *pRefType=0;
     for(i=0;;i++){
         if(buffer[i]=='\"'){
@@ -428 +443 @@
         if(buffer[i]=='.'){
             lstrcpy(NestMember,buffer+i+1);
-            *pRefType=DEF_OBJECT;
+            refType = CClass::Dot;
             buffer[i]=0;
             break;
@@ -434 +449 @@
         if(buffer[i]==1&&buffer[i+1]==ESC_PSMEM){
             lstrcpy(NestMember,buffer+i+2);
-            *pRefType=DEF_PTR_OBJECT;
+            refType = CClass::Pointer;
             buffer[i]=0;
             break;
@@ -614 +629 @@
     char lpPtrOffset[VN_SIZE];      //第2次配列
     char NestMember[VN_SIZE];   //入れ子メンバ
-    int object_type;            //"."参照のときは0、"->"参照のときは1
+    CClass::RefType refType = CClass::Non;
     lstrcpy(VarName,member);
-    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,&object_type)) return 0;
+    if(!GetVarFormatString(VarName,array,lpPtrOffset,NestMember,refType)) return 0;
 
     for(i=0;i<pobj_c->iMemberNum;i++){
@@ -664 +679 @@
     }
 
-    if(object_type){
+    if( refType != CClass::Non ){
         //入れ子構造の場合
 
@@ -704 +719 @@
 
 
-    int RefType;
-    if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){
+    CClass::RefType refType;
+    if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){
         // 戻り値オブジェクトのメンバを直接参照しているとき
         //例: func().member
@@ -723 +738 @@
 
     lstrcpy(VarName,variable);
-    GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType);
+    GetVarFormatString(VarName,array,lpPtrOffset,member,refType);
 
     int *pSubScripts;
@@ -825 +840 @@
         char tempMember[VN_SIZE];
         char tempArray[VN_SIZE];
-        GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,&i);
+        {
+            CClass::RefType refType;
+            GetVarFormatString(temporary,tempArray,lpPtrOffset,tempMember,refType);
+        }
 
         char temp2[VN_SIZE];
@@ -897 +915 @@
 
     if(member[0]){
-        if(NATURAL_TYPE(type)==DEF_OBJECT)
-            return GetMemberType((CClass *)lpIndex,member,plpIndex,0,bError);
+        if( NATURAL_TYPE(type)==DEF_OBJECT
+            || NATURAL_TYPE(type)==DEF_STRUCT){
+                return GetMemberType((CClass *)lpIndex,member,plpIndex,0,bError);
+        }
     }
 
@@ -921 +941 @@
 }
 
-BOOL GetVarOffsetReadOnly(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
+BOOL GetVarOffsetReadOnly(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss ){
     //読み取り専用で変数へアクセス
     return GetVarOffset(
@@ -932 +952 @@
         pss);
 }
-BOOL GetVarOffsetReadWrite(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss){
+BOOL GetVarOffsetReadWrite(const char *NameBuffer,int *pType,RELATIVE_VAR *pRelativeVar,LONG_PTR *plpIndex,int *pss ){
     //読み書き両用で変数へアクセス
     return GetVarOffset(
@@ -1095 +1115 @@
     }
 
+    /*
+    TODO: 消す
     if( pTypeInfo->type == DEF_OBJECT && InitBuf[0] != '\0' && InitBuf[0] != '[' && isRef == false ){
         if( pTypeInfo->u.pobj_Class->GetCopyConstructorMethod() ){
@@ -1101 +1123 @@
             InitBuf[0] = 0;
         }
-    }
+    }*/
 
     GetArrange(variable,VarName,SubScripts);
@@ -1191 +1213 @@
     lstrcpy(pVar->ConstractParameter,ConstractParameter);
 
-    if(InitBuf[0]||dwFlag==DIMFLAG_INITDEBUGVAR){
-        //初期バッファがあるとき
-        pVar->offset=AllInitGlobalVarSize;
-        AllInitGlobalVarSize+=VarSize;
-    }
-    else{
-        //初期バッファがないとき
-        pVar->offset=AllGlobalVarSize | 0x80000000;
-        AllGlobalVarSize+=VarSize;
-    }
-
     //レキシカルスコープ
     pVar->ScopeLevel=obj_LexScopes.GetNowLevel();
@@ -1210 +1221 @@
     pVar->source_code_address=cp;
 
-    //初期バッファにデータをセット
-    extern BYTE *initGlobalBuf;
-    initGlobalBuf=(BYTE *)HeapReAlloc(hHeap,
-        HEAP_ZERO_MEMORY,
-        initGlobalBuf,
-        AllInitGlobalVarSize);
+    //アラインメントを考慮
+    int alignment = 0;
+    if( pVar->type==DEF_STRUCT ){
+        alignment = pVar->u.pobj_c->iAlign;
+    }
+
+    if(InitBuf[0]||dwFlag==DIMFLAG_INITDEBUGVAR){
+        //初期バッファがあるとき
+
+        if( alignment ){
+            if( AllInitGlobalVarSize % alignment ){
+                AllInitGlobalVarSize += alignment - (AllInitGlobalVarSize % alignment);
+            }
+        }
+
+        pVar->offset=AllInitGlobalVarSize;
+        AllInitGlobalVarSize+=VarSize;
+    }
+    else{
+        //初期バッファがないとき
+
+        if( alignment ){
+            if( AllGlobalVarSize % alignment ){
+                AllGlobalVarSize += alignment - (AllGlobalVarSize % alignment);
+            }
+        }
+
+        pVar->offset=AllGlobalVarSize | 0x80000000;
+        AllGlobalVarSize+=VarSize;
+    }
+
     if(InitBuf[0]){
-        if( pVar->type == DEF_OBJECT && InitBuf[0] != '[' ){
-            //単発式が初期値のオブジェクトの場合
-            //初期値をコピーコンストラクタに渡す
-
-            if( isRef ){
-                SetRefVariable( name, InitBuf );
-            }
-        }
-        else{
-            int result = SetInitGlobalData(pVar->offset,
+        int result = 0;
+        if( pVar->type != DEF_OBJECT ){
+            //初期バッファにデータをセット
+            extern BYTE *initGlobalBuf;
+            initGlobalBuf=(BYTE *)HeapReAlloc(hHeap,
+                HEAP_ZERO_MEMORY,
+                initGlobalBuf,
+                AllInitGlobalVarSize);
+
+            result = SetInitGlobalData(pVar->offset,
                 pVar->type,
                 pVar->u.index,
                 pVar->SubScripts,
                 InitBuf);
-
-            if(!result){
-                //動的な式だった場合は代入演算を行う
-
-                //初期代入時のみ、書き込みアクセスを許可する
-                bool bConstBack = pVar->bConst;
-                pVar->bConst = false;
-
-                //代入
-                char temporary[8192];
-                sprintf(temporary,"%s=%s",name,InitBuf);
-                OpcodeCalc(temporary);
-
-                //アクセス制限を元に戻す
-                pVar->bConst = bConstBack;
-            }
+        }
+
+        if(!result){
+            //動的な式だった場合は代入演算を行う
+
+            //初期代入時のみ、書き込みアクセスを許可する
+            bool bConstBack = pVar->bConst;
+            pVar->bConst = false;
+
+            //代入
+            char temporary[8192];
+            sprintf(temporary,"%s=%s",name,InitBuf);
+            OpcodeCalc(temporary);
+
+            //アクセス制限を元に戻す
+            pVar->bConst = bConstBack;
         }
     }
@@ -1260 +1296 @@
 
 /*
+    TODO: 消す
     if(pTypeInfo->type==DEF_OBJECT){
         //利用対象のクラスコンストラクタ、デストラクタに使用チェックをつける

BasicCompiler_Common/Variable.h

@@ -16 +16 @@
 void GetOriginalTypeName(char *buffer);
 BOOL GetTypeName(int type,LONG_PTR lpIndex,char *name);
-bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, int &RefType, char *member );
-BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember,int *pRefType);
+bool FormatUseProcReturnObject( const char *term, char *procName, char *parameter, CClass::RefType &refType, char *member );
+BOOL GetVarFormatString(char *buffer,char *array,char *array2,char *NestMember, CClass::RefType &refType );
 void GetArrayElement(char *buffer,char *variable,char *array_element);
 BOOL CheckVarNameError(char *name,int NowLine);

BasicCompiler_Common/calculation.cpp

@@ -524 +524 @@
                         StrPtr[pnum][i2]=0;
 
-                        type[pnum]=DEF_PTR_BYTE;
+                        type[pnum]=DEF_PTR_CHAR;
                         before_index[pnum]=LITERAL_STRING;
                     }
@@ -538 +538 @@
                         StrPtr[pnum][i2]=0;
 
-                        type[pnum]=DEF_PTR_BYTE;
+                        type[pnum]=DEF_PTR_CHAR;
                         before_index[pnum]=LITERAL_STRING;
                     }
-                    else if(IsVariableTopChar(Parms[0])||Parms[0]=='*'){
+                    else if(IsVariableTopChar(Parms[0])||Parms[0]=='*'||(Parms[0]=='.'&&IsVariableTopChar(Parms[1]))){
                         if(bDebuggingWatchList){
                             //////////////////////////
@@ -1187 +1187 @@
     return -1;
 }
-BOOL IsStringObjectType(TYPEINFO *pTypeInfo){
-    if(pTypeInfo->type==DEF_OBJECT){
-        if(lstrcmp(pTypeInfo->u.pobj_Class->name,"String")==0){
+bool IsStringObjectType(const TYPEINFO &TypeInfo){
+    if(TypeInfo.type==DEF_OBJECT){
+        if(lstrcmp(TypeInfo.u.pobj_Class->name,"String")==0){
             return 1;
         }
@@ -1209 +1209 @@
         if(psi->ParmNum==2){
             TYPEINFO TypeInfo={psi->pParmInfo[1].type,psi->pParmInfo[1].u.index};
-            if(IsStringObjectType(&TypeInfo)){
+            if(IsStringObjectType( TypeInfo )){
                 bRet=1;
                 goto finish;
@@ -1277 +1277 @@
                         TypeInfo.type=pdi->ReturnType;
                         TypeInfo.u.lpIndex=pdi->u.ReturnIndex;
-                        if(IsStringObjectType(&TypeInfo)) return 1;
+                        if(IsStringObjectType( TypeInfo )) return 1;
                         return 0;
                     }
@@ -1287 +1287 @@
                         TypeInfo.type=psi->ReturnType;
                         TypeInfo.u.lpIndex=psi->u.ReturnIndex;
-                        if(IsStringObjectType(&TypeInfo)) return 1;
+                        if(IsStringObjectType(TypeInfo)) return 1;
                         return 0;
                     }

BasicCompiler_Common/common.h

@@ -546 +546 @@
 BOOL GetConstCalcBuffer(char *name,char *Parameter,char *pCalcBuffer);
 DWORD GetConstValue(char *name,double *dbl,char *buffer,LONG_PTR *plpIndex);
-BOOL IsStringObjectType(TYPEINFO *pTypeInfo);
+bool IsStringObjectType(const TYPEINFO &TypeInfo);
 BOOL IsStringSubsituation(CClass *pobj_c);
 int IsStrCalculation(char *Command);
@@ -615 +615 @@
 //error.cpp
 void SetError(int ErrorNum,const char *KeyWord,int pos);
+void SetError();
 void CompileMessage(char *buffer);
 bool CheckDifferentType(const int VarType,const LONG_PTR lpVarIndex,const int CalcType,const LONG_PTR lpCalcIndex,const char *pszFuncName,const int ParmNum);

BasicCompiler_Common/error.cpp

@@ -183 +183 @@
     if(num==131) lstrcpy(msg,"Const定義されたメソッド内でクラスメンバへの書き込みアクセスはできません。");
     if(num==132) lstrcpy(msg,"明示的なコンストラクタ呼び出しと初期値の指定を同時に行うことはできません。");
+    if(num==133) lstrcpy(msg,"Thisに代入はできません。");
 
     //Enum関連
@@ -359 +360 @@
     ErrorNum++;
 }
+void SetError(){
+    SetError(300,NULL,cp);
+}
 void CompileMessage(char *buffer){
     SetError(-2,buffer,-1);
@@ -397 +401 @@
 
 bool CheckDifferentType(const int VarType,const LONG_PTR lpVarIndex,int CalcType,const LONG_PTR lpCalcIndex,const char *pszFuncName,const int ParmNum){
+
+    if(VarType==DEF_STRUCT||CalcType==DEF_STRUCT){
+        //いずれかが構造体場合
+        if( VarType != CalcType || lpVarIndex != lpCalcIndex ){
+            DifferentTypeError(VarType,lpVarIndex,CalcType,lpCalcIndex,3,pszFuncName,ParmNum);
+            return false;
+        }
+    }
 
     if(VarType==DEF_OBJECT||CalcType==DEF_OBJECT){

ProjectEditor/WindowControl.cpp

@@ -943 +943 @@
             }
             else if(pMenuInfo[i2].type==MFT_SEPARATOR){
-                sprintf(Command+i,"InsMenu %s,0,MF_BYPOSITION\r\n",
+                sprintf(Command+i,"InsMenu %s,0,MF_BYPOSITION,\"\"\r\n",
                     MenuHandle);
                 i+=lstrlen(Command+i);