immibis
/
colobot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactored EOX

dev-time-step
krzys-h 2015-12-31 17:59:48 +01:00
parent a70381e1c8
commit d63773d89d
17 changed files with 140 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/CBot/CBotDefines.h
View File

@ -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

67
src/CBot/CBotExternalCall.cpp
View File

@ -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
}

30
src/CBot/CBotExternalCall.h
View File

@ -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

4
src/CBot/CBotFileUtils.h
View File

@ -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

3
src/CBot/CBotInstr/CBotFieldExpr.cpp
View File

@ -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;

2
src/CBot/CBotInstr/CBotIndexExpr.cpp
View File

@ -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;

4
src/CBot/CBotInstr/CBotTry.cpp
View File

@ -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
}

190
src/CBot/CBotStack.cpp
View File

@ -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;
}
////////////////////////////////////////////////////////////////////////////////
@ -593,23 +593,6 @@ void CBotStack::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar)
m_prog->GetFunctions()->RestoreCall(nIdent, token->GetString(), ppVar, this);
}
////////////////////////////////////////////////////////////////////////////////
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)
{
@ -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)
{
return WriteWord(pf, 0); // is a terminator
}
if ( m_next2 != nullptr )
{
if (!WriteWord(pf, 2)) return false; // a mark of pursuit
if (!m_next2->SaveState(pf)) return false;
if (!WriteWord(pf, 2)) return false; // a marker of type (m_next2)
if (!m_next2->SaveState(pf)) return false; // saves the next element
}
else
{
if (!WriteWord(pf, 1)) return false; // a mark of pursuit
if (!WriteWord(pf, 1)) return false; // a marker of type (m_next)
}
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?
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 (!SaveVar(pf, m_var)) return false; // current result
if (!SaveVar(pf, m_listVar)) return false; // local variables
if (!SaveVars(pf, m_var)) return false; // current result
if (!SaveVars(pf, m_listVar)) return false; // local variables
return m_next->SaveState(pf); // saves the following
if (m_next != nullptr)
{
if (!m_next->SaveState(pf)) return false; // saves the next element
}
else
{
if (!WriteWord(pf, 0)) return false; // terminator
}
return true;
}
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
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

47
src/CBot/CBotStack.h
View File

@ -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
//! 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;
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;
//! 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

4
src/CBot/CBotVar/CBotVar.cpp
View File

@ -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);*/
}
////////////////////////////////////////////////////////////////////////////////

2
src/CBot/CBotVar/CBotVar.h
View File

@ -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

2
src/CBot/CBotVar/CBotVarArray.cpp
View File

@ -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

4
src/CBot/CBotVar/CBotVarClass.cpp
View File

@ -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

2
src/CBot/CBotVar/CBotVarClass.h
View File

@ -56,7 +56,7 @@ public:
bool Save1State(FILE* pf) override;
void Maj(void* pUser) override;
void Update(void* pUser) override;
//! \name Reference counter
//@{

13
src/CBot/CBotVar/CBotVarPointer.cpp
View File

@ -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());
}
////////////////////////////////////////////////////////////////////////////////

2
src/CBot/CBotVar/CBotVarPointer.h
View File

@ -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;

2
src/script/script.cpp
View File

@ -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