From bc24b9f9e516e657fcc0034808e010287fc2e393 Mon Sep 17 00:00:00 2001 From: Piotr Dziwinski Date: Wed, 8 Aug 2012 22:35:17 +0200 Subject: Whitespace fix --- src/CBot/CBotTwoOpExpr.cpp | 932 ++++++++++++++++++++++----------------------- 1 file changed, 466 insertions(+), 466 deletions(-) (limited to 'src/CBot/CBotTwoOpExpr.cpp') diff --git a/src/CBot/CBotTwoOpExpr.cpp b/src/CBot/CBotTwoOpExpr.cpp index 49cfcc8..62290da 100644 --- a/src/CBot/CBotTwoOpExpr.cpp +++ b/src/CBot/CBotTwoOpExpr.cpp @@ -16,7 +16,7 @@ /////////////////////////////////////////////////// // expression of type Opérande1 + Opérande2 -// Opérande1 > Opérande2 +// Opérande1 > Opérande2 #include "CBot.h" @@ -24,271 +24,271 @@ CBotTwoOpExpr::CBotTwoOpExpr() { - m_leftop = - m_rightop = NULL; // NULL to be able to delete without other - name = "CBotTwoOpExpr"; // debug + m_leftop = + m_rightop = NULL; // NULL to be able to delete without other + name = "CBotTwoOpExpr"; // debug } CBotTwoOpExpr::~CBotTwoOpExpr() { - delete m_leftop; - delete m_rightop; + delete m_leftop; + delete m_rightop; } CBotLogicExpr::CBotLogicExpr() { - m_condition = - m_op1 = - m_op2 = NULL; // NULL to be able to delete without other - name = "CBotLogicExpr"; // debug + m_condition = + m_op1 = + m_op2 = NULL; // NULL to be able to delete without other + name = "CBotLogicExpr"; // debug } CBotLogicExpr::~CBotLogicExpr() { - delete m_condition; - delete m_op1; - delete m_op2; + delete m_condition; + delete m_op1; + delete m_op2; } // type of operands accepted by operations -#define ENTIER ((1<TokenStack(); // one end of stack please - - // search the intructions that may be suitable to the left of the operation - CBotInstr* left = (*pOp == 0) ? - CBotParExpr::Compile( p, pStk ) : // expression (...) left - CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A * B left - - if (left == NULL) return pStack->Return(NULL, pStk); // if error, transmit - - // did we expected the operand? - int TypeOp = p->GivType(); - if ( IsInList( TypeOp, pOperations, typemasque ) ) - { - CBotTypResult type1, type2; - type1 = pStk->GivTypResult(); // what kind of the first operand? - - if ( TypeOp == ID_LOGIC ) // special case provided for: ? op1: op2; - { - if ( !type1.Eq(CBotTypBoolean) ) - { - pStk->SetError( TX_BADTYPE, p); - return pStack->Return(NULL, pStk); - } - CBotLogicExpr* inst = new CBotLogicExpr(); - inst->m_condition = left; - - p = p->GivNext(); // skip the token of the operation - inst->m_op1 = CBotExpression::Compile(p, pStk); - CBotToken* pp = p; - if ( inst->m_op1 == NULL || !IsOfType( p, ID_DOTS ) ) - { - pStk->SetError( TX_MISDOTS, p->GivStart()); - delete inst; - return pStack->Return(NULL, pStk); - } - type1 = pStk->GivTypResult(); - - inst->m_op2 = CBotExpression::Compile(p, pStk); - if ( inst->m_op2 == NULL ) - { - pStk->SetError( TX_ENDOF, p->GivStart() ); - delete inst; - return pStack->Return(NULL, pStk); - } - type2 = pStk->GivTypResult(); - if (!TypeCompatible(type1, type2)) - { - pStk->SetError( TX_BAD2TYPE, pp ); - delete inst; - return pStack->Return(NULL, pStk); - } - - pStk->SetType(type1); // the greatest of 2 types - - return pStack->Return(inst, pStk); - } - - CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // element for operation - inst->SetToken(p); // stores the operation - - - p = p->GivNext(); // skip the token of the operation - - // looking statements that may be suitable for right - - if ( NULL != (inst->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp )) ) - // expression (...) right - { - // there is an second operand acceptable - - type2 = pStk->GivTypResult(); // what kind of results? - - // what kind of result? - int TypeRes = MAX( type1.GivType(3), type2.GivType(3) ); - if ( TypeOp == ID_ADD && type1.Eq(CBotTypString) ) - { - TypeRes = CBotTypString; - type2 = type1; // any type convertible chain - } - else if ( TypeOp == ID_ADD && type2.Eq(CBotTypString) ) - { - TypeRes = CBotTypString; - type1 = type2; // any type convertible chain - } - else if (!TypeOk( TypeRes, typemasque )) type1.SetType(99);// error of type - - switch ( TypeOp ) - { - case ID_LOG_OR: - case ID_LOG_AND: - case ID_TXT_OR: - case ID_TXT_AND: - case ID_EQ: - case ID_NE: - case ID_HI: - case ID_LO: - case ID_HS: - case ID_LS: - TypeRes = CBotTypBoolean; - } - if ( TypeCompatible (type1, type2, TypeOp ) ) // the results are compatible - { - // ok so, saves the operand in the object - inst->m_leftop = left; - - // special for evaluation of the operations of the same level from left to right - while ( IsInList( p->GivType(), pOperations, typemasque ) ) // same operation(s) follows? - { - TypeOp = p->GivType(); - CBotTwoOpExpr* i = new CBotTwoOpExpr(); // element for operation - i->SetToken(p); // stores the operation - i->m_leftop = inst; // left operand - type1 = TypeRes; - - p = p->GivNext(); // advance after - i->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp ); - type2 = pStk->GivTypResult(); - - if ( !TypeCompatible (type1, type2, TypeOp) ) // the results are compatible - { - pStk->SetError(TX_BAD2TYPE, &i->m_token); - delete i; - return pStack->Return(NULL, pStk); - } - - if ( TypeRes != CBotTypString ) - TypeRes = MAX(type1.GivType(), type2.GivType()); - inst = i; - } - - CBotTypResult t(type1); - t.SetType(TypeRes); - // is a variable on the stack for the type of result - pStk->SetVar(CBotVar::Create((CBotToken*)NULL, t)); - - // and returns the requested object - return pStack->Return(inst, pStk); - } - pStk->SetError(TX_BAD2TYPE, &inst->m_token); - } - - // in case of error, releases the elements - delete left; - delete inst; - // and transmits the error to the stack - return pStack->Return(NULL, pStk); - } - - // if we are not dealing with an operation + or - - // goes to that requested, the operand (left) found - // instead of the object "addition" - return pStack->Return(left, pStk); + int typemasque; + + if ( pOperations == NULL ) pOperations = ListOp; + int* pOp = pOperations; + while ( *pOp++ != 0 ); // follows the table + + CBotCStack* pStk = pStack->TokenStack(); // one end of stack please + + // search the intructions that may be suitable to the left of the operation + CBotInstr* left = (*pOp == 0) ? + CBotParExpr::Compile( p, pStk ) : // expression (...) left + CBotTwoOpExpr::Compile( p, pStk, pOp ); // expression A * B left + + if (left == NULL) return pStack->Return(NULL, pStk); // if error, transmit + + // did we expected the operand? + int TypeOp = p->GivType(); + if ( IsInList( TypeOp, pOperations, typemasque ) ) + { + CBotTypResult type1, type2; + type1 = pStk->GivTypResult(); // what kind of the first operand? + + if ( TypeOp == ID_LOGIC ) // special case provided for: ? op1: op2; + { + if ( !type1.Eq(CBotTypBoolean) ) + { + pStk->SetError( TX_BADTYPE, p); + return pStack->Return(NULL, pStk); + } + CBotLogicExpr* inst = new CBotLogicExpr(); + inst->m_condition = left; + + p = p->GivNext(); // skip the token of the operation + inst->m_op1 = CBotExpression::Compile(p, pStk); + CBotToken* pp = p; + if ( inst->m_op1 == NULL || !IsOfType( p, ID_DOTS ) ) + { + pStk->SetError( TX_MISDOTS, p->GivStart()); + delete inst; + return pStack->Return(NULL, pStk); + } + type1 = pStk->GivTypResult(); + + inst->m_op2 = CBotExpression::Compile(p, pStk); + if ( inst->m_op2 == NULL ) + { + pStk->SetError( TX_ENDOF, p->GivStart() ); + delete inst; + return pStack->Return(NULL, pStk); + } + type2 = pStk->GivTypResult(); + if (!TypeCompatible(type1, type2)) + { + pStk->SetError( TX_BAD2TYPE, pp ); + delete inst; + return pStack->Return(NULL, pStk); + } + + pStk->SetType(type1); // the greatest of 2 types + + return pStack->Return(inst, pStk); + } + + CBotTwoOpExpr* inst = new CBotTwoOpExpr(); // element for operation + inst->SetToken(p); // stores the operation + + + p = p->GivNext(); // skip the token of the operation + + // looking statements that may be suitable for right + + if ( NULL != (inst->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp )) ) + // expression (...) right + { + // there is an second operand acceptable + + type2 = pStk->GivTypResult(); // what kind of results? + + // what kind of result? + int TypeRes = MAX( type1.GivType(3), type2.GivType(3) ); + if ( TypeOp == ID_ADD && type1.Eq(CBotTypString) ) + { + TypeRes = CBotTypString; + type2 = type1; // any type convertible chain + } + else if ( TypeOp == ID_ADD && type2.Eq(CBotTypString) ) + { + TypeRes = CBotTypString; + type1 = type2; // any type convertible chain + } + else if (!TypeOk( TypeRes, typemasque )) type1.SetType(99);// error of type + + switch ( TypeOp ) + { + case ID_LOG_OR: + case ID_LOG_AND: + case ID_TXT_OR: + case ID_TXT_AND: + case ID_EQ: + case ID_NE: + case ID_HI: + case ID_LO: + case ID_HS: + case ID_LS: + TypeRes = CBotTypBoolean; + } + if ( TypeCompatible (type1, type2, TypeOp ) ) // the results are compatible + { + // ok so, saves the operand in the object + inst->m_leftop = left; + + // special for evaluation of the operations of the same level from left to right + while ( IsInList( p->GivType(), pOperations, typemasque ) ) // same operation(s) follows? + { + TypeOp = p->GivType(); + CBotTwoOpExpr* i = new CBotTwoOpExpr(); // element for operation + i->SetToken(p); // stores the operation + i->m_leftop = inst; // left operand + type1 = TypeRes; + + p = p->GivNext(); // advance after + i->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp ); + type2 = pStk->GivTypResult(); + + if ( !TypeCompatible (type1, type2, TypeOp) ) // the results are compatible + { + pStk->SetError(TX_BAD2TYPE, &i->m_token); + delete i; + return pStack->Return(NULL, pStk); + } + + if ( TypeRes != CBotTypString ) + TypeRes = MAX(type1.GivType(), type2.GivType()); + inst = i; + } + + CBotTypResult t(type1); + t.SetType(TypeRes); + // is a variable on the stack for the type of result + pStk->SetVar(CBotVar::Create((CBotToken*)NULL, t)); + + // and returns the requested object + return pStack->Return(inst, pStk); + } + pStk->SetError(TX_BAD2TYPE, &inst->m_token); + } + + // in case of error, releases the elements + delete left; + delete inst; + // and transmits the error to the stack + return pStack->Return(NULL, pStk); + } + + // if we are not dealing with an operation + or - + // goes to that requested, the operand (left) found + // instead of the object "addition" + return pStack->Return(left, pStk); } bool IsNan(CBotVar* left, CBotVar* right, int* err = NULL) { - if ( left ->GivInit() > IS_DEF || right->GivInit() > IS_DEF ) - { - if ( err != NULL ) *err = TX_OPNAN ; - return true; - } - return false; + if ( left ->GivInit() > IS_DEF || right->GivInit() > IS_DEF ) + { + if ( err != NULL ) *err = TX_OPNAN ; + return true; + } + return false; } @@ -296,273 +296,273 @@ bool IsNan(CBotVar* left, CBotVar* right, int* err = NULL) bool CBotTwoOpExpr::Execute(CBotStack* &pStack) { - CBotStack* pStk1 = pStack->AddStack(this); // adds an item to the stack - // or return in case of recovery -// if ( pStk1 == EOX ) return true; - - // according to recovery, it may be in one of two states - - if ( pStk1->GivState() == 0 ) // first state, evaluates the left operand - { - if (!m_leftop->Execute(pStk1) ) return false; // interrupted here? - - // for OR and AND logic does not evaluate the second expression if not necessary - if ( (GivTokenType() == ID_LOG_AND || GivTokenType() == ID_TXT_AND ) && pStk1->GivVal() == false ) - { - CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean); - res->SetValInt(false); - pStk1->SetVar(res); - return pStack->Return(pStk1); // transmits the result - } - if ( (GivTokenType() == ID_LOG_OR||GivTokenType() == ID_TXT_OR) && pStk1->GivVal() == true ) - { - CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean); - res->SetValInt(true); - pStk1->SetVar(res); - return pStack->Return(pStk1); // transmits the result - } - - // passes to the next step - pStk1->SetState(1); // ready for further - } + CBotStack* pStk1 = pStack->AddStack(this); // adds an item to the stack + // or return in case of recovery +// if ( pStk1 == EOX ) return true; + + // according to recovery, it may be in one of two states + + if ( pStk1->GivState() == 0 ) // first state, evaluates the left operand + { + if (!m_leftop->Execute(pStk1) ) return false; // interrupted here? + + // for OR and AND logic does not evaluate the second expression if not necessary + if ( (GivTokenType() == ID_LOG_AND || GivTokenType() == ID_TXT_AND ) && pStk1->GivVal() == false ) + { + CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean); + res->SetValInt(false); + pStk1->SetVar(res); + return pStack->Return(pStk1); // transmits the result + } + if ( (GivTokenType() == ID_LOG_OR||GivTokenType() == ID_TXT_OR) && pStk1->GivVal() == true ) + { + CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean); + res->SetValInt(true); + pStk1->SetVar(res); + return pStack->Return(pStk1); // transmits the result + } + + // passes to the next step + pStk1->SetState(1); // ready for further + } // requires a little more stack to avoid touching the result // of which is left on the stack, precisely - CBotStack* pStk2 = pStk1->AddStack(); // adds an item to the stack - // or return in case of recovery - - // 2e état, évalue l'opérande de droite - if ( pStk2->GivState() == 0 ) - { - if ( !m_rightop->Execute(pStk2) ) return false; // interrupted here? - pStk2->IncState(); - } - - CBotTypResult type1 = pStk1->GivTypResult(); // what kind of results? - CBotTypResult type2 = pStk2->GivTypResult(); - - CBotStack* pStk3 = pStk2->AddStack(this); // adds an item to the stack - if ( pStk3->IfStep() ) return false; // shows the operation if step by step - - // creates a temporary variable to put the result - // what kind of result? - int TypeRes = MAX(type1.GivType(), type2.GivType()); - - if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) ) - { - TypeRes = CBotTypString; - } - - switch ( GivTokenType() ) - { - case ID_LOG_OR: - case ID_LOG_AND: - case ID_TXT_OR: - case ID_TXT_AND: - case ID_EQ: - case ID_NE: - case ID_HI: - case ID_LO: - case ID_HS: - case ID_LS: - TypeRes = CBotTypBoolean; - break; - case ID_DIV: - TypeRes = MAX(TypeRes, CBotTypFloat); - } - - // creates a variable for the result - CBotVar* result = CBotVar::Create( (CBotToken*)NULL, TypeRes); - - // creates a variable to perform the calculation in the appropriate type - TypeRes = MAX(type1.GivType(), type2.GivType()); - - if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) ) - { - TypeRes = CBotTypString; - } - - CBotVar* temp; - - if ( TypeRes == CBotTypPointer ) TypeRes = CBotTypNullPointer; - if ( TypeRes == CBotTypClass ) temp = CBotVar::Create( (CBotToken*)NULL, CBotTypResult(CBotTypIntrinsic, type1.GivClass() ) ); - else temp = CBotVar::Create( (CBotToken*)NULL, TypeRes ); - - int err = 0; - // is a operation according to request - CBotVar* left = pStk1->GivVar(); - CBotVar* right = pStk2->GivVar(); - - switch (GivTokenType()) - { - case ID_ADD: - if ( !IsNan(left, right, &err) ) result->Add(left , right); // addition - break; - case ID_SUB: - if ( !IsNan(left, right, &err) ) result->Sub(left , right); // substraction - break; - case ID_MUL: - if ( !IsNan(left, right, &err) ) result->Mul(left , right); // multiplies - break; - case ID_POWER: - if ( !IsNan(left, right, &err) ) result->Power(left , right); // power - break; - case ID_DIV: - if ( !IsNan(left, right, &err) ) err = result->Div(left , right);// division - break; - case ID_MODULO: - if ( !IsNan(left, right, &err) ) err = result->Modulo(left , right);// remainder of division - break; - case ID_LO: - if ( !IsNan(left, right, &err) ) - result->SetValInt(temp->Lo(left , right)); // lower - break; - case ID_HI: - if ( !IsNan(left, right, &err) ) - result->SetValInt(temp->Hi(left , right)); // top - break; - case ID_LS: - if ( !IsNan(left, right, &err) ) - result->SetValInt(temp->Ls(left , right)); // less than or equal - break; - case ID_HS: - if ( !IsNan(left, right, &err) ) - result->SetValInt(temp->Hs(left , right)); // greater than or equal - break; - case ID_EQ: - if ( IsNan(left, right) ) - result->SetValInt(left->GivInit() == right->GivInit()) ; - else - result->SetValInt(temp->Eq(left , right)); // equal - break; - case ID_NE: - if ( IsNan(left, right) ) - result->SetValInt(left ->GivInit() != right->GivInit()) ; - else - result->SetValInt(temp->Ne(left , right)); // different - break; - case ID_TXT_AND: - case ID_LOG_AND: - case ID_AND: - if ( !IsNan(left, right, &err) ) result->And(left , right); // AND - break; - case ID_TXT_OR: - case ID_LOG_OR: - case ID_OR: - if ( !IsNan(left, right, &err) ) result->Or(left , right); // OR - break; - case ID_XOR: - if ( !IsNan(left, right, &err) ) result->XOr(left , right); // exclusive OR - break; - case ID_ASR: - if ( !IsNan(left, right, &err) ) result->ASR(left , right); - break; - case ID_SR: - if ( !IsNan(left, right, &err) ) result->SR(left , right); - break; - case ID_SL: - if ( !IsNan(left, right, &err) ) result->SL(left , right); - break; - default: - ASM_TRAP(); - } - delete temp; - - pStk2->SetVar(result); // puts the result on the stack - if ( err ) pStk2->SetError(err, &m_token); // and the possible error (division by zero) - -// pStk1->Return(pStk2); // releases the stack - return pStack->Return(pStk2); // transmits the result + CBotStack* pStk2 = pStk1->AddStack(); // adds an item to the stack + // or return in case of recovery + + // 2e état, évalue l'opérande de droite + if ( pStk2->GivState() == 0 ) + { + if ( !m_rightop->Execute(pStk2) ) return false; // interrupted here? + pStk2->IncState(); + } + + CBotTypResult type1 = pStk1->GivTypResult(); // what kind of results? + CBotTypResult type2 = pStk2->GivTypResult(); + + CBotStack* pStk3 = pStk2->AddStack(this); // adds an item to the stack + if ( pStk3->IfStep() ) return false; // shows the operation if step by step + + // creates a temporary variable to put the result + // what kind of result? + int TypeRes = MAX(type1.GivType(), type2.GivType()); + + if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) ) + { + TypeRes = CBotTypString; + } + + switch ( GivTokenType() ) + { + case ID_LOG_OR: + case ID_LOG_AND: + case ID_TXT_OR: + case ID_TXT_AND: + case ID_EQ: + case ID_NE: + case ID_HI: + case ID_LO: + case ID_HS: + case ID_LS: + TypeRes = CBotTypBoolean; + break; + case ID_DIV: + TypeRes = MAX(TypeRes, CBotTypFloat); + } + + // creates a variable for the result + CBotVar* result = CBotVar::Create( (CBotToken*)NULL, TypeRes); + + // creates a variable to perform the calculation in the appropriate type + TypeRes = MAX(type1.GivType(), type2.GivType()); + + if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) ) + { + TypeRes = CBotTypString; + } + + CBotVar* temp; + + if ( TypeRes == CBotTypPointer ) TypeRes = CBotTypNullPointer; + if ( TypeRes == CBotTypClass ) temp = CBotVar::Create( (CBotToken*)NULL, CBotTypResult(CBotTypIntrinsic, type1.GivClass() ) ); + else temp = CBotVar::Create( (CBotToken*)NULL, TypeRes ); + + int err = 0; + // is a operation according to request + CBotVar* left = pStk1->GivVar(); + CBotVar* right = pStk2->GivVar(); + + switch (GivTokenType()) + { + case ID_ADD: + if ( !IsNan(left, right, &err) ) result->Add(left , right); // addition + break; + case ID_SUB: + if ( !IsNan(left, right, &err) ) result->Sub(left , right); // substraction + break; + case ID_MUL: + if ( !IsNan(left, right, &err) ) result->Mul(left , right); // multiplies + break; + case ID_POWER: + if ( !IsNan(left, right, &err) ) result->Power(left , right); // power + break; + case ID_DIV: + if ( !IsNan(left, right, &err) ) err = result->Div(left , right);// division + break; + case ID_MODULO: + if ( !IsNan(left, right, &err) ) err = result->Modulo(left , right);// remainder of division + break; + case ID_LO: + if ( !IsNan(left, right, &err) ) + result->SetValInt(temp->Lo(left , right)); // lower + break; + case ID_HI: + if ( !IsNan(left, right, &err) ) + result->SetValInt(temp->Hi(left , right)); // top + break; + case ID_LS: + if ( !IsNan(left, right, &err) ) + result->SetValInt(temp->Ls(left , right)); // less than or equal + break; + case ID_HS: + if ( !IsNan(left, right, &err) ) + result->SetValInt(temp->Hs(left , right)); // greater than or equal + break; + case ID_EQ: + if ( IsNan(left, right) ) + result->SetValInt(left->GivInit() == right->GivInit()) ; + else + result->SetValInt(temp->Eq(left , right)); // equal + break; + case ID_NE: + if ( IsNan(left, right) ) + result->SetValInt(left ->GivInit() != right->GivInit()) ; + else + result->SetValInt(temp->Ne(left , right)); // different + break; + case ID_TXT_AND: + case ID_LOG_AND: + case ID_AND: + if ( !IsNan(left, right, &err) ) result->And(left , right); // AND + break; + case ID_TXT_OR: + case ID_LOG_OR: + case ID_OR: + if ( !IsNan(left, right, &err) ) result->Or(left , right); // OR + break; + case ID_XOR: + if ( !IsNan(left, right, &err) ) result->XOr(left , right); // exclusive OR + break; + case ID_ASR: + if ( !IsNan(left, right, &err) ) result->ASR(left , right); + break; + case ID_SR: + if ( !IsNan(left, right, &err) ) result->SR(left , right); + break; + case ID_SL: + if ( !IsNan(left, right, &err) ) result->SL(left , right); + break; + default: + ASM_TRAP(); + } + delete temp; + + pStk2->SetVar(result); // puts the result on the stack + if ( err ) pStk2->SetError(err, &m_token); // and the possible error (division by zero) + +// pStk1->Return(pStk2); // releases the stack + return pStack->Return(pStk2); // transmits the result } void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, bool bMain) { - if ( !bMain ) return; - CBotStack* pStk1 = pStack->RestoreStack(this); // adds an item to the stack - if ( pStk1 == NULL ) return; - - // according to recovery, it may be in one of two states - - if ( pStk1->GivState() == 0 ) // first state, evaluates the left operand - { - m_leftop->RestoreState(pStk1, bMain); // interrupted here! - return; - } - - CBotStack* pStk2 = pStk1->RestoreStack(); // adds an item to the stack - if ( pStk2 == NULL ) return; - - // second state, evaluates the right operand - if ( pStk2->GivState() == 0 ) - { - m_rightop->RestoreState(pStk2, bMain); // interrupted here! - return; - } + if ( !bMain ) return; + CBotStack* pStk1 = pStack->RestoreStack(this); // adds an item to the stack + if ( pStk1 == NULL ) return; + + // according to recovery, it may be in one of two states + + if ( pStk1->GivState() == 0 ) // first state, evaluates the left operand + { + m_leftop->RestoreState(pStk1, bMain); // interrupted here! + return; + } + + CBotStack* pStk2 = pStk1->RestoreStack(); // adds an item to the stack + if ( pStk2 == NULL ) return; + + // second state, evaluates the right operand + if ( pStk2->GivState() == 0 ) + { + m_rightop->RestoreState(pStk2, bMain); // interrupted here! + return; + } } bool CBotLogicExpr::Execute(CBotStack* &pStack) { - CBotStack* pStk1 = pStack->AddStack(this); // adds an item to the stack - // or return in case of recovery -// if ( pStk1 == EOX ) return true; - - if ( pStk1->GivState() == 0 ) - { - if ( !m_condition->Execute(pStk1) ) return false; - if (!pStk1->SetState(1)) return false; - } - - if ( pStk1->GivVal() == true ) - { - if ( !m_op1->Execute(pStk1) ) return false; - } - else - { - if ( !m_op2->Execute(pStk1) ) return false; - } - - return pStack->Return(pStk1); // transmits the result + CBotStack* pStk1 = pStack->AddStack(this); // adds an item to the stack + // or return in case of recovery +// if ( pStk1 == EOX ) return true; + + if ( pStk1->GivState() == 0 ) + { + if ( !m_condition->Execute(pStk1) ) return false; + if (!pStk1->SetState(1)) return false; + } + + if ( pStk1->GivVal() == true ) + { + if ( !m_op1->Execute(pStk1) ) return false; + } + else + { + if ( !m_op2->Execute(pStk1) ) return false; + } + + return pStack->Return(pStk1); // transmits the result } void CBotLogicExpr::RestoreState(CBotStack* &pStack, bool bMain) { - if ( !bMain ) return; - - CBotStack* pStk1 = pStack->RestoreStack(this); // adds an item to the stack - if ( pStk1 == NULL ) return; - - if ( pStk1->GivState() == 0 ) - { - m_condition->RestoreState(pStk1, bMain); - return; - } - - if ( pStk1->GivVal() == true ) - { - m_op1->RestoreState(pStk1, bMain); - } - else - { - m_op2->RestoreState(pStk1, bMain); - } + if ( !bMain ) return; + + CBotStack* pStk1 = pStack->RestoreStack(this); // adds an item to the stack + if ( pStk1 == NULL ) return; + + if ( pStk1->GivState() == 0 ) + { + m_condition->RestoreState(pStk1, bMain); + return; + } + + if ( pStk1->GivVal() == true ) + { + m_op1->RestoreState(pStk1, bMain); + } + else + { + m_op2->RestoreState(pStk1, bMain); + } } #if 0 void t() { - int x,y; - 1>0 ? x = 0 : y = 0; + int x,y; + 1>0 ? x = 0 : y = 0; } #endif #if 01 void t(bool t) { - int x; - x = 1 + t ? 1 : 3 + 4 * 2 ; - t ? 0 : "test"; + int x; + x = 1 + t ? 1 : 3 + 4 * 2 ; + t ? 0 : "test"; } #endif -- cgit v1.2.3-1-g7c22