Index: BasicCompiler64/CParameter.cpp =================================================================== --- BasicCompiler64/CParameter.cpp (revision 63) +++ BasicCompiler64/CParameter.cpp (revision 64) @@ -2,8 +2,10 @@ #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,6 +62,16 @@ int type = NumOpe( ®, 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,4 +93,6 @@ } } + + return stackItemNum * PTR_SIZE; } void CParameter::DeleteTempParameters(){ @@ -90,27 +104,27 @@ 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,8 +147,10 @@ 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,9 +194,10 @@ 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,7 +211,7 @@ 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,4 +226,5 @@ op_mov_RR(reg,REG_R11); } + void CParameter::SetParameter(const char *FuncName,PARAMETER_INFO *ppi,int pi_num,int SecondParmNum){ @@ -298,6 +316,6 @@ } - 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,6 +336,11 @@ 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,4 +442,9 @@ } } + 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,5 +470,7 @@ } } + next: + if(reg==REG_RAX){ //スタックフレームへコピー Index: BasicCompiler64/CommandValue.h =================================================================== --- BasicCompiler64/CommandValue.h (revision 63) +++ BasicCompiler64/CommandValue.h (revision 64) @@ -19,4 +19,5 @@ #define COM_LET 0x1066 #define COM_DELETE 0x1068 +#define COM_SWEEPINGDELETE 0x1069 //その他 Index: BasicCompiler64/Compile_Calc.cpp =================================================================== --- BasicCompiler64/Compile_Calc.cpp (revision 63) +++ BasicCompiler64/Compile_Calc.cpp (revision 64) @@ -11,27 +11,13 @@ 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,4 +151,9 @@ + if( lstrcmpi( variable, "This" ) == 0 ){ + SetError(133,NULL,cp); + return; + } + //////////////////////////////////////// @@ -195,8 +186,12 @@ CalcType=NumOpe(®,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,5 +201,6 @@ &VarType, &VarRelativeVar, - &lpVarIndex)) return; + &lpVarIndex, + NULL)) return; //レジスタのブロッキングを解除 @@ -216,11 +212,11 @@ } - 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,4 +237,6 @@ } +// TODO: 消す +/* void SetRefVariable( const char *varname, const char *expression ){ //////////////////////////////////////// @@ -320,2 +318,3 @@ SetVariableFromRax(VarType,CalcType,&VarRelativeVar); } +*/ Index: BasicCompiler64/Compile_CallProc.cpp =================================================================== --- BasicCompiler64/Compile_CallProc.cpp (revision 63) +++ BasicCompiler64/Compile_CallProc.cpp (revision 64) @@ -12,8 +12,8 @@ //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,5 +96,5 @@ } -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,5 +207,5 @@ /////////////////////////////////////////////////////////////// - // _System_LocalThis、_System_ReturnObjectのダミーをセット + // _System_LocalThisのダミーをセット /////////////////////////////////////////////////////////////// @@ -216,12 +216,11 @@ } - 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,9 +253,8 @@ 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,9 +314,7 @@ 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,5 +325,5 @@ //mov rcx,qword ptr[rsp+offset] ※スタックフレームを利用 - pobj_sf->ref(REG_RCX); + pobj_sf->ref_offset_data(REG_RCX, this_sp_offset); } else{ Index: BasicCompiler64/Compile_Func.cpp =================================================================== --- BasicCompiler64/Compile_Func.cpp (revision 63) +++ BasicCompiler64/Compile_Func.cpp (revision 64) @@ -62,5 +62,5 @@ TYPEINFO TypeInfo={type,lpIndex}; - if(IsStringObjectType(&TypeInfo)){ + if(IsStringObjectType(TypeInfo)){ //Stringオブジェクトの場合 sprintf(temporary,"%s.Length",tempParm); @@ -195,9 +195,15 @@ } 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,7 +216,16 @@ 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 ){ Index: BasicCompiler64/Compile_Object.cpp =================================================================== --- BasicCompiler64/Compile_Object.cpp (revision 63) +++ BasicCompiler64/Compile_Object.cpp (revision 64) @@ -2,5 +2,5 @@ #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,18 +73,134 @@ } } -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(®,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,5 +225,5 @@ } - int type,TypeSize; + int type; type=GetTypeFixed(TypeName,plpIndex); if(type==-1){ @@ -115,5 +231,4 @@ return 0; } - TypeSize=GetTypeSize(type,*plpIndex); if(type!=DEF_OBJECT){ @@ -129,111 +244,13 @@ 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(®,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,5 +271,5 @@ //add rax,PTR_SIZE - op_add64_value(REG_RAX,PTR_SIZE); + op_add_RV(REG_RAX,PTR_SIZE); @@ -261,5 +278,5 @@ //add rax,PTR_SIZE - op_add64_value(REG_RAX,PTR_SIZE); + op_add_RV(REG_RAX,PTR_SIZE); @@ -268,9 +285,9 @@ //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,6 +296,6 @@ 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,6 +326,13 @@ 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); + } } Index: BasicCompiler64/Compile_ProcOp.cpp =================================================================== --- BasicCompiler64/Compile_ProcOp.cpp (revision 63) +++ BasicCompiler64/Compile_ProcOp.cpp (revision 64) @@ -51,5 +51,5 @@ //add rsp,スタックフレームサイズ - op_add64_value(REG_RSP,pobj_sf->GetFrameSize()); + op_add_RV(REG_RSP,pobj_sf->GetFrameSize()); //スタックフレームスケジュール（subコマンドに渡す値） @@ -94,5 +94,5 @@ //add rsp,スタックフレームサイズ - op_add64_value(REG_RSP,pobj_sf->GetFrameSize()); + op_add_RV(REG_RSP,pobj_sf->GetFrameSize()); //スタックフレームスケジュール（subコマンドに渡す値） @@ -118,5 +118,5 @@ //add rsp,8 - op_add64_value(REG_RSP,0x8); + op_add_RV(REG_RSP,0x8); //ret @@ -128,5 +128,5 @@ //add rax,PTR_SIZE - op_add64_value(REG_RAX,PTR_SIZE); + op_add_RV(REG_RAX,PTR_SIZE); //ret @@ -337,13 +337,14 @@ 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,5 +458,5 @@ BaseLocalVar=AllLocalVarSize; - if(psi->ReturnType!=-1){ + if(psi->ReturnType!=DEF_NON){ //戻り値が存在するとき @@ -464,10 +465,6 @@ 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,8 +490,8 @@ //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,29 +568,12 @@ for(i3=0;i3iMemberNum;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;i4psi ); - } - } - } + 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,5 +645,6 @@ } - //実体クラスを持つメンバのデストラクタを呼び出す + //実体クラスを持つメンバのデストラクタ呼び出しはGCに任せる + /* //※コンストラクタと逆順序で呼び出す for(i3=pobj_CompilingClass->iMemberNum-1;i3>=0;i3--){ @@ -678,5 +659,5 @@ 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,5 +667,5 @@ //add rcx,offset - op_add64_value(REG_RCX,offset+i4*MemberTypeSize); + op_add_RV(REG_RCX,offset+i4*MemberTypeSize); //call destructor @@ -693,5 +674,5 @@ } } - } + }*/ } } @@ -743,5 +724,5 @@ } - if(psi->ReturnType!=-1){ + if(psi->ReturnType!=DEF_NON){ ////////////////////////////////// // 戻り値をraxまたはxmm0に設定 @@ -759,6 +740,10 @@ 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){ Index: BasicCompiler64/Compile_Set_Var.cpp =================================================================== --- BasicCompiler64/Compile_Set_Var.cpp (revision 63) +++ BasicCompiler64/Compile_Set_Var.cpp (revision 64) @@ -7,5 +7,5 @@ } -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,5 +36,6 @@ } - +/* + TODO: 消す /////////////////////////////////////////////////////////////////// // オペレータ '=' のオーバーロード関数を呼ぶ @@ -59,5 +60,5 @@ int iRet; iRet=CallOperatorProc(CALC_SUBSITUATION,NULL,type,index_stack,array_bUseHeap,sp); - +*/ //右辺用レジスタを解除 if(IsRealNumberType(CalcType)) pobj_reg->UnlockXmmReg(); @@ -71,16 +72,10 @@ 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,4 +117,5 @@ SetError(1,NULL,cp); } + void SetDoubleVariable(int type,RELATIVE_VAR *pRelative){ @@ -305,4 +301,14 @@ } } +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){ Index: BasicCompiler64/Compile_Statement.cpp =================================================================== --- BasicCompiler64/Compile_Statement.cpp (revision 63) +++ BasicCompiler64/Compile_Statement.cpp (revision 64) @@ -99,5 +99,5 @@ ///////////////////// - if(i2==DEF_OBJECT){ + if(i2==DEF_STRUCT){ //mov r14,rax op_mov_RR(REG_R14,REG_RAX); @@ -888,5 +888,5 @@ //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,4 +951,6 @@ else temp=pCompilingSubInfo->name; + /* + TODO: 消す if( pCompilingSubInfo->isReturnRef ){ //参照型 @@ -956,9 +958,9 @@ } else{ - //値型 + //値型*/ char temporary[VN_SIZE]; sprintf(temporary,"%s=%s",temp,Parameter); OpcodeCalc(temporary); - } + //} } @@ -968,11 +970,9 @@ } -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,5 +1084,5 @@ 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,8 +1090,11 @@ 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,12 +1102,12 @@ 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,31 +1117,31 @@ 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,5 +1172,5 @@ i4++; - if(Parameter[i2]=='\0') break; + if(parms[i2]=='\0') break; } sprintf(temp2,"_System_UsingDataType[%d]=-1",i4); @@ -1183,10 +1186,8 @@ 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]=='#'){ Index: BasicCompiler64/Compile_Var.cpp =================================================================== --- BasicCompiler64/Compile_Var.cpp (revision 63) +++ BasicCompiler64/Compile_Var.cpp (revision 64) @@ -41,16 +41,10 @@ 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,4 +65,18 @@ //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,5 +161,5 @@ //imul reg,i4 - op_imul_value(sizeof(_int64),reg,i4); + op_imul_RV(sizeof(_int64),reg,i4); //add r12,reg @@ -192,7 +200,7 @@ 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,16 +287,21 @@ //入れ子構造の場合 - 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,29 +316,18 @@ 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,5 +390,5 @@ 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,5 +400,6 @@ else lstrcpy(variable,NameBuffer); - if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){ + CClass::RefType refType; + if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){ // 戻り値オブジェクトのメンバを直接参照しているとき //例: func().member @@ -442,5 +445,5 @@ lstrcpy(VarName,variable); - GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType); + GetVarFormatString(VarName,array,lpPtrOffset,member,refType); int *pSubScripts; @@ -581,5 +584,8 @@ 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,17 +703,22 @@ } 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,5 +730,5 @@ else{ //pObj->member - if(RefType!=DEF_PTR_OBJECT){ + if( refType != CClass::Pointer ){ SetError(104,VarName,cp); pRelativeVar->dwKind=NON_VAR; @@ -732,9 +743,9 @@ } } - 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,5 +826,5 @@ } - if(type==DEF_OBJECT){ + if(type==DEF_STRUCT){ CClass *pobj_c; pobj_c=(CClass *)lpIndex; @@ -848,6 +859,6 @@ /////////////////////////////////////// - if( type == DEF_OBJECT){ - //オブジェクトの場合はありえない + if( type == DEF_OBJECT || type == DEF_STRUCT ){ + //オブジェクトまたは構造体の場合はありえない SetError(300,NULL,cp); return 0; @@ -888,5 +899,5 @@ *(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,5 +964,5 @@ } - if(type==DEF_OBJECT){ + if(type==DEF_STRUCT){ CClass *pobj_c; pobj_c=(CClass *)lpIndex; @@ -1037,5 +1048,5 @@ } 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,9 +1112,161 @@ } - +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;i2fRef = 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,4 +1335,5 @@ TypeSize=GetTypeSize(TypeInfo.type,TypeInfo.u.lpIndex); + extern BOOL bCompilingGlobal; if(dwFlags&DIMFLAG_STATIC){ if(bCompilingGlobal){ @@ -1186,5 +1350,5 @@ GetNowStaticVarFullName(VarName,temporary); - AddGlobalVariable(isRef,temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags); + dim( isRef,temporary,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags ); /* @@ -1194,124 +1358,5 @@ } else{ - if(bCompilingGlobal){ - ///////////////////////// - // グローバル変数 - ///////////////////////// - - AddGlobalVariable(isRef,VarName,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags); - } - else{ - ///////////////// - // ローカル変数 - ///////////////// - - for(i2=0;i2fRef = 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,5 +1407,5 @@ //mov reg,r11 - op_mov64_ToReg_FromReg(reg,REG_R11); + op_mov_RR(reg,REG_R11); } else{ @@ -1404,12 +1449,12 @@ //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,5 +1486,5 @@ directmem: //mov reg,r11 - op_mov64_ToReg_FromReg(reg,REG_R11); + op_mov_RR(reg,REG_R11); } } Index: BasicCompiler64/MakePeHdr.cpp =================================================================== --- BasicCompiler64/MakePeHdr.cpp (revision 63) +++ BasicCompiler64/MakePeHdr.cpp (revision 64) @@ -19,5 +19,8 @@ *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,4 +218,13 @@ 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,5 +357,5 @@ //add rsp,スタックフレームサイズ - op_add64_value(REG_RSP,pobj_sf->GetFrameSize()); + op_add_RV(REG_RSP,pobj_sf->GetFrameSize()); //xor rax,rax（raxを0に初期化する） Index: BasicCompiler64/NumOpe.cpp =================================================================== --- BasicCompiler64/NumOpe.cpp (revision 63) +++ BasicCompiler64/NumOpe.cpp (revision 64) @@ -14,50 +14,16 @@ ////////////////////////////////////////////////////// + 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,7 +31,4 @@ RESTORE_REGISTER_RESOURCE }//////////////////////////////////////////// - - //mov reg,r11 - op_mov_RR(reg,REG_R11); } @@ -102,5 +65,5 @@ else{ //mov reg,rax - op_mov64_ToReg_FromReg(UseReg,REG_RAX); + op_mov_RR(UseReg,REG_RAX); } } @@ -117,7 +80,13 @@ } - 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,5 +214,5 @@ TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex}; if(IsStringSubsituation(pobj_Class) - || IsStringObjectType(&BaseTypeInfo)){ + || IsStringObjectType(BaseTypeInfo)){ //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合 @@ -265,5 +234,5 @@ } - type[sp]=DEF_PTR_BYTE; + type[sp]=DEF_PTR_CHAR; bLiteralCalculation=0; @@ -375,6 +344,6 @@ else pobj_reg->LockReg(); - if(i2==DEF_OBJECT){ - //Object型が戻ったときはヒープ領域にインスタンスが格納されている + if(i2==DEF_STRUCT){ + //構造体が戻ったときはヒープ領域にインスタンスが格納されている //※後にfreeする必要あり bUseHeap[sp]=1; @@ -469,10 +438,10 @@ 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,6 +554,6 @@ }//////////////////////////////////////////// - if(type[sp]==DEF_OBJECT){ - //Object型が戻ったときはヒープ領域にインスタンスが格納されている + if(type[sp]==DEF_STRUCT){ + //構造体が戻ったときはヒープ領域にインスタンスが格納されている //※後にfreeする必要あり bUseHeap[sp]=1; Index: BasicCompiler64/NumOpe_Arithmetic.cpp =================================================================== --- BasicCompiler64/NumOpe_Arithmetic.cpp (revision 63) +++ BasicCompiler64/NumOpe_Arithmetic.cpp (revision 64) @@ -108,5 +108,5 @@ else if(idCalc==CALC_PRODUCT){ //mul reg1,reg2 - op_imul_reg(sizeof(_int64),reg1,reg2); + op_imul_RR(sizeof(_int64),reg1,reg2); } @@ -131,5 +131,5 @@ else if(idCalc==CALC_PRODUCT){ //mul reg1,reg2 - op_imul_reg(sizeof(long),reg1,reg2); + op_imul_RR(sizeof(long),reg1,reg2); } @@ -177,5 +177,5 @@ 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,5 +203,5 @@ //mov rax,reg1 - op_mov64_ToReg_FromReg(REG_RAX,reg1); + op_mov_RR(REG_RAX,reg1); if(IsSignedType(type[sp-2])){ @@ -231,5 +231,5 @@ //mov reg1,rdx - op_mov64_ToReg_FromReg(reg1,REG_RDX); + op_mov_RR(reg1,REG_RDX); } @@ -353,5 +353,5 @@ 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,5 +379,5 @@ //mov rax,reg1 - op_mov64_ToReg_FromReg(REG_RAX,reg1); + op_mov_RR(REG_RAX,reg1); if(IsSignedType(type[sp-2])){ @@ -407,5 +407,5 @@ //mov reg1,rax - op_mov64_ToReg_FromReg(reg1,REG_RAX); + op_mov_RR(reg1,REG_RAX); } @@ -495,5 +495,5 @@ //imul reg,-1 - op_imul_value(sizeof(_int64),reg,-1); + op_imul_RV(sizeof(_int64),reg,-1); if(reg==REG_R14){ @@ -508,5 +508,5 @@ //imul reg,-1 - op_imul_value(sizeof(long),reg,-1); + op_imul_RV(sizeof(long),reg,-1); if(reg==REG_R14){ @@ -617,5 +617,5 @@ 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,5 +629,5 @@ //mov rcx,reg2 - op_mov64_ToReg_FromReg(REG_RCX,reg2); + op_mov_RR(REG_RCX,reg2); if(idCalc==CALC_SHL){ @@ -662,5 +662,5 @@ if(sw==0){ //mov rcx,r15 - op_mov64_ToReg_FromReg(REG_RCX,REG_R15); + op_mov_RR(REG_RCX,REG_R15); } else{ Index: BasicCompiler64/NumOpe_Logical.cpp =================================================================== --- BasicCompiler64/NumOpe_Logical.cpp (revision 63) +++ BasicCompiler64/NumOpe_Logical.cpp (revision 64) @@ -112,5 +112,5 @@ //add rax, 1 - op_add64_value( REG_RAX, 1 ); + op_add_RV( REG_RAX, 1 ); if( reg != REG_RAX ){ Index: BasicCompiler64/Opcode.h =================================================================== --- BasicCompiler64/Opcode.h (revision 63) +++ BasicCompiler64/Opcode.h (revision 64) @@ -125,4 +125,6 @@ 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,5 +132,5 @@ 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,5 +249,4 @@ void SetVariableFromRax(int VarType,int CalcType,RELATIVE_VAR *pRelativeVar); void OpcodeCalc(char *Command); -void SetRefVariable( const char *varname, const char *expression ); //NumOpe.cpp @@ -285,7 +286,6 @@ //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,6 +307,7 @@ //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,8 +320,12 @@ #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,8 +357,8 @@ 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,5 +385,5 @@ #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,6 +415,6 @@ 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,5 +455,4 @@ 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,5 +464,5 @@ 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,6 +471,6 @@ 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); Index: BasicCompiler64/OperatorProc.cpp =================================================================== --- BasicCompiler64/OperatorProc.cpp (revision 63) +++ BasicCompiler64/OperatorProc.cpp (revision 64) @@ -55,5 +55,4 @@ if(pBaseTypeInfo){ if(pBaseTypeInfo->type==DEF_OBJECT){ - bReturnTypeIsObject=1; ReturnType.u.lpIndex=pBaseTypeInfo->u.lpIndex; } @@ -113,10 +112,6 @@ 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,9 +119,8 @@ } - - if(psi->ReturnType==DEF_OBJECT){ - ////////////////////////////////////////////////////// - // 戻り値にオブジェクト インスタンスを持つ場合 - // ※ByRef _System_ReturnObject パラメータ用領域を取得 + if(psi->ReturnType==DEF_STRUCT){ + ////////////////////////////////////////////////////// + // 戻り値に構造体インスタンスを持つ場合 + // ※ByRef _System_ReturnValue パラメータ用領域を取得 ////////////////////////////////////////////////////// @@ -154,5 +148,4 @@ }//////////////////////////////////////////// } - int reg1,reg2; @@ -161,4 +154,9 @@ SetOneTermToReg_Whole64Calc(type[sp-1],®2); pobj_reg->UnlockReg(); + if( !psi->pRealParmInfo[1].bByVal ){ + //一時参照を作成 + pobj_sf->push( reg2 ); + pobj_sf->mov_sp( reg2 ); + } } @@ -192,5 +190,5 @@ if(bTwoTerm){ - if(psi->ReturnType==DEF_OBJECT){ + if(psi->ReturnType==DEF_STRUCT){ //mov r8,reg2 op_mov_RR(REG_R8,reg2); @@ -202,5 +200,5 @@ } - if(psi->ReturnType==DEF_OBJECT){ + if(psi->ReturnType==DEF_STRUCT){ //mov rdx,r13 op_mov_RR(REG_RDX,REG_R13); @@ -213,5 +211,5 @@ op_call(psi); - if(psi->ReturnType!=-1){ + if(psi->ReturnType!=DEF_NON){ //戻り値を一時的に退避 @@ -254,5 +252,12 @@ } - 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,6 +271,6 @@ index_stack[sp-1]=psi->u.ReturnIndex; - if(psi->ReturnType==DEF_OBJECT){ - //Object型が戻ったときはヒープ領域にインスタンスが格納されている + if(psi->ReturnType==DEF_STRUCT){ + //構造体が戻ったときはヒープ領域にインスタンスが格納されている //※後にfreeする必要あり bUseHeap[sp-1]=1; Index: BasicCompiler64/WatchList.cpp =================================================================== --- BasicCompiler64/WatchList.cpp (revision 63) +++ BasicCompiler64/WatchList.cpp (revision 64) @@ -78,11 +78,5 @@ 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,7 +108,7 @@ 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,12 +169,21 @@ //入れ子構造の場合 - 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,5 +193,5 @@ } else{ - if(RefType!=DEF_PTR_OBJECT) return 0; + if( refType != CClass::Pointer ) return 0; extern HANDLE hDebugProcess; @@ -320,5 +323,5 @@ 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,5 +329,6 @@ lstrcpy(VarName,variable); - GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType); + CClass::RefType refType; + GetVarFormatString(VarName,array,lpPtrOffset,member,refType); LONG_PTR lpIndex; @@ -474,7 +478,7 @@ } 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,9 +497,9 @@ *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,5 +519,5 @@ else{ //pObj->member - if(RefType!=DEF_PTR_OBJECT) return 0; + if( refType != CClass::Pointer ) return 0; pRelativeVar->offset=Debugging_GetVarPtr(pRelativeVar); Index: BasicCompiler64/amd64_main.cpp =================================================================== --- BasicCompiler64/amd64_main.cpp (revision 63) +++ BasicCompiler64/amd64_main.cpp (revision 64) @@ -424,5 +424,24 @@ 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&®1<=REG_RDI){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; + if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; + } + if(REG_R8<=reg1&®1<=REG_R15){ + if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; + if(REG_R8<=reg2&®2<=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,26 +494,4 @@ } } -void op_mov64_ToReg_FromReg(int reg1,int reg2){ - //mov reg1,reg2 - char RexByte=-1; - - if(reg1==reg2) return; - - if(REG_RAX<=reg1&®1<=REG_RDI){ - if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x48; - if(REG_R8<=reg2&®2<=REG_R15) RexByte=(char)0x49; - } - if(REG_R8<=reg1&®1<=REG_R15){ - if(REG_RAX<=reg2&®2<=REG_RDI) RexByte=(char)0x4C; - if(REG_R8<=reg2&®2<=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,5 +683,5 @@ } -void op_add64_value(int reg,int offset){ +void op_add_RV(int reg,int offset){ //add reg,offset char RexByte=-1; @@ -843,5 +840,5 @@ //////////////////////// -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,5 +878,5 @@ 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; Index: BasicCompiler64/stack_frame.cpp =================================================================== --- BasicCompiler64/stack_frame.cpp (revision 63) +++ BasicCompiler64/stack_frame.cpp (revision 64) @@ -38,4 +38,19 @@ } 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){ Index: BasicCompiler64/varlist.cpp =================================================================== --- BasicCompiler64/varlist.cpp (revision 63) +++ BasicCompiler64/varlist.cpp (revision 64) @@ -22,5 +22,11 @@ _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,5 +37,5 @@ 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,5 +49,5 @@ } 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++){