void Compile_X_Group5 ( Compiler * compiler, int32 op, int32 rlFlag ) { //if ( CheckOptimizeOperands ( _Context_->Compiler0, 4 ) ) int optFlag = CheckOptimizeOperands ( compiler, 5 ) ; if ( optFlag == OPTIMIZE_DONE ) return ; else if ( optFlag ) { if ( compiler->Optimizer->OptimizeFlag & OPTIMIZE_IMM ) { _Compile_MoveImm_To_Reg ( EAX, compiler->Optimizer->Optimize_Imm, CELL ) ; compiler->Optimizer->Optimize_Mod = REG ; compiler->Optimizer->Optimize_Rm = EAX ; } _Compile_Group5 ( op, compiler->Optimizer->Optimize_Mod, compiler->Optimizer->Optimize_Rm, 0, compiler->Optimizer->Optimize_Disp, 0 ) ; _Compiler_Setup_BI_tttn ( _Context_->Compiler0, ZERO, N ) ; // ?? // not less than 0 == greater than 0 if ( compiler->Optimizer->Optimize_Rm == EAX ) { if ( GetState ( _Context_, C_SYNTAX ) ) _Stack_DropN ( _Context_->Compiler0->WordStack, 2 ) ; Word * zero = Compiler_WordStack ( compiler, 0 ) ; Word *one = ( Word* ) Compiler_WordStack ( compiler, - 1 ) ; // there is always only one arg for Group 5 instructions if ( ! ( one->CType & REGISTER_VARIABLE ) ) { _Word_CompileAndRecord_PushEAX ( zero ) ; } } } else { #if 0 if ( rlFlag == LVALUE ) { // assume lvalue on stack Compile_Move_TOS_To_EAX ( DSP ) ; _Compile_Group5 ( op, MEM, EAX, 0, 0, 0 ) ; } else { // assume rvalue on stack _Compile_Group5 ( op, MEM, DSP, 0, 0, 0 ) ; } #else Word *one = ( Word* ) Compiler_WordStack ( compiler, - 1 ) ; if ( one->CType & ( STACK_VARIABLE | LOCAL_VARIABLE | VARIABLE ) ) // *( ( cell* ) ( TOS ) ) += 1 ; { // assume lvalue on stack Compile_Move_TOS_To_EAX ( DSP ) ; _Compile_Group5 ( op, MEM, EAX, 0, 0, 0 ) ; _Compile_Stack_Drop ( DSP ) ; } else { // assume rvalue on stack _Compile_Group5 ( op, MEM, DSP, 0, 0, 0 ) ; } #endif } }
void Compile_LogicalNot ( Compiler * compiler ) { Word *one = Compiler_WordStack ( compiler, - 1 ) ; int optFlag = CheckOptimizeOperands ( compiler, 2 ) ; if ( optFlag == OPTIMIZE_DONE ) return ; else if ( optFlag ) { if ( compiler->Optimizer->OptimizeFlag & OPTIMIZE_IMM ) { _Compile_MoveImm_To_Reg ( EAX, compiler->Optimizer->Optimize_Imm, CELL ) ; } else if ( compiler->Optimizer->Optimize_Rm == DSP ) { _Compile_Move_StackN_To_Reg ( EAX, DSP, 0 ) ; } else if ( compiler->Optimizer->Optimize_Rm != EAX ) { _Compile_VarConstOrLit_RValue_To_Reg ( one, EAX ) ; } _Compile_TEST_Reg_To_Reg ( EAX, EAX ) ; _Compile_SET_tttn_REG ( ZERO, 0, EAX ) ; // SET : this only sets one byte of reg _Compile_MOVZX_REG ( EAX ) ; // so Zero eXtend reg if ( compiler->Optimizer->Optimize_Rm != DSP ) // optimize sets this { Word *zero = Compiler_WordStack ( compiler, 0 ) ; _Word_CompileAndRecord_PushEAX ( zero ) ; } else Compile_Move_EAX_To_TOS ( DSP ) ; } else { if ( one->StackPushRegisterCode ) SetHere ( one->StackPushRegisterCode ) ; else Compile_Move_TOS_To_EAX ( DSP ) ; //_Compile_Move_StackN_To_Reg ( EAX, DSP, 0 ) ; _Compile_TEST_Reg_To_Reg ( EAX, EAX ) ; //logical and eax eax => if ( eax > 0 ) 1 else 0 _Compile_SET_tttn_REG ( ZERO, 0, EAX ) ; // if (eax == zero) => zero flag is 1 if zero flag is true (1) set EAX to 1 else set eax to 0 :: SET : this only sets one byte of reg _Compile_MOVZX_REG ( EAX ) ; // so Zero eXtend reg Word *zero = Compiler_WordStack ( compiler, 0 ) ; zero->StackPushRegisterCode = Here ; Compile_Move_EAX_To_TOS ( DSP ) ; //int a, b, c= 0, d ; a = 1; b = !a, d= !c ; Printf ( "a = %d b = %d c =%d ~d = %d", a, b, c, d ) ; } }
void _Compiler_RemoveLocalFrame ( Compiler * compiler ) { int32 parameterVarsSubAmount, returnValueFlag ; Compiler_SetLocalsFrameSize_AtItsCellOffset ( compiler ) ; parameterVarsSubAmount = ( compiler->NumberOfParameterVariables * CELL ) ; if ( GetState ( _Context_, C_SYNTAX ) && ( ! String_Equal ( compiler->CurrentWord->S_ContainingNamespace->Name, "void" ) ) ) { SetState ( compiler, RETURN_TOS, true ) ; } //returnValueFlag = rvf = ( _Context_->CurrentRunWord->CProperty & C_RETURN ) || ( GetState ( compiler, RETURN_TOS | RETURN_EAX ) ) || IsWordRecursive || compiler->ReturnVariableWord ; returnValueFlag = ( _Context_->CurrentlyRunningWord->CProperty & C_RETURN ) || ( GetState ( compiler, RETURN_TOS | RETURN_EAX ) ) || IsWordRecursive || compiler->ReturnVariableWord ; Word * word = compiler->ReturnVariableWord ; #if 0 if ( GetState ( _Context_->Compiler0, SAVE_ESP ) ) { _Compile_ESP_Restore ( ) ; } #endif if ( word ) { _Compile_GetVarLitObj_RValue_To_Reg ( word, EAX, 0 ) ; // nb. these variables have no lasting lvalue - they exist on the stack - therefore we can only return there rvalue } //else if ( compiler->NumberOfParameterVariables && returnValueFlag && ( ! compiler->NumberOfRegisterVariables ) && ( ! GetState ( compiler, RETURN_EAX ) ) ) else if ( compiler->NumberOfParameterVariables && returnValueFlag && ( ! GetState ( compiler, RETURN_EAX ) ) ) { #if 0 // for some unknown reason this code will overwrite the function call address also byte add_esi_eax [ ] = { 0x01, 0x06 } ; //0106 add [esi], eax byte * here = _Q_CodeByteArray->EndIndex ; if ( memcmp ( add_esi_eax, here - 2, 2 ) ) { //_ByteArray_UnAppendSpace ( _Q_CodeByteArray, 2 ) ; SetHere ( Here - 2 ) ; _Compile_X_Group1 ( ADD, REG, MEM, EAX, DSP, 0, 0, CELL ) ; // result is on TOS } //{returnValueFlag ++ ; rvf = 0 ;} //else #else Compile_Move_TOS_To_EAX ( DSP ) ; // save TOS to EAX so we can set return it as TOS below #endif //else { parameterVarsSubAmount += CELL ; rvf = 0 ; } } else if ( GetState ( compiler, RETURN_TOS ) ) { Compile_Move_TOS_To_EAX ( DSP ) ; } _Compile_LEA ( DSP, FP, 0, - LocalVarIndex_Disp ( 1 ) ) ; // restore sp - release locals stack frame _Compile_Move_StackN_To_Reg ( FP, DSP, 1 ) ; // restore the saved pre fp - cf AddLocalsFrame // remove the incoming parameters -- like in C parameterVarsSubAmount -= returnValueFlag * CELL ; // reduce the subtract amount to make room for the return value if ( parameterVarsSubAmount > 0 ) { Compile_SUBI ( REG, DSP, 0, parameterVarsSubAmount, CELL ) ; // remove stack variables } else if ( parameterVarsSubAmount < 0 ) { Compile_ADDI ( REG, DSP, 0, - parameterVarsSubAmount, CELL ) ; // add a place on the stack for return value } //if ( rvf && returnValueFlag && ( ! GetState ( compiler, RETURN_EAX ) ) ) if ( returnValueFlag && ( ! GetState ( compiler, RETURN_EAX ) ) ) { // nb : stack was already adjusted accordingly for this above by reducing the SUBI subAmount or adding if there weren't any parameter variables Compile_Move_EAX_To_TOS ( DSP ) ; } }