[colobot] 221/377: Refactored EOX
Didier Raboud
odyx at moszumanska.debian.org
Wed Mar 30 13:34:19 UTC 2016
This is an automated email from the git hooks/post-receive script.
odyx pushed a commit to branch debian/master
in repository colobot.
commit d63773d89d0ae3afda96ab3b8cce357f1bf8f51a
Author: krzys-h <krzys_h at interia.pl>
Date: Thu Dec 31 17:59:48 2015 +0100
Refactored EOX
---
src/CBot/CBotDefines.h | 2 -
src/CBot/CBotExternalCall.cpp | 67 +++----------
src/CBot/CBotExternalCall.h | 30 ------
src/CBot/CBotFileUtils.h | 4 +-
src/CBot/CBotInstr/CBotFieldExpr.cpp | 3 +-
src/CBot/CBotInstr/CBotIndexExpr.cpp | 2 +-
src/CBot/CBotInstr/CBotTry.cpp | 4 +-
src/CBot/CBotStack.cpp | 186 +++++++++++++++--------------------
src/CBot/CBotStack.h | 51 +++++-----
src/CBot/CBotVar/CBotVar.cpp | 4 +-
src/CBot/CBotVar/CBotVar.h | 2 +-
src/CBot/CBotVar/CBotVarArray.cpp | 2 +-
src/CBot/CBotVar/CBotVarClass.cpp | 4 +-
src/CBot/CBotVar/CBotVarClass.h | 2 +-
src/CBot/CBotVar/CBotVarPointer.cpp | 13 +--
src/CBot/CBotVar/CBotVarPointer.h | 2 +-
src/script/script.cpp | 2 +-
17 files changed, 140 insertions(+), 240 deletions(-)
diff --git a/src/CBot/CBotDefines.h b/src/CBot/CBotDefines.h
index 01f7e1b..e73e02a 100644
--- a/src/CBot/CBotDefines.h
+++ b/src/CBot/CBotDefines.h
@@ -22,8 +22,6 @@
#define STACKMEM 1 /// \def preserve memory for the execution stack
#define MAXSTACK 990 /// \def stack size reserved
-#define EOX (reinterpret_cast<CBotStack*>(-1)) /// \def tag special condition
-
#define MAXARRAYSIZE 9999
//! Define the current CBot version
diff --git a/src/CBot/CBotExternalCall.cpp b/src/CBot/CBotExternalCall.cpp
index 20cb6c3..54ab787 100644
--- a/src/CBot/CBotExternalCall.cpp
+++ b/src/CBot/CBotExternalCall.cpp
@@ -71,7 +71,8 @@ bool CBotExternalCallList::CheckCall(const std::string& name)
return m_list.count(name) > 0;
}
-int CBotExternalCallList::DoCall(CBotToken* token, CBotVar* thisVar, CBotVar** ppVar, CBotStack* pStack, const CBotTypResult& rettype)
+int CBotExternalCallList::DoCall(CBotToken* token, CBotVar* thisVar, CBotVar** ppVar, CBotStack* pStack,
+ const CBotTypResult& rettype)
{
if (token == nullptr)
return -1;
@@ -81,18 +82,18 @@ int CBotExternalCallList::DoCall(CBotToken* token, CBotVar* thisVar, CBotVar** p
CBotExternalCall* pt = m_list[token->GetString()].get();
- CBotStack* pile = pStack->AddStackEOX(pt);
- if (pile == EOX) return true;
+ if (pStack->IsCallFinished()) return true;
+ CBotStack* pile = pStack->AddStackExternalCall(pt);
// lists the parameters depending on the contents of the stack (pStackVar)
- CBotVar* pVar = MakeListVars(ppVar, true);
+ CBotVar* pVar = MakeListVars(ppVar, true);
// creates a variable to the result
- CBotVar* pResult = rettype.Eq(CBotTypVoid) ? nullptr : CBotVar::Create("", rettype);
+ CBotVar* pResult = rettype.Eq(CBotTypVoid) ? nullptr : CBotVar::Create("", rettype);
pile->SetVar(pVar);
- CBotStack* pile2 = pile->AddStack();
+ CBotStack* pile2 = pile->AddStack();
pile2->SetVar(pResult);
pile->SetError(CBotNoErr, token); // save token for the position in case of error
@@ -106,8 +107,8 @@ bool CBotExternalCallList::RestoreCall(CBotToken* token, CBotVar* thisVar, CBotV
CBotExternalCall* pt = m_list[token->GetString()].get();
- CBotStack* pile = pStack->RestoreStackEOX(pt);
- if ( pile == nullptr ) return true;
+ CBotStack* pile = pStack->RestoreStackEOX(pt);
+ if (pile == nullptr) return true;
pile->RestoreStack();
return true;
@@ -142,8 +143,8 @@ CBotTypResult CBotExternalCallDefault::Compile(CBotVar* thisVar, CBotVar* args,
bool CBotExternalCallDefault::Run(CBotVar* thisVar, CBotStack* pStack)
{
- CBotStack* pile = pStack->AddStackEOX(this);
- if ( pile == EOX ) return true;
+ if (pStack->IsCallFinished()) return true;
+ CBotStack* pile = pStack->AddStackExternalCall(this);
CBotVar* args = pile->GetVar();
CBotStack* pile2 = pile->AddStack();
@@ -167,48 +168,4 @@ bool CBotExternalCallDefault::Run(CBotVar* thisVar, CBotStack* pStack)
return true;
}
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-
-CBotExternalCallDefaultClass::CBotExternalCallDefaultClass(RuntimeFunc rExec, CompileFunc rCompile)
-{
- m_rExec = rExec;
- m_rComp = rCompile;
-}
-
-CBotExternalCallDefaultClass::~CBotExternalCallDefaultClass()
-{
-}
-
-CBotTypResult CBotExternalCallDefaultClass::Compile(CBotVar* thisVar, CBotVar* args, void* user)
-{
- return m_rComp(nullptr, args);
-}
-
-// TODO: Figure out why classes do pStack->SetVar while normal calls do pStack->SetCopyVar
-bool CBotExternalCallDefaultClass::Run(CBotVar* thisVar, CBotStack* pStack)
-{
- CBotStack* pile = pStack->AddStackEOX(this);
- if ( pile == EOX ) return true;
- CBotVar* args = pile->GetVar();
-
- CBotStack* pile2 = pile->AddStack();
-
- CBotVar* result = pile2->GetVar();
-
- int exception = CBotNoErr; // TODO: Change to CBotError
- bool res = m_rExec(thisVar, args, result, exception, pStack->GetUserPtr());
- pStack->SetVar(result);
-
- if (!res)
- {
- if (exception != CBotNoErr)
- {
- pStack->SetError(static_cast<CBotError>(exception));
- }
- return false;
- }
-
- return true;
-}
-
-} // namespace CBot
+}
\ No newline at end of file
diff --git a/src/CBot/CBotExternalCall.h b/src/CBot/CBotExternalCall.h
index 9fc84cb..d655409 100644
--- a/src/CBot/CBotExternalCall.h
+++ b/src/CBot/CBotExternalCall.h
@@ -105,36 +105,6 @@ private:
CompileFunc m_rComp;
};
-/**
- * \brief Default implementation of CBot external class call, using compilation and runtime functions
- */
-class CBotExternalCallDefaultClass : public CBotExternalCall
-{
-public:
- typedef bool (*RuntimeFunc)(CBotVar* thisVar, CBotVar* args, CBotVar* result, int& exception, void* user);
- typedef CBotTypResult (*CompileFunc)(CBotVar* thisVar, CBotVar*& args); // TODO: Add user pointer
-
- /**
- * \brief Constructor
- * \param rExec Runtime function
- * \param rCompile Compilation function
- * \see CBotClass::AddFunction()
- */
- CBotExternalCallDefaultClass(RuntimeFunc rExec, CompileFunc rCompile);
-
- /**
- * \brief Destructor
- */
- virtual ~CBotExternalCallDefaultClass();
-
- virtual CBotTypResult Compile(CBotVar* thisVar, CBotVar* args, void* user);
- virtual bool Run(CBotVar* thisVar, CBotStack* pStack);
-
-private:
- RuntimeFunc m_rExec;
- CompileFunc m_rComp;
-};
-
/**
* \brief Class for mangaging CBot external calls
diff --git a/src/CBot/CBotFileUtils.h b/src/CBot/CBotFileUtils.h
index a962f3b..d752ee0 100644
--- a/src/CBot/CBotFileUtils.h
+++ b/src/CBot/CBotFileUtils.h
@@ -73,12 +73,12 @@ std::size_t fRead(void *buffer,
FILE* filehandle);
/*!
- * \brief SaveVar
+ * \brief SaveVars
* \param pf
* \param pVar
* \return
*/
-bool SaveVar(FILE* pf, CBotVar* pVar);
+bool SaveVars(FILE* pf, CBotVar* pVar);
/*!
* \brief WriteWord
diff --git a/src/CBot/CBotInstr/CBotFieldExpr.cpp b/src/CBot/CBotInstr/CBotFieldExpr.cpp
index f240f86..04abeb1 100644
--- a/src/CBot/CBotInstr/CBotFieldExpr.cpp
+++ b/src/CBot/CBotInstr/CBotFieldExpr.cpp
@@ -72,7 +72,6 @@ bool CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prev
{
CBotStack* pj = pile;
pile = pile->AddStack(this); // changes in output stack
- if (pile == EOX) return true;
if (pVar->GetType(CBotVar::GetTypeMode::CLASS_AS_POINTER) != CBotTypPointer)
@@ -107,7 +106,7 @@ bool CBotFieldExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prev
}
// request the update of the element, if applicable
- pVar->Maj(pile->GetUserPtr());
+ pVar->Update(pile->GetUserPtr());
if ( m_next3 != nullptr &&
!m_next3->ExecuteVar(pVar, pile, &m_token, bStep, bExtend) ) return false;
diff --git a/src/CBot/CBotInstr/CBotIndexExpr.cpp b/src/CBot/CBotInstr/CBotIndexExpr.cpp
index cf81390..e276e54 100644
--- a/src/CBot/CBotInstr/CBotIndexExpr.cpp
+++ b/src/CBot/CBotInstr/CBotIndexExpr.cpp
@@ -91,7 +91,7 @@ bool CBotIndexExpr::ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prev
return pj->Return(pile);
}
- pVar->Maj(pile->GetUserPtr());
+ pVar->Update(pile->GetUserPtr());
if ( m_next3 != nullptr &&
!m_next3->ExecuteVar(pVar, pile, prevToken, bStep, bExtend) ) return false;
diff --git a/src/CBot/CBotInstr/CBotTry.cpp b/src/CBot/CBotInstr/CBotTry.cpp
index a98056d..325887c 100644
--- a/src/CBot/CBotInstr/CBotTry.cpp
+++ b/src/CBot/CBotInstr/CBotTry.cpp
@@ -101,14 +101,14 @@ bool CBotTry::Execute(CBotStack* &pj)
}
val = pile1->GetError();
- if ( val == 0 && CBotStack::m_initimer == 0 ) // mode step?
+ if ( val == CBotNoErr && pile1->GetTimer() == 0 ) // mode step?
return false; // does not make the catch
pile1->IncState();
pile2->SetState(val); // stores the error number
pile1->SetError(CBotNoErr); // for now there is are more errors!
- if ( val == 0 && CBotStack::m_initimer < 0 ) // mode step?
+ if ( val == CBotNoErr && pile1->GetTimer() < 0 ) // mode step?
return false; // does not make the catch
}
diff --git a/src/CBot/CBotStack.cpp b/src/CBot/CBotStack.cpp
index fc230a7..2c542e2 100644
--- a/src/CBot/CBotStack.cpp
+++ b/src/CBot/CBotStack.cpp
@@ -36,9 +36,9 @@
namespace CBot
{
-#define ITIMER 100
+const int DEFAULT_TIMER = 100;
-int CBotStack::m_initimer = ITIMER;
+int CBotStack::m_initimer = DEFAULT_TIMER;
int CBotStack::m_timer = 0;
CBotVar* CBotStack::m_retvar = nullptr;
CBotError CBotStack::m_error = CBotNoErr;
@@ -61,7 +61,7 @@ CBotStack* CBotStack::AllocateStack()
// completely empty
memset(p, 0, size);
- p-> m_bBlock = BlockVisibilityType::BLOCK;
+ p->m_block = BlockVisibilityType::BLOCK;
m_timer = m_initimer; // sets the timer at the beginning
CBotStack* pp = p;
@@ -80,7 +80,7 @@ CBotStack* CBotStack::AllocateStack()
////////////////////////////////////////////////////////////////////////////////
void CBotStack::Delete()
{
- if ( this == nullptr || this == EOX ) return;
+ if ( this == nullptr ) return;
m_next->Delete();
m_next2->Delete();
@@ -125,32 +125,29 @@ CBotStack* CBotStack::AddStack(CBotInstr* instr, BlockVisibilityType bBlock)
while ( p->m_prev != nullptr );
m_next = p; // chain an element
- p->m_bBlock = bBlock;
- p->m_instr = instr;
- p->m_prog = m_prog;
- p->m_step = 0;
- p->m_prev = this;
- p->m_state = 0;
- p->m_call = nullptr;
- p->m_bFunc = IsFunction::NO;
- return p;
+ p->m_block = bBlock;
+ p->m_instr = instr;
+ p->m_prog = m_prog;
+ p->m_step = 0;
+ p->m_prev = this;
+ p->m_state = 0;
+ p->m_call = nullptr;
+ p->m_func = IsFunction::NO;
+ p->m_callFinished = false;
+ return p;
}
////////////////////////////////////////////////////////////////////////////////
-CBotStack* CBotStack::AddStackEOX(CBotExternalCall* instr, BlockVisibilityType bBlock)
+CBotStack* CBotStack::AddStackExternalCall(CBotExternalCall* instr, BlockVisibilityType bBlock)
{
+ assert(!m_callFinished);
if (m_next != nullptr)
{
- if ( m_next == EOX )
- {
- m_next = nullptr;
- return EOX;
- }
return m_next; // included in an existing stack
}
CBotStack* p = AddStack(nullptr, bBlock);
p->m_call = instr;
- p->m_bFunc = IsFunction::EXTERNAL_CALL; // special
+ p->m_func = IsFunction::EXTERNAL_CALL;
return p;
}
@@ -172,7 +169,7 @@ CBotStack* CBotStack::AddStack2(BlockVisibilityType bBlock)
m_next2 = p; // chain an element
p->m_prev = this;
- p->m_bBlock = bBlock;
+ p->m_block = bBlock;
p->m_prog = m_prog;
p->m_step = 0;
return p;
@@ -181,7 +178,7 @@ CBotStack* CBotStack::AddStack2(BlockVisibilityType bBlock)
////////////////////////////////////////////////////////////////////////////////
CBotStack::BlockVisibilityType CBotStack::GetBlock()
{
- return m_bBlock;
+ return m_block;
}
////////////////////////////////////////////////////////////////////////////////
@@ -282,7 +279,7 @@ bool CBotStack::IfContinue(int state, const std::string& name)
m_state = state; // where again?
m_error = CBotNoErr;
m_labelBreak.clear();
- if ( m_next != EOX ) m_next->Delete(); // purge above stack
+ m_next->Delete(); // purge above stack
return true;
}
@@ -327,7 +324,7 @@ CBotVar* CBotStack::FindVar(CBotToken*& pToken, bool bUpdate)
if (pp->GetName() == name)
{
if ( bUpdate )
- pp->Maj(m_pUser);
+ pp->Update(m_pUser);
return pp;
}
@@ -370,7 +367,7 @@ CBotVar* CBotStack::FindVar(long ident, bool bUpdate)
if (pp->GetUniqNum() == ident)
{
if ( bUpdate )
- pp->Maj(m_pUser);
+ pp->Update(m_pUser);
return pp;
}
@@ -451,6 +448,11 @@ void CBotStack::SetTimer(int n)
m_initimer = n;
}
+int CBotStack::GetTimer()
+{
+ return m_initimer;
+}
+
////////////////////////////////////////////////////////////////////////////////
bool CBotStack::Execute()
{
@@ -476,7 +478,7 @@ bool CBotStack::Execute()
pile->m_next->Delete();
- pile->m_next = EOX; // special for recovery
+ pile->m_callFinished = true;
return true;
}
@@ -517,12 +519,10 @@ void CBotStack::AddVar(CBotVar* pVar)
CBotStack* p = this;
// returns to the father element
- while (p != nullptr && p->m_bBlock == BlockVisibilityType::INSTRUCTION) p = p->m_prev;
+ while (p != nullptr && p->m_block == BlockVisibilityType::INSTRUCTION) p = p->m_prev;
if ( p == nullptr ) return;
-// p->m_bDontDelete = bDontDelete;
-
CBotVar** pp = &p->m_listVar;
while ( *pp != nullptr ) pp = &(*pp)->m_next;
@@ -532,8 +532,8 @@ void CBotStack::AddVar(CBotVar* pVar)
////////////////////////////////////////////////////////////////////////////////
void CBotStack::SetProgram(CBotProgram* p)
{
- m_prog = p;
- m_bFunc = IsFunction::YES;
+ m_prog = p;
+ m_func = IsFunction::YES;
}
////////////////////////////////////////////////////////////////////////////////
@@ -594,23 +594,6 @@ void CBotStack::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar)
}
////////////////////////////////////////////////////////////////////////////////
-bool SaveVar(FILE* pf, CBotVar* pVar)
-{
- while ( true )
- {
- if ( pVar == nullptr )
- {
- return WriteWord(pf, 0); // is a terminator
- }
-
- if ( !pVar->Save0State(pf)) return false; // common header
- if ( !pVar->Save1State(pf) ) return false; // saves as the child class
-
- pVar = pVar->GetNext();
- }
-}
-
-////////////////////////////////////////////////////////////////////////////////
void CBotStack::GetRunPos(std::string& functionName, int& start, int& end)
{
CBotProgram* prog = m_prog; // Current program
@@ -623,7 +606,7 @@ void CBotStack::GetRunPos(std::string& functionName, int& start, int& end)
while (p->m_next != nullptr)
{
if ( p->m_instr != nullptr ) instr = p->m_instr;
- if ( p->m_bFunc == IsFunction::YES && p->m_instr != nullptr ) funct = p->m_instr;
+ if (p->m_func == IsFunction::YES && p->m_instr != nullptr ) funct = p->m_instr;
if ( p->m_next->m_prog != prog ) break ;
if (p->m_next2 && p->m_next2->m_state != 0) p = p->m_next2 ;
@@ -631,7 +614,7 @@ void CBotStack::GetRunPos(std::string& functionName, int& start, int& end)
}
if ( p->m_instr != nullptr ) instr = p->m_instr;
- if ( p->m_bFunc == IsFunction::YES && p->m_instr != nullptr ) funct = p->m_instr;
+ if (p->m_func == IsFunction::YES && p->m_instr != nullptr ) funct = p->m_instr;
if ( funct == nullptr ) return;
@@ -665,13 +648,13 @@ CBotVar* CBotStack::GetStackVars(std::string& functionName, int level)
// descends upon the elements of block
- while ( p != nullptr && p->m_bBlock == BlockVisibilityType::INSTRUCTION) p = p->m_prev;
+ while ( p != nullptr && p->m_block == BlockVisibilityType::INSTRUCTION) p = p->m_prev;
// Now p is on the beggining of the top block (with local variables)
while ( p != nullptr && level++ < 0 )
{
p = p->m_prev;
- while ( p != nullptr && p->m_bBlock == BlockVisibilityType::INSTRUCTION) p = p->m_prev;
+ while ( p != nullptr && p->m_block == BlockVisibilityType::INSTRUCTION) p = p->m_prev;
}
// Now p is on the block "level"
@@ -681,7 +664,7 @@ CBotVar* CBotStack::GetStackVars(std::string& functionName, int level)
CBotStack* pp = p;
while ( pp != nullptr )
{
- if ( pp->m_bFunc == IsFunction::YES) break;
+ if (pp->m_func == IsFunction::YES) break;
pp = pp->m_prev;
}
@@ -696,59 +679,73 @@ CBotVar* CBotStack::GetStackVars(std::string& functionName, int level)
////////////////////////////////////////////////////////////////////////////////
bool CBotStack::SaveState(FILE* pf)
{
- if ( this == nullptr ) // end of the tree?
+ if (m_next2 != nullptr)
+ {
+ if (!WriteWord(pf, 2)) return false; // a marker of type (m_next2)
+ if (!m_next2->SaveState(pf)) return false; // saves the next element
+ }
+ else
{
- return WriteWord(pf, 0); // is a terminator
+ if (!WriteWord(pf, 1)) return false; // a marker of type (m_next)
}
+ if (!WriteWord(pf, static_cast<unsigned short>(m_block))) return false;
+ if (!WriteWord(pf, m_state)) return false;
+ if (!WriteWord(pf, 0)) return false; // for backwards combatibility (m_bDontDelete)
+ if (!WriteWord(pf, m_step)) return false;
+
- if ( m_next2 != nullptr )
+ if (!SaveVars(pf, m_var)) return false; // current result
+ if (!SaveVars(pf, m_listVar)) return false; // local variables
+
+ if (m_next != nullptr)
{
- if (!WriteWord(pf, 2)) return false; // a mark of pursuit
- if (!m_next2->SaveState(pf)) return false;
+ if (!m_next->SaveState(pf)) return false; // saves the next element
}
else
{
- if (!WriteWord(pf, 1)) return false; // a mark of pursuit
+ if (!WriteWord(pf, 0)) return false; // terminator
}
- if (!WriteWord(pf, static_cast<unsigned short>(m_bBlock))) return false; // is a local block
- if (!WriteWord(pf, m_state)) return false; // in what state?
- if (!WriteWord(pf, 0)) return false; // by compatibility m_bDontDelete
- if (!WriteWord(pf, m_step)) return false; // in what state?
-
+ return true;
+}
- if (!SaveVar(pf, m_var)) return false; // current result
- if (!SaveVar(pf, m_listVar)) return false; // local variables
+bool SaveVars(FILE* pf, CBotVar* pVar)
+{
+ while (pVar != nullptr)
+ {
+ if (!pVar->Save0State(pf)) return false; // common header
+ if (!pVar->Save1State(pf)) return false; // saves the data
- return m_next->SaveState(pf); // saves the following
+ pVar = pVar->GetNext();
+ }
+ return WriteWord(pf, 0); // terminator
}
////////////////////////////////////////////////////////////////////////////////
bool CBotStack::RestoreState(FILE* pf, CBotStack* &pStack)
{
- unsigned short w;
+ unsigned short w;
pStack = nullptr;
if (!ReadWord(pf, w)) return false;
- if ( w == 0 ) return true;
+ if ( w == 0 ) return true; // 0 - terminator
if ( this == nullptr ) pStack = AllocateStack();
else pStack = AddStack();
- if ( w == 2 )
+ if ( w == 2 ) // 2 - m_next2
{
if (!pStack->RestoreState(pf, pStack->m_next2)) return false;
}
- if (!ReadWord(pf, w)) return false; // is a local block
- pStack->m_bBlock = static_cast<BlockVisibilityType>(w);
+ if (!ReadWord(pf, w)) return false;
+ pStack->m_block = static_cast<BlockVisibilityType>(w);
- if (!ReadWord(pf, w)) return false; // in what state ?
- pStack->SetState(static_cast<short>(w)); // in a good state
+ if (!ReadWord(pf, w)) return false;
+ pStack->SetState(static_cast<short>(w));
- if (!ReadWord(pf, w)) return false; // dont delete?
- // uses more
+ if (!ReadWord(pf, w)) return false; // backwards compatibility (m_bDontDelete)
- if (!ReadWord(pf, w)) return false; // step by step
+ if (!ReadWord(pf, w)) return false;
pStack->m_step = w;
if (!CBotVar::RestoreState(pf, pStack->m_var)) return false; // temp variable
@@ -767,32 +764,6 @@ bool CBotVar::Save0State(FILE* pf)
return WriteString(pf, m_token->GetString()); // and variable name
}
-namespace
-{
-bool ParseInitType(int rawInitType, CBotVar::InitType* initType)
-{
- switch (rawInitType)
- {
- case static_cast<int>(CBotVar::InitType::UNDEF):
- *initType = CBotVar::InitType::UNDEF;
- break;
- case static_cast<int>(CBotVar::InitType::DEF):
- *initType = CBotVar::InitType::DEF;
- break;
- case static_cast<int>(CBotVar::InitType::IS_POINTER):
- *initType = CBotVar::InitType::IS_POINTER;
- break;
- case static_cast<int>(CBotVar::InitType::IS_NAN):
- *initType = CBotVar::InitType::IS_NAN;
- break;
- default:
- *initType = CBotVar::InitType::UNDEF;
- return false;
- }
- return true;
-}
-}
-
////////////////////////////////////////////////////////////////////////////////
bool CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
{
@@ -828,8 +799,8 @@ bool CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
if ( w == CBotTypClass ) w = CBotTypIntrinsic; // necessarily intrinsic
- CBotVar::InitType initType = CBotVar::InitType::UNDEF;
- if (!ReadWord(pf, wi) || !ParseInitType(wi, &initType)) return false; // init ?
+ if (!ReadWord(pf, wi)) return false; // init ?
+ CBotVar::InitType initType = static_cast<CBotVar::InitType>(wi);
if (!ReadString(pf, name)) return false; // variable name
CBotToken token(name, std::string());
@@ -929,4 +900,9 @@ bool CBotVar::RestoreState(FILE* pf, CBotVar* &pVar)
return true;
}
+bool CBotStack::IsCallFinished()
+{
+ return m_callFinished;
+}
+
} // namespace CBot
diff --git a/src/CBot/CBotStack.h b/src/CBot/CBotStack.h
index 261663e..61942dd 100644
--- a/src/CBot/CBotStack.h
+++ b/src/CBot/CBotStack.h
@@ -240,7 +240,8 @@ public:
*
* \todo Document params & return
*/
- CBotStack* AddStackEOX(CBotExternalCall* instr = nullptr, BlockVisibilityType bBlock = BlockVisibilityType::INSTRUCTION);
+ CBotStack* AddStackExternalCall(CBotExternalCall* instr = nullptr,
+ BlockVisibilityType bBlock = BlockVisibilityType::INSTRUCTION);
/**
* \brief Restore CBotInstr pointer after loading stack from file
@@ -446,6 +447,10 @@ public:
* \todo Full documentation of the timer
*/
static void SetTimer(int n);
+ /**
+ * \brief Get the current configured maximum number of "timer ticks" (parts of instructions) to execute
+ */
+ static int GetTimer();
/**
* \brief Get current position in the program
@@ -462,41 +467,41 @@ public:
*/
CBotVar* GetStackVars(std::string& functionName, int level);
+ bool IsCallFinished();
+
private:
CBotStack* m_next;
CBotStack* m_next2;
CBotStack* m_prev;
- friend class CBotDefArray;
- int m_state;
- int m_step;
+ int m_state;
+ int m_step;
static CBotError m_error;
static int m_start;
static int m_end;
- static
- CBotVar* m_retvar; // result of a return
+ static CBotVar* m_retvar; // result of a return
CBotVar* m_var; // result of the operations
CBotVar* m_listVar; // variables declared at this level
- BlockVisibilityType m_bBlock; // is part of a block (variables are local to this block)
+ BlockVisibilityType m_block; // is part of a block (variables are local to this block)
bool m_bOver; // stack limits?
-// bool m_bDontDelete; // special, not to destroy the variable during delete
- CBotProgram* m_prog; // user-defined functions
-
- static
- int m_initimer;
- static
- int m_timer;
- static
- std::string m_labelBreak;
- static
- void* m_pUser;
-
- CBotInstr* m_instr; // the corresponding instruction
- IsFunction m_bFunc; // an input of a function?
- CBotExternalCall* m_call; // recovery point in a extern call
- friend class CBotTry;
+ //! CBotProgram instance the execution is in in this stack level
+ CBotProgram* m_prog;
+
+ static int m_initimer;
+ static int m_timer;
+ static std::string m_labelBreak;
+ static void* m_pUser;
+
+ //! The corresponding instruction
+ CBotInstr* m_instr;
+ //! If this stack level holds a function call
+ IsFunction m_func;
+ //! Extern call on this level (only if m_func == IsFunction::EXTERNAL_CALL)
+ CBotExternalCall* m_call;
+
+ bool m_callFinished;
};
} // namespace CBot
diff --git a/src/CBot/CBotVar/CBotVar.cpp b/src/CBot/CBotVar/CBotVar.cpp
index a82598b..3b63096 100644
--- a/src/CBot/CBotVar/CBotVar.cpp
+++ b/src/CBot/CBotVar/CBotVar.cpp
@@ -128,10 +128,8 @@ bool CBotVar::Save1State(FILE* pf)
}
////////////////////////////////////////////////////////////////////////////////
-void CBotVar::Maj(void* pUser)
+void CBotVar::Update(void* pUser)
{
-/* if (!bContinu && m_pMyThis != nullptr)
- m_pMyThis->Maj(pUser, true);*/
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/CBot/CBotVar/CBotVar.h b/src/CBot/CBotVar/CBotVar.h
index 760c103..fdcb193 100644
--- a/src/CBot/CBotVar/CBotVar.h
+++ b/src/CBot/CBotVar/CBotVar.h
@@ -365,7 +365,7 @@ public:
* \param pUser User pointer to pass to the update function
* \see CBotClass::SetUpdateFunc()
*/
- virtual void Maj(void* pUser);
+ virtual void Update(void* pUser);
/**
* \brief Set unique identifier of this variable
diff --git a/src/CBot/CBotVar/CBotVarArray.cpp b/src/CBot/CBotVar/CBotVarArray.cpp
index dd44072..d0eacab 100644
--- a/src/CBot/CBotVar/CBotVarArray.cpp
+++ b/src/CBot/CBotVar/CBotVarArray.cpp
@@ -141,7 +141,7 @@ std::string CBotVarArray::GetValString()
bool CBotVarArray::Save1State(FILE* pf)
{
if ( !WriteType(pf, m_type) ) return false;
- return SaveVar(pf, m_pInstance); // saves the instance that manages the table
+ return SaveVars(pf, m_pInstance); // saves the instance that manages the table
}
} // namespace CBot
diff --git a/src/CBot/CBotVar/CBotVarClass.cpp b/src/CBot/CBotVar/CBotVarClass.cpp
index efd6412..93c6b8f 100644
--- a/src/CBot/CBotVar/CBotVarClass.cpp
+++ b/src/CBot/CBotVar/CBotVarClass.cpp
@@ -228,7 +228,7 @@ CBotClass* CBotVarClass::GetClass()
}
////////////////////////////////////////////////////////////////////////////////
-void CBotVarClass::Maj(void* pUser)
+void CBotVarClass::Update(void* pUser)
{
// retrieves the user pointer according to the class
// or according to the parameter passed to CBotProgram::Run()
@@ -467,7 +467,7 @@ bool CBotVarClass::Save1State(FILE* pf)
if ( !WriteType(pf, m_type) ) return false;
if ( !WriteLong(pf, m_ItemIdent) ) return false;
- return SaveVar(pf, m_pVar); // content of the object
+ return SaveVars(pf, m_pVar); // content of the object
}
} // namespace CBot
diff --git a/src/CBot/CBotVar/CBotVarClass.h b/src/CBot/CBotVar/CBotVarClass.h
index d00610e..545b884 100644
--- a/src/CBot/CBotVar/CBotVarClass.h
+++ b/src/CBot/CBotVar/CBotVarClass.h
@@ -56,7 +56,7 @@ public:
bool Save1State(FILE* pf) override;
- void Maj(void* pUser) override;
+ void Update(void* pUser) override;
//! \name Reference counter
//@{
diff --git a/src/CBot/CBotVar/CBotVarPointer.cpp b/src/CBot/CBotVar/CBotVarPointer.cpp
index cc81619..a0715a7 100644
--- a/src/CBot/CBotVar/CBotVarPointer.cpp
+++ b/src/CBot/CBotVar/CBotVarPointer.cpp
@@ -51,22 +51,19 @@ CBotVarPointer::CBotVarPointer(const CBotToken& name, CBotTypResult& type)
m_pClass = nullptr;
m_pVarClass = nullptr; // will be defined by a SetPointer()
- SetClass(type.GetClass() );
+ SetClass(type.GetClass());
}
////////////////////////////////////////////////////////////////////////////////
CBotVarPointer::~CBotVarPointer()
{
- if ( m_pVarClass != nullptr ) m_pVarClass->DecrementUse(); // decrement reference
+ if (m_pVarClass != nullptr) m_pVarClass->DecrementUse(); // decrement reference
}
////////////////////////////////////////////////////////////////////////////////
-void CBotVarPointer::Maj(void* pUser)
+void CBotVarPointer::Update(void* pUser)
{
-/* if ( !bContinu && m_pMyThis != nullptr )
- m_pMyThis->Maj(pUser, false);*/
-
- if ( m_pVarClass != nullptr) m_pVarClass->Maj(pUser);
+ if (m_pVarClass != nullptr) m_pVarClass->Update(pUser);
}
////////////////////////////////////////////////////////////////////////////////
@@ -189,7 +186,7 @@ bool CBotVarPointer::Save1State(FILE* pf)
if (!WriteLong(pf, GetIdent())) return false; // the unique reference
// also saves the proceedings copies
- return SaveVar(pf, GetPointer());
+ return SaveVars(pf, GetPointer());
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/src/CBot/CBotVar/CBotVarPointer.h b/src/CBot/CBotVar/CBotVarPointer.h
index ea3168b..f8e112d 100644
--- a/src/CBot/CBotVar/CBotVarPointer.h
+++ b/src/CBot/CBotVar/CBotVarPointer.h
@@ -63,7 +63,7 @@ public:
bool Save1State(FILE* pf) override;
- void Maj(void* pUser) override;
+ void Update(void* pUser) override;
bool Eq(CBotVar* left, CBotVar* right) override;
bool Ne(CBotVar* left, CBotVar* right) override;
diff --git a/src/script/script.cpp b/src/script/script.cpp
index a68d5e3..50c1b9a 100644
--- a/src/script/script.cpp
+++ b/src/script/script.cpp
@@ -508,7 +508,7 @@ void PutList(const char *baseName, bool bArray, CBot::CBotVar *var, Ui::CList *l
index = 0;
while ( var != nullptr )
{
- var->Maj(nullptr);
+ var->Update(nullptr);
pStatic = var->GetStaticVar(); // finds the static element
p = pStatic->GetName(); // variable name
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-games/colobot.git
More information about the Pkg-games-commits
mailing list