colobot/src/CBot/CBotWhile.cpp

1128 lines
36 KiB
C++

/*
* This file is part of the Colobot: Gold Edition source code
* Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam
* http://epsitec.ch; http://colobot.info; http://github.com/colobot
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see http://gnu.org/licenses
*/
///////////////////////////////////////////////////////////////////////
// This file defined the following statements:
// CBotWhile "while (condition) {instructions}"
// CBotDo "do {instructions} while (condition)"
// CBotFor "for (init, condition, incr) {instructions}"
// CBotSwitch "switch (val) {instructions}"
// CBotCase "case val:"
// CBotBreak "break", "break label", "continu", "continu label"
// CBotTry "try {instructions}"
// CBotCatch "catch (condition) {instructions}" or "finally"
// CBotThrow "throw execption"
#include "CBot.h"
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// compile an instruction "while"
CBotWhile::CBotWhile()
{
m_Condition =
m_Block = nullptr; // nullptr so that delete is not possible further
name = "CBotWhile"; // debug
}
CBotWhile::~CBotWhile()
{
delete m_Condition; // frees the condition
delete m_Block; // releases the block instruction
}
CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack)
{
CBotWhile* inst = new CBotWhile(); // creates the object
CBotToken* pp = p; // preserves at the ^ token (starting position)
if ( IsOfType( p, TokenTypVar ) &&
IsOfType( p, ID_DOTS ) )
{
inst->m_label = pp->GetString(); // records the name of the label
}
inst->SetToken(p);
if (!IsOfType(p, ID_WHILE)) return nullptr; // should never happen
CBotCStack* pStk = pStack->TokenStack(pp); // un petit bout de pile svp
// a bit of battery please (??)
if ( nullptr != (inst->m_Condition = CBotCondition::Compile( p, pStk )) )
{
// the condition exists
IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
DecLvl();
if ( pStk->IsOk() )
{
// the statement block is ok (it may be empty!
return pStack->Return(inst, pStk); // return an object to the application
// makes the object to which the application
}
}
delete inst; // error, frees the place
return pStack->Return(nullptr, pStk); // no object, the error is on the stack
}
// executes a "while" instruction
bool CBotWhile :: Execute(CBotStack* &pj)
{
CBotStack* pile = pj->AddStack(this); // adds an item to the stack
// or find in case of recovery
// if ( pile == EOX ) return true;
if ( pile->IfStep() ) return false;
while( true ) switch( pile->GetState() ) // executes the loop
{ // there are two possible states (depending on recovery)
case 0:
// evaluates the condition
if ( !m_Condition->Execute(pile) ) return false; // interrupted here?
// the result of the condition is on the stack
// terminates if an error or if the condition is false
if ( !pile->IsOk() || pile->GetVal() != true )
{
return pj->Return(pile); // sends the results and releases the stack
}
// the condition is true, pass in the second mode
if (!pile->SetState(1)) return false; // ready for further
case 1:
// evaluates the associated statement block
if ( m_Block != nullptr &&
!m_Block->Execute(pile) )
{
if (pile->IfContinue(0, m_label)) continue; // if continued, will return to test
return pj->BreakReturn(pile, m_label); // sends the results and releases the stack
}
// terminates if there is an error
if ( !pile->IsOk() )
{
return pj->Return(pile); // sends the results and releases the stack
}
// returns to the test again
if (!pile->SetState(0, 0)) return false;
continue;
}
}
void CBotWhile :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
CBotStack* pile = pj->RestoreStack(this); // adds an item to the stack
if ( pile == nullptr ) return;
switch( pile->GetState() )
{ // there are two possible states (depending on recovery)
case 0:
// evaluates the condition
m_Condition->RestoreState(pile, bMain);
return;
case 1:
// evaluates the associated statement block
if ( m_Block != nullptr ) m_Block->RestoreState(pile, bMain);
return;
}
}
///////////////////////////////////////////////////////////////////////////
// compiles instruction "for"
CBotFor::CBotFor()
{
m_Init =
m_Test =
m_Incr =
m_Block = nullptr; // nullptr so that delete is not possible further
name = "CBotFor"; // debug
}
CBotFor::~CBotFor()
{
delete m_Init;
delete m_Test;
delete m_Incr;
delete m_Block; // frees the instruction block
}
CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
{
CBotFor* inst = new CBotFor(); // creates the object
CBotToken* pp = p; // preserves at the ^ token (starting position)
if ( IsOfType( p, TokenTypVar ) &&
IsOfType( p, ID_DOTS ) )
{
inst->m_label = pp->GetString(); // register the name of label
}
inst->SetToken(p);
if (!IsOfType(p, ID_FOR)) return nullptr; // should never happen
if ( !IsOfType(p, ID_OPENPAR)) // missing parenthesis ?
{
pStack->SetError(TX_OPENPAR, p->GetStart());
return nullptr;
}
CBotCStack* pStk = pStack->TokenStack(pp, true); // un petit bout de pile svp
// compiles instructions for initialization
inst->m_Init = CBotListExpression::Compile( p, pStk );
if ( pStk->IsOk() )
{
if ( !IsOfType(p, ID_SEP)) // lack the semicolon?
{
pStack->SetError(TX_OPENPAR, p->GetStart());
delete inst;
return pStack->Return(nullptr, pStk); // no object, the error is on the stack
}
inst->m_Test = CBotBoolExpr::Compile( p, pStk );
if ( pStk->IsOk() )
{
if ( !IsOfType(p, ID_SEP)) // lack the semicolon?
{
pStack->SetError(TX_OPENPAR, p->GetStart());
delete inst;
return pStack->Return(nullptr, pStk); // no object, the error is on the stack
}
inst->m_Incr = CBotListExpression::Compile( p, pStk );
if ( pStk->IsOk() )
{
if ( IsOfType(p, ID_CLOSEPAR)) // missing parenthesis ?
{
IncLvl(inst->m_label);
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk, true );
DecLvl();
if ( pStk->IsOk() )
return pStack->Return(inst, pStk);;
}
pStack->SetError(TX_CLOSEPAR, p->GetStart());
}
}
}
delete inst; // error, frees up
return pStack->Return(nullptr, pStk); // no object, the error is on the stack
}
// execution of instruction "for"
bool CBotFor :: Execute(CBotStack* &pj)
{
CBotStack* pile = pj->AddStack(this, true); // adds an item to the stack (variables locales)
// or find in case of recovery
// if ( pile == EOX ) return true;
if ( pile->IfStep() ) return false;
while( true ) switch( pile->GetState() ) // executes the loop
{ // there are four possible states (depending on recovery)
case 0:
// initialize
if ( m_Init != nullptr &&
!m_Init->Execute(pile) ) return false; // interrupted here ?
if (!pile->SetState(1)) return false; // ready for further
case 1:
// evaluates the condition
if ( m_Test != nullptr ) // no strings attached? -> True!
{
if (!m_Test->Execute(pile) ) return false; // interrupted here ?
// the result of the condition is on the stack
// terminates if an error or if the condition is false
if ( !pile->IsOk() || pile->GetVal() != true )
{
return pj->Return(pile); // sends the results and releases the stack
}
}
// la condition est vrai, passe à la suite
if (!pile->SetState(2)) return false; // ready for further
case 2:
// evaluates the associated statement block
if ( m_Block != nullptr &&
!m_Block->Execute(pile) )
{
if (pile->IfContinue(3, m_label)) continue; // if continued, going on to incrementation
return pj->BreakReturn(pile, m_label); // sends the results and releases the stack
}
// terminates if there is an error
if ( !pile->IsOk() )
{
return pj->Return(pile); // sends the results and releases the stack
}
if (!pile->SetState(3)) return false; // ready for further
case 3:
// evalutate the incrementation
if ( m_Incr != nullptr &&
!m_Incr->Execute(pile) ) return false; // interrupted here ?
// returns to the test again
if (!pile->SetState(1, 0)) return false; // returns to the test
continue;
}
}
void CBotFor :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
CBotStack* pile = pj->RestoreStack(this); // adds an item to the stack (variables locales)
if ( pile == nullptr ) return;
switch( pile->GetState() )
{ // there are four possible states (depending on recovery)
case 0:
// initialize
if ( m_Init != nullptr ) m_Init->RestoreState(pile, true); // interrupted here !
return;
case 1:
if ( m_Init != nullptr ) m_Init->RestoreState(pile, false); // variables definitions
// evaluates the condition
if ( m_Test != nullptr ) m_Test->RestoreState(pile, true); // interrupted here !
return;
case 2:
if ( m_Init != nullptr ) m_Init->RestoreState(pile, false); // variable definitions
// evaluates the associated statement block
if ( m_Block != nullptr ) m_Block->RestoreState(pile, true);
return;
case 3:
if ( m_Init != nullptr ) m_Init->RestoreState(pile, false); // variable definitions
// evaluate the incrementation
if ( m_Incr != nullptr ) m_Incr->RestoreState(pile, true); // interrupted here !
return;
}
}
//////////////////////////////////////////////////////////////////////////////////////
// compiles a list of expressions
// is used only in "for" statement
// in incrementing and intitialisation
CBotListExpression::CBotListExpression()
{
m_Expr = nullptr;
name = "CBotListExpression";
}
CBotListExpression::~CBotListExpression()
{
delete m_Expr;
}
// seeks a declaration of variable or expression
static CBotInstr* CompileInstrOrDefVar(CBotToken* &p, CBotCStack* pStack)
{
CBotInstr* i = CBotInt::Compile( p, pStack, false, true ); // Is this a declaration of an integer?
if ( i== nullptr ) i = CBotFloat::Compile( p, pStack, false, true ); // or a real number?
if ( i== nullptr ) i = CBotBoolean::Compile( p, pStack, false, true ); // or a boolean?
if ( i== nullptr ) i = CBotIString::Compile( p, pStack, false, true ); // ar a string?
if ( i== nullptr ) i = CBotExpression::Compile( p, pStack ); // compiles an expression
return i;
}
CBotInstr* CBotListExpression::Compile(CBotToken* &p, CBotCStack* pStack)
{
CBotListExpression* inst = new CBotListExpression();
inst->m_Expr = CompileInstrOrDefVar( p, pStack ); // compile the first expression in a list
if (pStack->IsOk())
{
while ( IsOfType(p, ID_COMMA) ) // more instructions?
{
CBotInstr* i = CompileInstrOrDefVar( p, pStack ); // Is this a declaration of an integer?
inst->m_Expr->AddNext(i); // added after
if ( !pStack->IsOk() )
{
delete inst;
return nullptr; // no object, the error is on the stack
}
}
return inst;
}
delete inst;
return nullptr;
}
bool CBotListExpression::Execute(CBotStack* &pj)
{
CBotStack* pile = pj->AddStack(); // essential
CBotInstr* p = m_Expr; // the first expression
int state = pile->GetState();
while (state-->0) p = p->GetNext(); // returns to the interrupted operation
if ( p != nullptr ) while (true)
{
if ( !p->Execute(pile) ) return false;
p = p->GetNext();
if ( p == nullptr ) break;
if (!pile->IncState()) return false; // ready for next
}
return pj->Return(pile);
}
void CBotListExpression::RestoreState(CBotStack* &pj, bool bMain)
{
CBotStack* pile = pj;
int state = 0x7000;
if ( bMain )
{
pile = pj->RestoreStack();
if ( pile == nullptr ) return;
state = pile->GetState();
}
CBotInstr* p = m_Expr; // the first expression
while (p != nullptr && state-->0)
{
p->RestoreState(pile, false);
p = p->GetNext(); // returns to the interrupted operation
}
if ( p != nullptr )
{
p->RestoreState(pile, bMain);
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// compiles instruction "switch"
CBotSwitch::CBotSwitch()
{
m_Value =
m_Block = nullptr; // nullptr so that delete is not possible further
name = "CBotSwitch"; // debug
}
CBotSwitch::~CBotSwitch()
{
delete m_Value; // frees the value
delete m_Block; // frees the instruction block
}
CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)
{
CBotSwitch* inst = new CBotSwitch(); // creates the object
CBotToken* pp = p; // preserves at the ^ token (starting position)
inst->SetToken(p);
if (!IsOfType(p, ID_SWITCH)) return nullptr; // should never happen
CBotCStack* pStk = pStack->TokenStack(pp); // un petit bout de pile svp
if ( IsOfType(p, ID_OPENPAR ) )
{
if ( nullptr != (inst->m_Value = CBotExpression::Compile( p, pStk )) )
{
if ( pStk->GetType() < CBotTypLong )
{
if ( IsOfType(p, ID_CLOSEPAR ) )
{
if ( IsOfType(p, ID_OPBLK ) )
{
IncLvl();
while( !IsOfType( p, ID_CLBLK ) )
{
if ( p->GetType() == ID_CASE || p->GetType() == ID_DEFAULT)
{
CBotCStack* pStk2 = pStk->TokenStack(p); // un petit bout de pile svp
CBotInstr* i = CBotCase::Compile( p, pStk2 );
if (i == nullptr)
{
delete inst;
return pStack->Return(nullptr, pStk2);
}
delete pStk2;
if ( inst->m_Block == nullptr ) inst->m_Block = i;
else inst->m_Block->AddNext(i);
continue;
}
if ( inst->m_Block == nullptr )
{
pStk->SetError(TX_NOCASE, p->GetStart());
delete inst;
return pStack->Return(nullptr, pStk);
}
CBotInstr* i = CBotBlock::CompileBlkOrInst( p, pStk, true );
if ( !pStk->IsOk() )
{
delete inst;
return pStack->Return(nullptr, pStk);
}
inst->m_Block->AddNext(i);
if ( p == nullptr )
{
pStk->SetError(TX_CLOSEBLK, -1);
delete inst;
return pStack->Return(nullptr, pStk);
}
}
DecLvl();
if ( inst->m_Block == nullptr )
{
pStk->SetError(TX_NOCASE, p->GetStart());
delete inst;
return pStack->Return(nullptr, pStk);
}
// the statement block is ok
return pStack->Return(inst, pStk); // return an object to the application
}
pStk->SetError( TX_OPENBLK, p->GetStart() );
}
pStk->SetError( TX_CLOSEPAR, p->GetStart() );
}
pStk->SetError( TX_BADTYPE, p->GetStart() );
}
}
pStk->SetError( TX_OPENPAR, p->GetStart());
delete inst; // error, frees up
return pStack->Return(nullptr, pStk); // no object, the error is on the stack
}
// executes instruction "switch"
bool CBotSwitch :: Execute(CBotStack* &pj)
{
CBotStack* pile1 = pj->AddStack(this); // adds an item to the stack
// if ( pile1 == EOX ) return true;
CBotInstr* p = m_Block; // first expression
int state = pile1->GetState();
if (state == 0)
{
if ( !m_Value->Execute(pile1) ) return false;
pile1->SetState(state = -1);
}
if ( pile1->IfStep() ) return false;
if ( state == -1 )
{
state = 0;
int val = pile1->GetVal(); // result of the value
CBotStack* pile2 = pile1->AddStack();
while ( p != nullptr ) // search for the corresponding case in a list
{
state++;
if ( p->CompCase( pile2, val ) ) break; // found the case
p = p->GetNext();
}
pile2->Delete();
if ( p == nullptr ) return pj->Return(pile1); // completed if nothing
if ( !pile1->SetState(state) ) return false;
}
p = m_Block; // returns to the beginning
while (state-->0) p = p->GetNext(); // advance in the list
while( p != nullptr )
{
if ( !p->Execute(pile1) ) return pj->BreakReturn(pile1);
if ( !pile1->IncState() ) return false;
p = p->GetNext();
}
return pj->Return(pile1);
}
void CBotSwitch :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
CBotStack* pile1 = pj->RestoreStack(this); // adds an item to the stack
if ( pile1 == nullptr ) return;
CBotInstr* p = m_Block; // first expression
int state = pile1->GetState();
if (state == 0)
{
m_Value->RestoreState(pile1, bMain);
return;
}
if ( state == -1 )
{
return;
}
// p = m_Block; // returns to the beginning
while ( p != nullptr && state-- > 0 )
{
p->RestoreState(pile1, false);
p = p->GetNext(); // advance in the list
}
if( p != nullptr )
{
p->RestoreState(pile1, true);
return;
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// compiles instruction "case"
// we are bound to the statement block "switch"
CBotCase::CBotCase()
{
m_Value = nullptr; // nullptr so that delete is not possible further
name = "CBotCase"; // debug
}
CBotCase::~CBotCase()
{
delete m_Value; // frees the value
}
CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack)
{
CBotCase* inst = new CBotCase(); // creates the object
CBotToken* pp = p; // preserves at the ^ token (starting position)
inst->SetToken(p);
if (!IsOfType(p, ID_CASE, ID_DEFAULT)) return nullptr; // should never happen
if ( pp->GetType() == ID_CASE )
{
pp = p;
inst->m_Value = CBotExprNum::Compile(p, pStack);
if ( inst->m_Value == nullptr )
{
pStack->SetError( TX_BADNUM, pp );
delete inst;
return nullptr;
}
}
if ( !IsOfType( p, ID_DOTS ))
{
pStack->SetError( TX_MISDOTS, p->GetStart() );
delete inst;
return nullptr;
}
return inst;
}
// execution of instruction "case"
bool CBotCase::Execute(CBotStack* &pj)
{
return true; // the "case" statement does nothing!
}
void CBotCase::RestoreState(CBotStack* &pj, bool bMain)
{
}
// routine to find the entry point of "case"
// corresponding to the value seen
bool CBotCase::CompCase(CBotStack* &pile, int val)
{
if ( m_Value == nullptr ) return true; // "default" case
while (!m_Value->Execute(pile)); // puts the value on the correspondent stack (without interruption)
return (pile->GetVal() == val); // compared with the given value
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// compiles instruction "break" or "continu"
CBotBreak::CBotBreak()
{
name = "CBotBreak"; // debug
}
CBotBreak::~CBotBreak()
{
}
CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack)
{
CBotToken* pp = p; // preserves at the ^ token (starting position)
int type = p->GetType();
if (!IsOfType(p, ID_BREAK, ID_CONTINUE)) return nullptr; // should never happen
if ( !ChkLvl(CBotString(), type ) )
{
pStack->SetError(TX_BREAK, pp);
return nullptr; // no object, the error is on the stack
}
CBotBreak* inst = new CBotBreak(); // creates the object
inst->SetToken(pp); // keeps the operation
pp = p;
if ( IsOfType( p, TokenTypVar ) )
{
inst->m_label = pp->GetString(); // register the name of label
if ( !ChkLvl(inst->m_label, type ) )
{
delete inst;
pStack->SetError(TX_NOLABEL, pp);
return nullptr; // no object, the error is on the stack
}
}
if (IsOfType(p, ID_SEP))
{
return inst; // return what it wants
}
delete inst;
pStack->SetError(TX_ENDOF, p->GetStart());
return nullptr; // no object, the error is on the stack
}
// execution of statement "break" or "continu"
bool CBotBreak :: Execute(CBotStack* &pj)
{
CBotStack* pile = pj->AddStack(this);
// if ( pile == EOX ) return true;
if ( pile->IfStep() ) return false;
pile->SetBreak(m_token.GetType()==ID_BREAK ? 1 : 2, m_label);
return pj->Return(pile);
}
void CBotBreak :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( bMain ) pj->RestoreStack(this);
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// compiles instruction "try"
CBotTry::CBotTry()
{
m_ListCatch = nullptr;
m_FinalInst =
m_Block = nullptr; // nullptr so that delete is not possible further
name = "CBotTry"; // debug
}
CBotTry::~CBotTry()
{
delete m_ListCatch; // frees the list
delete m_Block; // frees the instruction block
delete m_FinalInst;
}
CBotInstr* CBotTry::Compile(CBotToken* &p, CBotCStack* pStack)
{
CBotTry* inst = new CBotTry(); // creates the object
CBotToken* pp = p; // preserves at the ^ token (starting position)
inst->SetToken(p);
if (!IsOfType(p, ID_TRY)) return nullptr; // should never happen
CBotCStack* pStk = pStack->TokenStack(pp); // un petit bout de pile svp
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk );
CBotCatch** pn = &inst->m_ListCatch;
while (pStk->IsOk() && p->GetType() == ID_CATCH)
{
CBotCatch* i = CBotCatch::Compile(p, pStk);
*pn = i;
pn = &i->m_next;
}
if (pStk->IsOk() && IsOfType( p, ID_FINALLY) )
{
inst->m_FinalInst = CBotBlock::CompileBlkOrInst( p, pStk );
}
if (pStk->IsOk())
{
return pStack->Return(inst, pStk); // return an object to the application
}
delete inst; // error, frees up
return pStack->Return(nullptr, pStk); // no object, the error is on the stack
}
// execution of instruction Try
// manages the return of exceptions
// stops (judgements) by suspension
// and "finally"
bool CBotTry :: Execute(CBotStack* &pj)
{
int val;
CBotStack* pile1 = pj->AddStack(this); // adds an item to the stack
// if ( pile1 == EOX ) return true;
if ( pile1->IfStep() ) return false;
// or find in case of recovery
CBotStack* pile0 = pj->AddStack2(); // adds an element to the secondary stack
CBotStack* pile2 = pile0->AddStack();
if ( pile1->GetState() == 0 )
{
if ( m_Block->Execute(pile1) )
{
if ( m_FinalInst == nullptr ) return pj->Return(pile1);
pile1->SetState(-2); // passes final
}
val = pile1->GetError();
if ( val == 0 && CBotStack::m_initimer == 0 ) // mode step?
return false; // does not make the catch
pile1->IncState();
pile2->SetState(val); // stores the error number
pile1->SetError(0); // for now there is are more errors!
if ( val == 0 && CBotStack::m_initimer < 0 ) // mode step?
return false; // does not make the catch
}
// there was an interruption
// see what it returns
CBotCatch* pc = m_ListCatch;
int state = static_cast<short>(pile1->GetState()); // where were we?
val = pile2->GetState(); // what error?
pile0->SetState(1); // marking the GetRunPos
if ( val >= 0 && state > 0 ) while ( pc != nullptr )
{
if ( --state <= 0 )
{
// request to the catch block if they feel concerned
// demande au bloc catch s'il se sent concerné
if ( !pc->TestCatch(pile2, val) ) return false; // suspend !
pile1->IncState();
}
if ( --state <= 0 )
{
if ( pile2->GetVal() == true )
{
// pile0->SetState(1);
if ( !pc->Execute(pile2) ) return false; // performs the operation
if ( m_FinalInst == nullptr )
return pj->Return(pile2); // ends the try
pile1->SetState(-2); // passes final
break;
}
pile1->IncState();
}
pc = pc->m_next;
}
if ( m_FinalInst != nullptr &&
pile1->GetState() > 0 && val != 0 ) pile1->SetState(-1);// if stop then made the final
if (pile1->GetState() <= -1)
{
// pile0->SetState(1);
if (!m_FinalInst->Execute(pile2) && pile2->IsOk()) return false;
if (!pile2->IsOk()) return pj->Return(pile2); // keep this exception
pile2->SetError(pile1->GetState()==-1 ? val : 0); // gives the initial error
return pj->Return(pile2);
}
pile1->SetState(0); // returns to the evaluation
pile0->SetState(0); // returns to the evaluation
if ( val != 0 && m_ListCatch == nullptr && m_FinalInst == nullptr )
return pj->Return(pile2); // ends the try without exception
pile1->SetError(val); // gives the error
return false; // it's not for us
}
void CBotTry :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
int val;
CBotStack* pile1 = pj->RestoreStack(this); // adds an item to the stack
if ( pile1 == nullptr ) return;
// or find in case of recovery
CBotStack* pile0 = pj->AddStack2(); // adds an item to the secondary stack
if ( pile0 == nullptr ) return;
CBotStack* pile2 = pile0->RestoreStack();
if ( pile2 == nullptr ) return;
m_Block->RestoreState(pile1, bMain);
if ( pile0->GetState() == 0 )
{
return;
}
// there was an interruption
// see what it returns
CBotCatch* pc = m_ListCatch;
int state = pile1->GetState(); // where were we ?
val = pile2->GetState(); // what error ?
if ( val >= 0 && state > 0 ) while ( pc != nullptr )
{
if ( --state <= 0 )
{
// request to the catch block if they feel concerned
// demande au bloc catch s'il se sent concerné
pc->RestoreCondState(pile2, bMain); // suspend !
return;
}
if ( --state <= 0 )
{
if ( pile2->GetVal() == true )
{
pc->RestoreState(pile2, bMain); // execute the operation
return;
}
}
pc = pc->m_next;
}
if (pile1->GetState() <= -1)
{
m_FinalInst->RestoreState(pile2, bMain);
return;
}
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// compiles instruction "catch"
CBotCatch::CBotCatch()
{
m_Cond =
m_Block = nullptr; // nullptr so that delete is not possible further
m_next = nullptr;
name = "CBotCatch"; // debug
}
CBotCatch::~CBotCatch()
{
delete m_Cond; // frees the list
delete m_Block; // frees the instruction block
delete m_next; // and subsequent
}
CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack)
{
CBotCatch* inst = new CBotCatch(); // creates the object
pStack->SetStartError(p->GetStart());
inst->SetToken(p);
if (!IsOfType(p, ID_CATCH)) return nullptr; // should never happen
if (IsOfType(p, ID_OPENPAR))
{
inst->m_Cond = CBotExpression::Compile(p, pStack);
if (( pStack->GetType() < CBotTypLong ||
pStack->GetTypResult().Eq(CBotTypBoolean) )&& pStack->IsOk() )
{
if (IsOfType(p, ID_CLOSEPAR))
{
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStack );
if ( pStack->IsOk() )
return inst; // return an object to the application
}
pStack->SetError(TX_CLOSEPAR, p->GetStart());
}
pStack->SetError(TX_BADTYPE, p->GetStart());
}
pStack->SetError(TX_OPENPAR, p->GetStart());
delete inst; // error, frees up
return nullptr; // no object, the error is on the stack
}
// execution of "catch"
bool CBotCatch :: Execute(CBotStack* &pj)
{
if ( m_Block == nullptr ) return true;
return m_Block->Execute(pj); // executes the associated block
}
void CBotCatch :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( bMain && m_Block != nullptr ) m_Block->RestoreState(pj, bMain);
}
void CBotCatch :: RestoreCondState(CBotStack* &pj, bool bMain)
{
m_Cond->RestoreState(pj, bMain);
}
// routine to see if the catch is to do or not
bool CBotCatch :: TestCatch(CBotStack* &pile, int val)
{
if ( !m_Cond->Execute(pile) ) return false;
if ( val > 0 || pile->GetType() != CBotTypBoolean )
{
CBotVar* var = CBotVar::Create(static_cast<CBotToken*>(nullptr), CBotTypBoolean);
var->SetValInt( pile->GetVal() == val );
pile->SetVar(var); // calls on the stack
}
return true;
}
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
// compiles instruction "throw"
CBotThrow::CBotThrow()
{
m_Value = nullptr; // nullptr so that delete is not possible further
name = "CBotThrow"; // debug
}
CBotThrow::~CBotThrow()
{
delete m_Value;
}
CBotInstr* CBotThrow::Compile(CBotToken* &p, CBotCStack* pStack)
{
pStack->SetStartError(p->GetStart());
CBotThrow* inst = new CBotThrow(); // creates the object
inst->SetToken(p);
CBotToken* pp = p; // preserves at the ^ token (starting position)
if (!IsOfType(p, ID_THROW)) return nullptr; // should never happen
inst->m_Value = CBotExpression::Compile( p, pStack );
if (pStack->GetType() < CBotTypLong && pStack->IsOk())
{
return inst; // return an object to the application
}
pStack->SetError(TX_BADTYPE, pp);
delete inst; // error, frees up
return nullptr; // no object, the error is on the stack
}
// execution of instruction "throw"
bool CBotThrow :: Execute(CBotStack* &pj)
{
CBotStack* pile = pj->AddStack(this);
// if ( pile == EOX ) return true;
if ( pile->GetState() == 0 )
{
if ( !m_Value->Execute(pile) ) return false;
pile->IncState();
}
if ( pile->IfStep() ) return false;
int val = pile->GetVal();
if ( val < 0 ) val = TX_BADTHROW;
pile->SetError( val, &m_token );
return pj->Return( pile );
}
void CBotThrow :: RestoreState(CBotStack* &pj, bool bMain)
{
if ( !bMain ) return;
CBotStack* pile = pj->RestoreStack(this);
if ( pile == nullptr ) return;
if ( pile->GetState() == 0 )
{
m_Value->RestoreState(pile, bMain);
return;
}
}