Index: BasicCompiler32/CParameter.cpp =================================================================== --- BasicCompiler32/CParameter.cpp (revision 63) +++ BasicCompiler32/CParameter.cpp (revision 64) @@ -2,13 +2,12 @@ #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,4 +63,15 @@ 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,54 +90,41 @@ 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,8 +140,10 @@ - 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,9 +184,12 @@ } } - else{ + else{*/ + + //push eax op_push(REG_EAX); - +/* + TODO: 消す if( pobj_Class->GetConstructorMethod() ){ //////////////////////////////// @@ -201,14 +203,13 @@ 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,6 +281,6 @@ } - 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,6 +300,11 @@ 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,5 +334,5 @@ 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,39 +360,13 @@ } 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,13 +375,49 @@ 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); + } } } Index: BasicCompiler32/Compile_Calc.cpp =================================================================== --- BasicCompiler32/Compile_Calc.cpp (revision 63) +++ BasicCompiler32/Compile_Calc.cpp (revision 64) @@ -364,4 +364,66 @@ //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,4 +547,11 @@ } + + if( lstrcmpi( variable, "This" ) == 0 ){ + SetError(133,NULL,cp); + return; + } + + //////////////////////////////////////// // 変数のタイプ型を識別して、演算を行う @@ -511,6 +580,6 @@ else ProcPtr_BaseIndex=-1; - if(VarType==DEF_OBJECT){ - //代入演算のオーバーロード オペレータに備える + if(VarType==DEF_STRUCT){ + //代入コピーに備える //変数アドレスを取得 @@ -544,11 +613,11 @@ } - 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,4 +637,10 @@ ///////////////////////////////////////////////// + //eax、edx:eax、またはst(0)にスタック上のデータを取り出す + RestoreDefaultRegisterFromStackMemory( CalcType ); + + SetVariableFromEax( VarType, CalcType, &VarRelativeVar ); +/* + TODO: 消す if(VarType==DEF_BOOLEAN){ //bool @@ -598,7 +673,10 @@ //Single型変数へスタックの内容を格納する SetSingleVariable(CalcType,VarRelativeVar.dwKind,VarRelativeVar.offset,VarRelativeVar.bOffsetOffset); - } -} - + }*/ +} + + +// TODO: 消す +/* void SetRefVariable( const char *varname, const char *expression ){ //////////////////////////////////////// @@ -721,2 +799,3 @@ } } +*/ Index: BasicCompiler32/Compile_CallProc.cpp =================================================================== --- BasicCompiler32/Compile_CallProc.cpp (revision 63) +++ BasicCompiler32/Compile_CallProc.cpp (revision 64) @@ -94,5 +94,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; @@ -206,5 +206,5 @@ /////////////////////////////////////////////////////////////// - // _System_LocalThis、_System_ReturnObjectのダミーをセット + // _System_LocalThisのダミーをセット /////////////////////////////////////////////////////////////// @@ -215,9 +215,4 @@ } - 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,5 +241,5 @@ //一時オブジェクトを生成 - 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,9 +247,8 @@ 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,14 +288,6 @@ 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,10 +296,7 @@ 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{ Index: BasicCompiler32/Compile_Func.cpp =================================================================== --- BasicCompiler32/Compile_Func.cpp (revision 63) +++ BasicCompiler32/Compile_Func.cpp (revision 64) @@ -208,5 +208,5 @@ TYPEINFO TypeInfo={type,lpIndex}; - if(IsStringObjectType(&TypeInfo)){ + if(IsStringObjectType(TypeInfo)){ //Stringオブジェクトの場合 char temporary[VN_SIZE]; @@ -346,19 +346,18 @@ } 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,7 +367,16 @@ 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){ Index: BasicCompiler32/Compile_Object.cpp =================================================================== --- BasicCompiler32/Compile_Object.cpp (revision 63) +++ BasicCompiler32/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){ //////////////////////////// // コンストラクタの呼び出し @@ -74,6 +74,146 @@ } } -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,10 +221,10 @@ 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,134 +269,13 @@ 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,6 +374,13 @@ ////////////////////////////////////////// - //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: BasicCompiler32/Compile_ProcOp.cpp =================================================================== --- BasicCompiler32/Compile_ProcOp.cpp (revision 63) +++ BasicCompiler32/Compile_ProcOp.cpp (revision 64) @@ -293,13 +293,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; @@ -370,5 +371,5 @@ OpBuffer[obp++]=(char)0x57; - if(psi->ReturnType!=-1){ + if(psi->ReturnType!=DEF_NON){ //戻り値が存在するとき @@ -377,10 +378,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{ @@ -517,35 +514,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 ); } } @@ -619,5 +593,6 @@ } - //実体クラスを持つメンバのデストラクタを呼び出す + //実体クラスを持つメンバのデストラクタ呼び出しはGCに任せる + /* //※コンストラクタと逆順序で呼び出す int offset; @@ -658,5 +633,5 @@ } } - } + }*/ } } @@ -706,5 +681,5 @@ if(bDebugCompile&&bDebugSupportProc==0){ - *((long *)(OpBuffer+EspOffsetSchedule))=AllLocalVarSize-BaseOffset; + *((long *)(OpBuffer+EspOffsetSchedule))=AllLocalVarSize-BaseOffset-sizeof(long); //call _DebugSys_EndProc @@ -713,5 +688,5 @@ } - if(psi->ReturnType!=-1){ + if(psi->ReturnType!=DEF_NON){ //戻り値をeax、edxに設定 RELATIVE_VAR RelativeVar; @@ -726,6 +701,10 @@ 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,4 +797,19 @@ 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; Index: BasicCompiler32/Compile_Set_Var.cpp =================================================================== --- BasicCompiler32/Compile_Set_Var.cpp (revision 63) +++ BasicCompiler32/Compile_Set_Var.cpp (revision 64) @@ -7,5 +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,14 +34,13 @@ //成功したとき、またはエラーが発行されたとき 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,4 +82,338 @@ } + +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,55 +1307,3 @@ } } -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); -} +*/ Index: BasicCompiler32/Compile_Statement.cpp =================================================================== --- BasicCompiler32/Compile_Statement.cpp (revision 63) +++ BasicCompiler32/Compile_Statement.cpp (revision 64) @@ -105,5 +105,5 @@ OpBuffer[obp++]=(char)0xD8; } - if(i2==DEF_OBJECT){ + if(i2==DEF_STRUCT){ //mov ebx,eax op_mov_RR(REG_EBX,REG_EAX); @@ -1336,4 +1336,6 @@ else temp=pCompilingSubInfo->name; + /* + TODO: 消す if( pCompilingSubInfo->isReturnRef ){ //参照型 @@ -1341,9 +1343,9 @@ } else{ - //値型 + //値型*/ char temporary[VN_SIZE]; sprintf(temporary,"%s=%s",temp,Parameter); OpcodeCalc(temporary); - } + //} } @@ -1353,11 +1355,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]=='#'){ @@ -1469,5 +1469,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; @@ -1475,8 +1475,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; @@ -1484,12 +1487,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\""); @@ -1499,31 +1502,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'){ @@ -1554,5 +1557,5 @@ i4++; - if(Parameter[i2]=='\0') break; + if(parms[i2]=='\0') break; } sprintf(temp2,"_System_UsingDataType[%d]=-1",i4); @@ -1568,10 +1571,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: BasicCompiler32/Compile_Var.cpp =================================================================== --- BasicCompiler32/Compile_Var.cpp (revision 63) +++ BasicCompiler32/Compile_Var.cpp (revision 64) @@ -23,23 +23,10 @@ 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,4 +43,18 @@ 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,7 +169,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; //////////////////////////// @@ -251,16 +252,21 @@ //入れ子構造の場合 - 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,31 +281,18 @@ 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,5 +357,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]; @@ -374,6 +367,6 @@ else lstrcpy(variable,NameBuffer); - - if( FormatUseProcReturnObject( variable, VarName, array, RefType, member ) ){ + CClass::RefType refType; + if( FormatUseProcReturnObject( variable, VarName, array, refType, member ) ){ // 戻り値オブジェクトのメンバを直接参照しているとき //例: func().member @@ -410,5 +403,5 @@ lstrcpy(VarName,variable); - GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType); + GetVarFormatString(VarName,array,lpPtrOffset,member,refType); int *pSubScripts; @@ -546,7 +539,11 @@ 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,17 +662,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; @@ -687,5 +689,5 @@ else{ //pObj->member - if(RefType!=DEF_PTR_OBJECT){ + if( refType != CClass::Pointer ){ SetError(104,VarName,cp); pRelativeVar->dwKind=NON_VAR; @@ -701,9 +703,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; @@ -785,5 +787,5 @@ } - if(type==DEF_OBJECT){ + if(type==DEF_STRUCT){ CClass *pobj_c; pobj_c=(CClass *)lpIndex; @@ -818,6 +820,6 @@ /////////////////////////////////////// - if( type == DEF_OBJECT){ - //オブジェクトの場合はありえない + if( type == DEF_OBJECT || type == DEF_STRUCT ){ + //オブジェクトまたは構造体の場合はありえない SetError(300,NULL,cp); return 0; @@ -855,5 +857,5 @@ *(_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,5 +920,5 @@ } - if(type==DEF_OBJECT){ + if(type==DEF_STRUCT){ CClass *pobj_c; pobj_c=(CClass *)lpIndex; @@ -1045,5 +1047,5 @@ } 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,8 +1104,159 @@ } +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%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,5 +1340,5 @@ GetNowStaticVarFullName(VarName,temporary); - AddGlobalVariable(isRef, temporary,SubScripts,&TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags); + dim( isRef,temporary,SubScripts,TypeInfo,TypeSize,InitBuf,ConstractParameter,dwFlags ); /* @@ -1195,129 +1348,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%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 ); } } Index: BasicCompiler32/MakePeHdr.cpp =================================================================== --- BasicCompiler32/MakePeHdr.cpp (revision 63) +++ BasicCompiler32/MakePeHdr.cpp (revision 64) @@ -22,4 +22,7 @@ *pSub_realloc, *pSub_free, + *pSub_System_GC_malloc_ForObject, + *pSub_System_GC_malloc_ForObjectPtr, + *pSub_System_GC_free_for_SweepingDelete, *pSub_allrem, @@ -30,5 +33,7 @@ *pSub_allshl, *pSub_allshr, - *pSub_aullshr; + *pSub_aullshr, + + *pSub_esp_error; @@ -227,4 +232,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; + pSub_allrem=GetSubHash("_allrem"); pSub_allrem->bUse=1; @@ -258,4 +272,9 @@ pSub_aullshr->bUse=1; pSub_aullshr->bSystem=1; + + pSub_esp_error=GetSubHash("_esp_error"); + pSub_esp_error->bUse=1; + + Index: BasicCompiler32/NumOpe.cpp =================================================================== --- BasicCompiler32/NumOpe.cpp (revision 63) +++ BasicCompiler32/NumOpe.cpp (revision 64) @@ -6,5 +6,5 @@ //※この処理内では、esi、ediは使用不可 - if(type==DEF_OBJECT){ + if(type==DEF_OBJECT || type==DEF_STRUCT){ //push eax op_push(REG_EAX); @@ -62,7 +62,6 @@ op_push(REG_EAX); } - else if(type==DEF_PTR_BYTE){ - //push eax - op_push(REG_EAX); + else{ + SetError(); } } @@ -71,42 +70,16 @@ /////////////////////////////////////////////////////// // 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,7 +95,10 @@ } - 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,5 +197,5 @@ TYPEINFO BaseTypeInfo = {BaseType,lpBaseIndex}; if(IsStringSubsituation(pobj_Class) - || IsStringObjectType(&BaseTypeInfo)){ + || IsStringObjectType(BaseTypeInfo)){ //要求タイプがオブジェクトであり、Stringの受け入れが可能な場合 @@ -239,5 +215,5 @@ - type[sp]=DEF_PTR_BYTE; + type[sp]=DEF_PTR_CHAR; index_stack[sp]=LITERAL_STRING; bLiteralCalculation=0; @@ -329,6 +305,6 @@ } - if(i2==DEF_OBJECT){ - //Object型が戻ったときはヒープ領域にインスタンスが格納されている + if(i2==DEF_STRUCT){ + //構造体が戻ったときはヒープ領域にインスタンスが格納されている //※後にfreeする必要あり bUseHeap[sp]=1; @@ -413,5 +389,5 @@ } else if(i2==DEF_LONG||i2==DEF_DWORD||i2==DEF_SINGLE|| - IsPtrType(i2)){ + IsPtrType(i2) || i2==DEF_OBJECT){ //32ビット型 PushLongVariable(&RelativeVar); @@ -429,6 +405,6 @@ PushByteVariable(&RelativeVar); } - else if(i2==DEF_OBJECT){ - //オブジェクト ポインタをeaxへ格納 + else if(i2==DEF_STRUCT){ + //構造体ポインタをeaxへ格納（構造体は値型） SetVarPtrToEax(&RelativeVar); @@ -436,4 +412,5 @@ op_push(REG_EAX); } + else SetError(11,term,cp); if(Is64Type(type[sp])&&IsWholeNumberType(i2)&&GetTypeSize(i2,-1)<=sizeof(long)){ @@ -517,6 +494,6 @@ PushReturnValue(RetTypeInfo.type); - if(type[sp]==DEF_OBJECT){ - //Object型が戻ったときはヒープ領域にインスタンスが格納されている + if(type[sp]==DEF_STRUCT){ + //構造体が戻ったときはヒープ領域にインスタンスが格納されている //※後にfreeする必要あり bUseHeap[sp]=1; Index: BasicCompiler32/NumOpe_Relation.cpp =================================================================== --- BasicCompiler32/NumOpe_Relation.cpp (revision 63) +++ BasicCompiler32/NumOpe_Relation.cpp (revision 64) @@ -1313,5 +1313,5 @@ OpBuffer[obp++]=(char)0xC3; - //jnz 4（次のxorとjmpを飛び越す） + //jz 4（次のxorとjmpを飛び越す） OpBuffer[obp++]=(char)0x74; OpBuffer[obp++]=(char)0x04; Index: BasicCompiler32/Opcode.h =================================================================== --- BasicCompiler32/Opcode.h (revision 63) +++ BasicCompiler32/Opcode.h (revision 64) @@ -97,6 +97,6 @@ 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,5 +136,8 @@ //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,6 +174,7 @@ //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,8 +187,12 @@ #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,9 +224,9 @@ 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,5 +236,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); @@ -258,6 +266,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); @@ -300,4 +308,6 @@ 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,4 +322,5 @@ 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 ); Index: BasicCompiler32/OperatorProc.cpp =================================================================== --- BasicCompiler32/OperatorProc.cpp (revision 63) +++ BasicCompiler32/OperatorProc.cpp (revision 64) @@ -50,5 +50,4 @@ if(pBaseTypeInfo){ if(pBaseTypeInfo->type==DEF_OBJECT){ - bReturnTypeIsObject=1; ReturnType.u.lpIndex=pBaseTypeInfo->u.lpIndex; } @@ -107,10 +106,8 @@ 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,8 +116,8 @@ - if(psi->ReturnType==DEF_OBJECT){ + if(psi->ReturnType==DEF_STRUCT){ ////////////////////////////////////////////////////// - // 戻り値にオブジェクト インスタンスを持つ場合 - // ※ByRef _System_ReturnObject パラメータ用領域を取得 + // 戻り値に構造体インスタンスを持つ場合 + // ※ByRef _System_ReturnValue パラメータ用領域を取得 ////////////////////////////////////////////////////// @@ -182,7 +179,17 @@ 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,5 +202,12 @@ 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,6 +225,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: BasicCompiler32/VarList.cpp =================================================================== --- BasicCompiler32/VarList.cpp (revision 63) +++ BasicCompiler32/VarList.cpp (revision 64) @@ -20,5 +20,11 @@ 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,5 +35,5 @@ 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,5 +47,5 @@ } 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++){ Index: BasicCompiler32/WatchList.cpp =================================================================== --- BasicCompiler32/WatchList.cpp (revision 63) +++ BasicCompiler32/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; @@ -319,5 +322,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]; ULONG_PTR lpData; @@ -325,5 +328,6 @@ lstrcpy(VarName,variable); - GetVarFormatString(VarName,array,lpPtrOffset,member,&RefType); + CClass::RefType refType; + GetVarFormatString(VarName,array,lpPtrOffset,member,refType); LONG_PTR lpIndex; @@ -470,7 +474,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; } @@ -489,9 +493,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); @@ -511,5 +515,5 @@ else{ //pObj->member - if(RefType!=DEF_PTR_OBJECT) return 0; + if( refType != CClass::Pointer ) return 0; pRelativeVar->offset=Debugging_GetVarPtr(pRelativeVar); Index: BasicCompiler32/commandvalue.h =================================================================== --- BasicCompiler32/commandvalue.h (revision 63) +++ BasicCompiler32/commandvalue.h (revision 64) @@ -19,4 +19,5 @@ #define COM_LET 0x1066 #define COM_DELETE 0x1068 +#define COM_SWEEPINGDELETE 0x1069 //その他 Index: BasicCompiler32/increment.cpp =================================================================== --- BasicCompiler32/increment.cpp (revision 63) +++ BasicCompiler32/increment.cpp (revision 64) @@ -1,242 +1,4 @@ #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,4 +200,4 @@ } - SetVariableFromReg(VarType,VarType,&VarRelativeVar); + SetVariableFromEax(VarType,VarType,&VarRelativeVar); } Index: BasicCompiler32/op32_main.cpp =================================================================== --- BasicCompiler32/op32_main.cpp (revision 63) +++ BasicCompiler32/op32_main.cpp (revision 64) @@ -372,4 +372,46 @@ +//////////////////////// +// 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,4 +510,9 @@ void op_push(int reg){ //push reg + + if( reg == REG_NON ){ + op_sub_esp( PTR_SIZE ); + return; + } //オペコード、レジスタ @@ -489,4 +536,9 @@ //pop reg + if( reg == REG_NON ){ + op_add_esp( PTR_SIZE ); + return; + } + //オペコード、レジスタ __op_format(0,(char)0x58,reg); @@ -532,4 +584,11 @@ // 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