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

Changed GivAttrName() to GetAttrName()

dev-ui
Michał Konopacki 2012-08-11 20:59:35 +02:00
parent 7b03a6a2ac
commit a9186d1960
25 changed files with 1397 additions and 1397 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

638
src/CBot/CBot.cpp
View File

File diff suppressed because it is too large Load Diff

144
src/CBot/CBot.h
View File

@ -105,18 +105,18 @@ public:
bool StackOver();
/**
* \brief GivError Get error number of the stack
* \brief GetError Get error number of the stack
* \param [out] start beginning of the stack
* \param [out] end end of stack
* \return error number
*/
int GivError(int& start, int& end);
int GetError(int& start, int& end);
/**
* \brief GivError Get error number
* \brief GetError Get error number
* \return eror number
*/
int GivError();// rend le numéro d'erreur retourné
int GetError();// rend le numéro d'erreur retourné
/**
* \brief Reset Reset error at and set user
@ -131,18 +131,18 @@ public:
void SetType(CBotTypResult& type);
/**
* \brief GivType Get the type of value on the stack.
* \brief GetType Get the type of value on the stack.
* \param [in] mode Used when getting class type (1 gives pointer, 2 gives intrinsic).
* \return Type number.
*/
int GivType(int mode = 0);
int GetType(int mode = 0);
/**
* \brief Gives the type of complete value on the stack.
* \brief Getes the type of complete value on the stack.
* \param [in] mode Used when getting class type (1 gives pointer, 2 gives intrinsic).
* \return Type of an element.
*/
CBotTypResult GivTypResult(int mode = 0);
CBotTypResult GetTypResult(int mode = 0);
/**
* \brief Adds a local variable.
@ -215,18 +215,18 @@ public:
bool IsOk();
bool SetState(int n, int lim = -10); // select a state
int GivState(); // in what state am I?
int GetState(); // in what state am I?
bool IncState(int lim = -10); // passes to the next state
bool IfStep(); // do step by step
bool Execute();
void SetVar( CBotVar* var );
void SetCopyVar( CBotVar* var );
CBotVar* GivVar();
CBotVar* GivCopyVar();
CBotVar* GivPtVar();
bool GivRetVar(bool bRet);
long GivVal();
CBotVar* GetVar();
CBotVar* GetCopyVar();
CBotVar* GetPtVar();
bool GetRetVar(bool bRet);
long GetVal();
void SetStartError(int pos);
void SetError(int n, CBotToken* token = NULL);
@ -235,9 +235,9 @@ public:
void SetBreak(int val, const char* name);
void SetBotCall(CBotProgram* p);
CBotProgram* GivBotCall(bool bFirst = false);
void* GivPUser();
bool GivBlock();
CBotProgram* GetBotCall(bool bFirst = false);
void* GetPUser();
bool GetBlock();
bool ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotTypResult& rettype);
@ -250,7 +250,7 @@ public:
void SetTimer(int n);
void GetRunPos(const char* &FunctionName, int &start, int &end);
CBotVar* GivStackVars(const char* &FunctionName, int level);
CBotVar* GetStackVars(const char* &FunctionName, int level);
int m_temp;
@ -301,12 +301,12 @@ inline bool CBotStack::IsOk()
return (m_error == 0);
}
inline int CBotStack::GivState()
inline int CBotStack::GetState()
{
return m_state;
}
inline int CBotStack::GivError()
inline int CBotStack::GetError()
{
return m_error;
}
@ -343,14 +343,14 @@ public:
~CBotCStack();
bool IsOk();
int GivError();
int GivError(int& start, int& end);
int GetError();
int GetError(int& start, int& end);
// gives error number
void SetType(CBotTypResult& type);// determines the type
CBotTypResult GivTypResult(int mode = 0); // gives the type of value on the stack
int GivType(int mode = 0); // gives the type of value on the stack
CBotClass* GivClass(); // gives the class of the value on the stack
CBotTypResult GetTypResult(int mode = 0); // gives the type of value on the stack
int GetType(int mode = 0); // gives the type of value on the stack
CBotClass* GetClass(); // gives the class of the value on the stack
void AddVar(CBotVar* p); // adds a local variable
CBotVar* FindVar(CBotToken* &p); // finds a variable
@ -364,7 +364,7 @@ public:
void SetVar( CBotVar* var );
void SetCopyVar( CBotVar* var );
CBotVar* GivVar();
CBotVar* GetVar();
void SetStartError(int pos);
void SetError(int n, int pos);
@ -372,11 +372,11 @@ public:
void ResetError(int n, int start, int end);
void SetRetType(CBotTypResult& type);
CBotTypResult GivRetType();
CBotTypResult GetRetType();
// void SetBotCall(CBotFunction* &pFunc);
void SetBotCall(CBotProgram* p);
CBotProgram* GivBotCall();
CBotProgram* GetBotCall();
CBotTypResult CompileCall(CBotToken* &p, CBotVar** ppVars, long& nIdent);
bool CheckCall(CBotToken* &pToken, CBotDefParam* pParam);
@ -454,15 +454,15 @@ public:
bool CompCase(CBotStack* &pj, int val);
void SetToken(CBotToken* p);
int GivTokenType();
CBotToken* GivToken();
int GetTokenType();
CBotToken* GetToken();
void AddNext(CBotInstr* n);
CBotInstr* GivNext();
CBotInstr* GetNext();
void AddNext3(CBotInstr* n);
CBotInstr* GivNext3();
CBotInstr* GetNext3();
void AddNext3b(CBotInstr* n);
CBotInstr* GivNext3b();
CBotInstr* GetNext3b();
static
void IncLvl(CBotString& label);
@ -1263,9 +1263,9 @@ public:
void SetValInt(int val, const char* s = NULL);
void SetValFloat(float val);
int GivValInt();
float GivValFloat();
CBotString GivValString();
int GetValInt();
float GetValFloat();
CBotString GetValString();
void Copy(CBotVar* pSrc, bool bName=true);
@ -1314,9 +1314,9 @@ public:
void SetValInt(int val, const char* s = NULL);
void SetValFloat(float val);
int GivValInt();
float GivValFloat();
CBotString GivValString();
int GetValInt();
float GetValFloat();
CBotString GetValString();
void Copy(CBotVar* pSrc, bool bName=true);
@ -1354,7 +1354,7 @@ public:
// ~CBotVarString();
void SetValString(const char* p);
CBotString GivValString();
CBotString GetValString();
void Copy(CBotVar* pSrc, bool bName=true);
@ -1382,9 +1382,9 @@ public:
void SetValInt(int val, const char* s = NULL);
void SetValFloat(float val);
int GivValInt();
float GivValFloat();
CBotString GivValString();
int GetValInt();
float GetValFloat();
CBotString GetValString();
void Copy(CBotVar* pSrc, bool bName=true);
@ -1426,14 +1426,14 @@ public:
void Copy(CBotVar* pSrc, bool bName=true);
void SetClass(CBotClass* pClass); //, int &nIdent);
CBotClass* GivClass();
CBotVar* GivItem(const char* name); // return an element of a class according to its name (*)
CBotVar* GivItemRef(int nIdent);
CBotClass* GetClass();
CBotVar* GetItem(const char* name); // return an element of a class according to its name (*)
CBotVar* GetItemRef(int nIdent);
CBotVar* GivItem(int n, bool bExtend);
CBotVar* GivItemList();
CBotVar* GetItem(int n, bool bExtend);
CBotVar* GetItemList();
CBotString GivValString();
CBotString GetValString();
bool Save1State(FILE* pf);
void Maj(void* pUser, bool bContinue);
@ -1442,7 +1442,7 @@ public:
void DecrementUse(); // a reference to decrementation
CBotVarClass*
GivPointer();
GetPointer();
void SetItemList(CBotVar* pVar);
void SetIdent(long n);
@ -1450,7 +1450,7 @@ public:
static CBotVarClass* Find(long id);
// CBotVar* GivMyThis();
// CBotVar* GetMyThis();
bool Eq(CBotVar* left, CBotVar* right);
bool Ne(CBotVar* left, CBotVar* right);
@ -1474,18 +1474,18 @@ public:
void Copy(CBotVar* pSrc, bool bName=true);
void SetClass(CBotClass* pClass);
CBotClass* GivClass();
CBotVar* GivItem(const char* name); // return an element of a class according to its name (*)
CBotVar* GivItemRef(int nIdent);
CBotVar* GivItemList();
CBotClass* GetClass();
CBotVar* GetItem(const char* name); // return an element of a class according to its name (*)
CBotVar* GetItemRef(int nIdent);
CBotVar* GetItemList();
CBotString GivValString();
CBotString GetValString();
void SetPointer(CBotVar* p);
CBotVarClass*
GivPointer();
GetPointer();
void SetIdent(long n); // associates an identification number (unique)
long GivIdent(); // gives the identification number associated with
long GetIdent(); // gives the identification number associated with
void ConstructorSet();
bool Save1State(FILE* pf);
@ -1514,15 +1514,15 @@ public:
void SetPointer(CBotVar* p);
CBotVarClass*
GivPointer();
GetPointer();
void Copy(CBotVar* pSrc, bool bName=true);
CBotVar* GivItem(int n, bool bGrow=false); // makes an element according to its numeric index
CBotVar* GetItem(int n, bool bGrow=false); // makes an element according to its numeric index
// enlarged the table if necessary if bExtend
// CBotVar* GivItem(const char* name); // makes a element by literal index
CBotVar* GivItemList(); // gives the first item in the list
// CBotVar* GetItem(const char* name); // makes a element by literal index
CBotVar* GetItemList(); // gives the first item in the list
CBotString GivValString(); // gets the contents of the array into a string
CBotString GetValString(); // gets the contents of the array into a string
bool Save1State(FILE* pf);
};
@ -1544,7 +1544,7 @@ extern bool ReadString(FILE* pf, CBotString& s);
extern bool WriteType(FILE* pf, CBotTypResult type);
extern bool ReadType(FILE* pf, CBotTypResult& type);
extern float GivNumFloat( const char* p );
extern float GetNumFloat( const char* p );
#if false
extern void DEBUG( const char* text, int val, CBotStack* pile );
@ -1596,7 +1596,7 @@ public:
bool RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack);
#endif
CBotString GivName();
CBotString GetName();
CBotCall* Next();
static void SetPUser(void* pUser);
@ -1629,7 +1629,7 @@ public:
int DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotVar* &pResult, CBotStack* pStack, CBotToken* pFunc);
CBotString GivName();
CBotString GetName();
CBotCallMethode* Next();
void AddNext(CBotCallMethode* p);
@ -1655,11 +1655,11 @@ public:
void RestoreState(CBotStack* &pj, bool bMain);
void AddNext(CBotDefParam* p);
int GivType();
CBotTypResult GivTypResult();
CBotDefParam* GivNext();
int GetType();
CBotTypResult GetTypResult();
CBotDefParam* GetNext();
CBotString GivParamString();
CBotString GetParamString();
};
@ -1720,8 +1720,8 @@ public:
static
void AddPublic(CBotFunction* pfunc);
CBotString GivName();
CBotString GivParams();
CBotString GetName();
CBotString GetParams();
bool IsPublic();
bool IsExtern();
CBotFunction* Next();

126
src/CBot/CBotClass.cpp
View File

@ -175,7 +175,7 @@ void CBotClass::FreeLock(CBotProgram* p)
bool CBotClass::AddItem(CBotString name, CBotTypResult type, int mPrivate)
{
CBotToken token(name, CBotString());
CBotClass* pClass = type.GivClass();
CBotClass* pClass = type.GetClass();
CBotVar* pVar = CBotVar::Create( name, type );
/// pVar->SetUniqNum(CBotVar::NextUniqNum());
@ -188,7 +188,7 @@ bool CBotClass::AddItem(CBotString name, CBotTypResult type, int mPrivate)
{
// adds a new statement for the object initialization
pVar->m_InitExpr = new CBotNew() ;
CBotToken nom( pClass->GivName() );
CBotToken nom( pClass->GetName() );
pVar->m_InitExpr->SetToken(&nom);
}
}
@ -214,12 +214,12 @@ void CBotClass::AddNext(CBotClass* pClass)
p->m_next = pClass;
}
CBotString CBotClass::GivName()
CBotString CBotClass::GetName()
{
return m_name;
}
CBotClass* CBotClass::GivParent()
CBotClass* CBotClass::GetParent()
{
if ( this == NULL ) return NULL;
return m_pParent;
@ -237,34 +237,34 @@ bool CBotClass::IsChildOf(CBotClass* pClass)
}
CBotVar* CBotClass::GivVar()
CBotVar* CBotClass::GetVar()
{
return m_pVar;
}
CBotVar* CBotClass::GivItem(const char* name)
CBotVar* CBotClass::GetItem(const char* name)
{
CBotVar* p = m_pVar;
while ( p != NULL )
{
if ( p->GivName() == name ) return p;
p = p->GivNext();
if ( p->GetName() == name ) return p;
p = p->GetNext();
}
if ( m_pParent != NULL ) return m_pParent->GivItem(name);
if ( m_pParent != NULL ) return m_pParent->GetItem(name);
return NULL;
}
CBotVar* CBotClass::GivItemRef(int nIdent)
CBotVar* CBotClass::GetItemRef(int nIdent)
{
CBotVar* p = m_pVar;
while ( p != NULL )
{
if ( p->GivUniqNum() == nIdent ) return p;
p = p->GivNext();
if ( p->GetUniqNum() == nIdent ) return p;
p = p->GetNext();
}
if ( m_pParent != NULL ) return m_pParent->GivItemRef(nIdent);
if ( m_pParent != NULL ) return m_pParent->GetItemRef(nIdent);
return NULL;
}
@ -275,7 +275,7 @@ bool CBotClass::IsIntrinsic()
CBotClass* CBotClass::Find(CBotToken* &pToken)
{
return Find(pToken->GivString());
return Find(pToken->GetString());
}
CBotClass* CBotClass::Find(const char* name)
@ -284,7 +284,7 @@ CBotClass* CBotClass::Find(const char* name)
while ( p != NULL )
{
if ( p->GivName() == name ) return p;
if ( p->GetName() == name ) return p;
p = p->m_ExNext;
}
@ -301,7 +301,7 @@ bool CBotClass::AddFunction(const char* name,
while ( p != NULL )
{
if ( name == p->GivName() )
if ( name == p->GetName() )
{
if ( pp == NULL ) m_pCalls = p->m_next;
else pp->m_next = p->m_next;
@ -338,7 +338,7 @@ CBotTypResult CBotClass::CompileMethode(const char* name,
// find the methods declared by AddFunction
CBotTypResult r = m_pCalls->CompileCall(name, pThis, ppParams, pStack, nIdent);
if ( r.GivType() >= 0) return r;
if ( r.GetType() >= 0) return r;
// find the methods declared by user
@ -384,21 +384,21 @@ bool CBotClass::SaveStaticState(FILE* pf)
{
if (!WriteWord( pf, 1)) return false;
// save the name of the class
if (!WriteString( pf, p->GivName() )) return false;
if (!WriteString( pf, p->GetName() )) return false;
CBotVar* pv = p->GivVar();
CBotVar* pv = p->GetVar();
while( pv != NULL )
{
if ( pv->IsStatic() )
{
if (!WriteWord( pf, 1)) return false;
if (!WriteString( pf, pv->GivName() )) return false;
if (!WriteString( pf, pv->GetName() )) return false;
if ( !pv->Save0State(pf)) return false; // common header
if ( !pv->Save1State(pf) ) return false; // saves as the child class
if ( !WriteWord( pf, 0)) return false;
}
pv = pv->GivNext();
pv = pv->GetNext();
}
if (!WriteWord( pf, 0)) return false;
@ -435,7 +435,7 @@ bool CBotClass::RestoreStaticState(FILE* pf)
CBotVar* pv = NULL;
if (!ReadString( pf, VarName )) return false;
if ( pClass != NULL ) pVar = pClass->GivItem(VarName);
if ( pClass != NULL ) pVar = pClass->GetItem(VarName);
if (!CBotVar::RestoreState(pf, pv)) return false; // the temp variable
@ -475,7 +475,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
// seeks the corresponding classes
if ( pClass == NULL )
{
pStack->SetStartError(p->GivStart());
pStack->SetStartError(p->GetStart());
pClass = CBotClass::Find(p);
if ( pClass == NULL )
{
@ -483,7 +483,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
pStack->SetError(TX_NOCLASS, p);
return NULL;
}
p = p->GivNext();
p = p->GetNext();
}
bool bIntrinsic = pClass->IsIntrinsic();
@ -495,7 +495,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
inst = new CBotClassInst();
/// \TODO Need to be revised and fixed after adding unit tests
CBotToken token(pClass->GivName(), CBotString(), p->GivStart(), p->GivEnd());
CBotToken token(pClass->GetName(), CBotString(), p->GetStart(), p->GetEnd());
inst->SetToken(&token);
CBotToken* vartoken = p;
@ -504,8 +504,8 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
((CBotLeftExprVar*)inst->m_var)->m_typevar = type;
if (pStk->CheckVarLocal(vartoken)) // redefinition of the variable
{
pStk->SetStartError(vartoken->GivStart());
pStk->SetError(TX_REDEFVAR, vartoken->GivEnd());
pStk->SetStartError(vartoken->GetStart());
pStk->SetError(TX_REDEFVAR, vartoken->GetEnd());
goto error;
}
@ -520,7 +520,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
if (!pStk->IsOk() )
{
pStk->SetError(TX_CLBRK, p->GivStart());
pStk->SetError(TX_CLBRK, p->GetStart());
goto error;
}
goto suite; // no assignment, variable already created
@ -528,7 +528,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
CBotVar* var;
var = CBotVar::Create(vartoken->GivString(), type); // creates the instance
var = CBotVar::Create(vartoken->GetString(), type); // creates the instance
// var->SetClass(pClass);
var->SetUniqNum(
((CBotLeftExprVar*)inst->m_var)->m_nIdent = CBotVar::NextUniqNum());
@ -536,7 +536,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
pStack->AddVar(var); // placed on the stack
// look if there are parameters
inst->m_hasParams = (p->GivType() == ID_OPENPAR);
inst->m_hasParams = (p->GetType() == ID_OPENPAR);
CBotVar* ppVars[1000];
inst->m_Parameters = CompileParams(p, pStk, ppVars);
@ -551,9 +551,9 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
{
// the constructor is there?
// CBotString noname;
CBotTypResult r = pClass->CompileMethode(pClass->GivName(), var, ppVars, pStk, inst->m_nMethodeIdent);
CBotTypResult r = pClass->CompileMethode(pClass->GetName(), var, ppVars, pStk, inst->m_nMethodeIdent);
delete pStk->TokenStack(); // releases the supplement stack
int typ = r.GivType();
int typ = r.GetType();
if (typ == TX_UNDEFCALL)
{
@ -568,7 +568,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
if (typ>20)
{
pStk->SetError(typ, vartoken->GivEnd());
pStk->SetError(typ, vartoken->GetEnd());
goto error;
}
@ -578,7 +578,7 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
{
if (inst->m_hasParams)
{
pStk->SetError(TX_ENDOF, p->GivStart());
pStk->SetError(TX_ENDOF, p->GetStart());
goto error;
}
@ -586,15 +586,15 @@ CBotInstr* CBotClassInst::Compile(CBotToken* &p, CBotCStack* pStack, CBotClass*
{
goto error;
}
CBotClass* result = pStk->GivClass();
if ( !pStk->GivTypResult(1).Eq(CBotTypNullPointer) &&
( !pStk->GivTypResult(1).Eq(CBotTypPointer) ||
CBotClass* result = pStk->GetClass();
if ( !pStk->GetTypResult(1).Eq(CBotTypNullPointer) &&
( !pStk->GetTypResult(1).Eq(CBotTypPointer) ||
( result != NULL && !pClass->IsChildOf(result) ))) // type compatible ?
{
pStk->SetError(TX_BADTYPE, p->GivStart());
pStk->SetError(TX_BADTYPE, p->GetStart());
goto error;
}
// if ( !bIntrinsic ) var->SetPointer(pStk->GivVar()->GivPointer());
// if ( !bIntrinsic ) var->SetPointer(pStk->GetVar()->GetPointer());
if ( !bIntrinsic )
{
// does not use the result on the stack, to impose the class
@ -630,7 +630,7 @@ suite:
return pStack->Return(inst, pStk);
}
pStk->SetError(TX_ENDOF, p->GivStart());
pStk->SetError(TX_ENDOF, p->GetStart());
}
error:
@ -655,9 +655,9 @@ bool CBotClassInst::Execute(CBotStack* &pj)
// creates the variable of type pointer to the object
if ( pile->GivState()==0)
if ( pile->GetState()==0)
{
CBotString name = m_var->m_token.GivString();
CBotString name = m_var->m_token.GetString();
if ( bIntrincic )
{
pThis = CBotVar::Create(name, CBotTypResult( CBotTypIntrinsic, pClass ));
@ -674,7 +674,7 @@ bool CBotClassInst::Execute(CBotStack* &pj)
if ( pThis == NULL ) pThis = pile->FindVar(((CBotLeftExprVar*)m_var)->m_nIdent);
if ( pile->GivState()<3)
if ( pile->GetState()<3)
{
// ss there an assignment or parameters (contructor)
@ -687,18 +687,18 @@ bool CBotClassInst::Execute(CBotStack* &pj)
if ( bIntrincic )
{
CBotVar* pv = pile->GivVar();
if ( pv == NULL || pv->GivPointer() == NULL )
CBotVar* pv = pile->GetVar();
if ( pv == NULL || pv->GetPointer() == NULL )
{
pile->SetError(TX_NULLPT, &m_token);
return pj->Return(pile);
}
pThis->Copy(pile->GivVar(), false);
pThis->Copy(pile->GetVar(), false);
}
else
{
CBotVarClass* pInstance;
pInstance = ((CBotVarPointer*)pile->GivVar())->GivPointer(); // value for the assignment
pInstance = ((CBotVarPointer*)pile->GetVar())->GetPointer(); // value for the assignment
pThis->SetPointer(pInstance);
}
pThis->SetInit(true);
@ -708,7 +708,7 @@ bool CBotClassInst::Execute(CBotStack* &pj)
{
// evaluates the constructor of an instance
if ( !bIntrincic && pile->GivState() == 1)
if ( !bIntrincic && pile->GetState() == 1)
{
CBotToken* pt = &m_token;
CBotClass* pClass = CBotClass::Find(pt);
@ -736,13 +736,13 @@ bool CBotClassInst::Execute(CBotStack* &pj)
if ( p != NULL) while ( true )
{
pile2 = pile2->AddStack(); // place on the stack for the results
if ( pile2->GivState() == 0 )
if ( pile2->GetState() == 0 )
{
if (!p->Execute(pile2)) return false; // interrupted here?
pile2->SetState(1);
}
ppVars[i++] = pile2->GivVar();
p = p->GivNext();
ppVars[i++] = pile2->GetVar();
p = p->GetNext();
if ( p == NULL) break;
}
ppVars[i] = NULL;
@ -750,15 +750,15 @@ bool CBotClassInst::Execute(CBotStack* &pj)
// creates a variable for the result
CBotVar* pResult = NULL; // constructor still void
if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GivName(),
if ( !pClass->ExecuteMethode(m_nMethodeIdent, pClass->GetName(),
pThis, ppVars,
pResult, pile2, GivToken())) return false; // interrupt
pResult, pile2, GetToken())) return false; // interrupt
pThis->SetInit(true);
pThis->ConstructorSet(); // indicates that the constructor has been called
pile->Return(pile2); // releases a piece of stack
// pInstance = pThis->GivPointer();
// pInstance = pThis->GetPointer();
}
@ -787,7 +787,7 @@ void CBotClassInst::RestoreState(CBotStack* &pj, bool bMain)
// creates the variable of type pointer to the object
{
CBotString name = m_var->m_token.GivString();
CBotString name = m_var->m_token.GetString();
pThis = pile->FindVar(name);
pThis->SetUniqNum(((CBotLeftExprVar*)m_var)->m_nIdent); // its attribute a unique number
}
@ -796,7 +796,7 @@ void CBotClassInst::RestoreState(CBotStack* &pj, bool bMain)
CBotClass* pClass = CBotClass::Find(pt);
bool bIntrincic = pClass->IsIntrinsic();
if ( bMain && pile->GivState()<3)
if ( bMain && pile->GetState()<3)
{
// is there an assignment or parameters (constructor)
@ -813,7 +813,7 @@ void CBotClassInst::RestoreState(CBotStack* &pj, bool bMain)
{
// evaluates the constructor of an instance
if ( !bIntrincic && pile->GivState() == 1)
if ( !bIntrincic && pile->GetState() == 1)
{
return;
}
@ -833,13 +833,13 @@ void CBotClassInst::RestoreState(CBotStack* &pj, bool bMain)
pile2 = pile2->RestoreStack(); // place on the stack for the results
if ( pile2 == NULL ) return;
if ( pile2->GivState() == 0 )
if ( pile2->GetState() == 0 )
{
p->RestoreState(pile2, bMain); // interrupted here?
return;
}
ppVars[i++] = pile2->GivVar();
p = p->GivNext();
ppVars[i++] = pile2->GetVar();
p = p->GetNext();
if ( p == NULL) break;
}
ppVars[i] = NULL;
@ -847,7 +847,7 @@ void CBotClassInst::RestoreState(CBotStack* &pj, bool bMain)
// creates a variable for the result
CBotVar* pResult = NULL; // constructor still void
pClass->RestoreMethode(m_nMethodeIdent, pClass->GivName(), pThis, ppVars, pile2);
pClass->RestoreMethode(m_nMethodeIdent, pClass->GetName(), pThis, ppVars, pile2);
return;
}
}
@ -861,14 +861,14 @@ void CBotClassInst::RestoreState(CBotStack* &pj, bool bMain)
bool CBotClass::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
CBotString name = pToken->GivString();
CBotString name = pToken->GetString();
if ( CBotCall::CheckCall(name) ) return true;
CBotFunction* pp = m_pMethod;
while ( pp != NULL )
{
if ( pToken->GivString() == pp->GivName() )
if ( pToken->GetString() == pp->GetName() )
{
// are their parameters exactly the same?
if ( pp->CheckParam( pParam ) )

126
src/CBot/CBotDll.h
View File

@ -111,16 +111,16 @@ public:
~CBotTypResult();
int GivType(int mode = 0) const;
int GetType(int mode = 0) const;
// returns type CBotType* as a result
void SetType(int n);
// modifies a type
CBotClass* GivClass() const;
CBotClass* GetClass() const;
// makes the pointer to the class (for CBotTypClass, CBotTypPointer)
int GivLimite() const;
int GetLimite() const;
// returns limit size of table (CBotTypArray)
void SetLimite(int n);
@ -129,7 +129,7 @@ public:
void SetArray(int* max );
// set limits for a list of dimensions (arrays of arrays)
CBotTypResult& GivTypElem() const;
CBotTypResult& GetTypElem() const;
// returns type of array elements (CBotTypArray)
// rend le type des éléments du tableau (CBotTypArray)
@ -262,7 +262,7 @@ public:
void Empty();
bool IsEmpty() const;
int GivLength();
int GetLength();
int Find(const char c);
int Find(const char* lpsz);
int ReverseFind(const char c);
@ -338,7 +338,7 @@ public:
CBotStringArray();
~CBotStringArray();
void SetSize(int nb);
int GivSize();
int GetSize();
void Add(const CBotString& str);
CBotString& operator[](int nIndex);
@ -388,7 +388,7 @@ public:
// frees the static memory areas
static
int GivVersion();
int GetVersion();
// gives the version of the library CBOT
@ -406,10 +406,10 @@ public:
void SetIdent(long n);
// associates an identifier with the instance CBotProgram
long GivIdent();
long GetIdent();
// gives the identifier
int GivError();
int GetError();
bool GetError(int& code, int& start, int& end);
bool GetError(int& code, int& start, int& end, CBotProgram* &pProg);
// if true
@ -417,7 +417,7 @@ public:
// or execution
// delimits the start and end block where the error
// pProg lets you know what "module" has produced runtime error
static CBotString GivErrorText(int code);
static CBotString GetErrorText(int code);
bool Start(const char* name);
@ -437,7 +437,7 @@ public:
// FunctionName is a pointer made to the name of the function
// start and end position in the text of the token processing
CBotVar* GivStackVars(const char* &FunctionName, int level);
CBotVar* GetStackVars(const char* &FunctionName, int level);
// provides the pointer to the variables on the execution stack
// level is an input parameter, 0 for the last level, -1, -2, etc. for the other levels
// the return value (CBotVar *) is a variable list (or NULL)
@ -480,7 +480,7 @@ public:
// see the above modes in CBotGet
CBotFunction* GivFunctions();
CBotFunction* GetFunctions();
};
@ -513,8 +513,8 @@ int cMean(CBotVar* &pVar, CBotString& ClassName)
while ( pVar != NULL )
{
if ( pVar->GivType() > CBotTypDouble ) return 6002; // this is not a number
pVar = pVar -> GivNext();
if ( pVar->GetType() > CBotTypDouble ) return 6002; // this is not a number
pVar = pVar -> GetNext();
}
return CBotTypFloat; // the type of the result may depend on the parameters!
@ -527,8 +527,8 @@ bool rMean(CBotVar* pVar, CBotVar* pResult, int& Exception)
int nb = 0;
while (pVar != NULL)
{
total += pVar->GivValFloat();
pVar = pVar->GivNext();
total += pVar->GetValFloat();
pVar = pVar->GetNext();
nb++;
}
pResult->SetValFloat(total/nb); // returns the mean value
@ -544,7 +544,7 @@ bool rMean(CBotVar* pVar, CBotVar* pResult, int& Exception)
// may be useful to the outside of the module
// ( it is currently not expected to be able to create these objects in outer )
// results of GivInit()
// results of GetInit()
#define IS_UNDEF 0 // undefined variable
#define IS_DEF 1 // variable defined
#define IS_NAN 999 // variable defined as not a number
@ -615,33 +615,33 @@ virtual ~CBotVar( ); // destructor
// associates a unique identifier to an instance
// ( it is used to ensure that the id is unique)
void* GivUserPtr();
void* GetUserPtr();
// makes the pointer associated with the variable
CBotString GivName(); // the name of the variable, if known
CBotString GetName(); // the name of the variable, if known
////////////////////////////////////////////////////////////////////////////////////
void SetName(const char* name); // changes the name of the variable
int GivType(int mode = 0); // returns the base type (int) of the variable
int GetType(int mode = 0); // returns the base type (int) of the variable
// TODO check it
////////////////////////////////////////////////////////////////////////////////////////
CBotTypResult GivTypResult(int mode = 0); // returns the complete type of the variable
CBotTypResult GetTypResult(int mode = 0); // returns the complete type of the variable
CBotToken* GivToken();
CBotToken* GetToken();
void SetType(CBotTypResult& type);
void SetInit(int bInit); // is the variable in the state IS_UNDEF, IS_DEF, IS_NAN
int GivInit(); // gives the state of the variable
int GetInit(); // gives the state of the variable
void SetStatic(bool bStatic);
bool IsStatic();
void SetPrivate(int mPrivate);
bool IsPrivate(int mode = PR_PROTECT);
int GivPrivate();
int GetPrivate();
virtual
void ConstructorSet();
@ -649,23 +649,23 @@ virtual ~CBotVar( ); // destructor
void SetVal(CBotVar* var); // remprend une valeur
// TODO remprend value
virtual
CBotVar* GivItem(const char* name); // returns an element of a class according to its name (*)
CBotVar* GetItem(const char* name); // returns an element of a class according to its name (*)
virtual
CBotVar* GivItemRef(int nIdent); // idem à partir du n° ref
CBotVar* GetItemRef(int nIdent); // idem à partir du n° ref
// TODO ditto from ref no.
virtual
CBotVar* GivItem(int row, bool bGrow = false);
CBotVar* GetItem(int row, bool bGrow = false);
virtual
CBotVar* GivItemList(); // lists the elements
CBotVar* GetItemList(); // lists the elements
CBotVar* GivStaticVar(); // makes the pointer to the variable if it is static
CBotVar* GetStaticVar(); // makes the pointer to the variable if it is static
bool IsElemOfClass(const char* name);
// said if the element belongs to the class "name"
// makes true if the object is a subclass
CBotVar* GivNext(); // next variable in the list (parameters)
CBotVar* GetNext(); // next variable in the list (parameters)
////////////////////////////////////////////////////////////////////////////////////////////
void AddNext(CBotVar* pVar); // added to a list
@ -683,23 +683,23 @@ virtual ~CBotVar( ); // destructor
virtual void SetValString(const char* p);// initialized with a string value (#)
////////////////////////////////////////////////////////////////////////////////
virtual int GivValInt(); // request the full value (#)
virtual int GetValInt(); // request the full value (#)
////////////////////////////////////////////////////////////////////////
virtual float GivValFloat(); // gets real value (#)
virtual float GetValFloat(); // gets real value (#)
///////////////////////////////////////////////////////////////////////
virtual
CBotString GivValString(); // request the string value (#)
CBotString GetValString(); // request the string value (#)
///////////////////////////////////////////////////////////////////////
virtual void SetClass(CBotClass* pClass);
virtual
CBotClass* GivClass();
CBotClass* GetClass();
virtual void SetPointer(CBotVar* p);
virtual
CBotVarClass* GivPointer();
CBotVarClass* GetPointer();
// virtual void SetIndirection(CBotVar* pVar);
virtual void Add(CBotVar* left, CBotVar* right); // addition
@ -736,13 +736,13 @@ virtual ~CBotVar( ); // destructor
void debug();
// virtual
// CBotVar* GivMyThis();
// CBotVar* GetMyThis();
virtual
void Maj(void* pUser = NULL, bool bContinue = true);
void SetUniqNum(long n);
long GivUniqNum();
long GetUniqNum();
static long NextUniqNum();
};
@ -751,12 +751,12 @@ virtual ~CBotVar( ); // destructor
can be called with objects which are respectively integer, real or string
Always be sure of the type of the variable before calling these methods
if ( pVar->GivType() == CBotInt() ) pVar->SetValFloat( 3.3 ); // plante !!
if ( pVar->GetType() == CBotInt() ) pVar->SetValFloat( 3.3 ); // plante !!
methods GivValInt(), GivValFloat() et GivValString()
methods GetValInt(), GetValFloat() et GetValString()
use value conversions,
GivValString() works on numbers (makes the corresponding string)
but do not make GivValInt () with a string variable!
GetValString() works on numbers (makes the corresponding string)
but do not make GetValInt () with a string variable!
*/
@ -824,8 +824,8 @@ public:
// adds an element by giving an element of type CBotVar
void AddNext(CBotClass* pClass);
CBotString GivName(); // gives the name of the class
CBotClass* GivParent(); // gives the parent class (or NULL)
CBotString GetName(); // gives the name of the class
CBotClass* GetParent(); // gives the parent class (or NULL)
// true if a class is derived (Extends) of another
// return true also if the classes are identical
@ -837,9 +837,9 @@ public:
static
CBotClass* Find(const char* name);
CBotVar* GivVar(); // return the list of variables
CBotVar* GivItem(const char* name); // one of the variables according to its name
CBotVar* GivItemRef(int nIdent);
CBotVar* GetVar(); // return the list of variables
CBotVar* GetItem(const char* name); // one of the variables according to its name
CBotVar* GetItemRef(int nIdent);
CBotTypResult CompileMethode(const char* name, CBotVar* pThis, CBotVar** ppParams,
CBotCStack* pStack, long& nIdent);
@ -922,9 +922,9 @@ private:
* \brief Check whether given parameter is a keyword
*/
static
int GivKeyWords(const char* w); // is it a keyword?
int GetKeyWords(const char* w); // is it a keyword?
static
bool GivKeyDefNum(const char* w, CBotToken* &token);
bool GetKeyDefNum(const char* w, CBotToken* &token);
/**
* \brief Loads the list of keywords
@ -948,35 +948,35 @@ public:
/**
* \brief Returns the type of token
*/
int GivType();
int GetType();
/**
* \brief makes the string corresponding to this token
*/
CBotString& GivString();
CBotString& GetString();
/**
* \brief makes the following separator token
*/
CBotString& GivSep();
CBotString& GetSep();
/**
* \brief position of the beginning in the text
*/
int GivStart();
int GetStart();
/**
* \brief end position in the text
*/
int GivEnd();
int GetEnd();
/**
* \brief gives the next token in the list
*/
CBotToken* GivNext();
CBotToken* GetNext();
/**
* \brief gives the previous token in a list
*/
CBotToken* GivPrev();
CBotToken* GetPrev();
/**
* \brief transforms the entire program
@ -997,7 +997,7 @@ public:
void SetString(const char* name);
void SetPos(int start, int end);
long GivIdKey();
long GetIdKey();
/**
* \brief adds a token (a copy)
*/
@ -1091,7 +1091,7 @@ public:
// routine that implements the GOTO (CPoint pos)
bool rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )
{
if (pVar->GivType() != CBotTypeClass ||
if (pVar->GetType() != CBotTypeClass ||
pVar->IsElemOfClas("CPoint") ) { exception = 6522; return false; )
// the parameter is not the right class?
// in fact the control is done to the routine of compilation
@ -1100,13 +1100,13 @@ bool rDoGoto( CBotVar* pVar, CBotVar* pResult, int& exception )
// or so
CBotVar* temp;
temp = pVar->GivItem("x"); // is necessary for the object of type CPoint
ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);
m_PosToGo.x = temp->GivValFloat();
temp = pVar->GetItem("x"); // is necessary for the object of type CPoint
ASSERT (temp != NULL && temp->GetType() == CBotTypFloat);
m_PosToGo.x = temp->GetValFloat();
temp = pVar->GivItem("y"); // is necessary for the object of type CPoint
ASSERT (temp != NULL && temp->GivType() == CBotTypFloat);
m_PosToGo.y = temp->GivValFloat();
temp = pVar->GetItem("y"); // is necessary for the object of type CPoint
ASSERT (temp != NULL && temp->GetType() == CBotTypFloat);
m_PosToGo.y = temp->GetValFloat();
return (m_CurentPos == m_PosToGo); // makes true if the position is reached
// returns false if one had wait yet

268
src/CBot/CBotFunction.cpp
View File

@ -77,40 +77,40 @@ bool CBotFunction::IsExtern()
bool CBotFunction::GetPosition(int& start, int& stop, CBotGet modestart, CBotGet modestop)
{
start = m_extern.GivStart();
stop = m_closeblk.GivEnd();
start = m_extern.GetStart();
stop = m_closeblk.GetEnd();
if (modestart == GetPosExtern)
{
start = m_extern.GivStart();
start = m_extern.GetStart();
}
if (modestop == GetPosExtern)
{
stop = m_extern.GivEnd();
stop = m_extern.GetEnd();
}
if (modestart == GetPosNom)
{
start = m_token.GivStart();
start = m_token.GetStart();
}
if (modestop == GetPosNom)
{
stop = m_token.GivEnd();
stop = m_token.GetEnd();
}
if (modestart == GetPosParam)
{
start = m_openpar.GivStart();
start = m_openpar.GetStart();
}
if (modestop == GetPosParam)
{
stop = m_closepar.GivEnd();
stop = m_closepar.GetEnd();
}
if (modestart == GetPosBloc)
{
start = m_openblk.GivStart();
start = m_openblk.GetStart();
}
if (modestop == GetPosBloc)
{
stop = m_closeblk.GivEnd();
stop = m_closeblk.GetEnd();
}
return true;
@ -123,7 +123,7 @@ CBotTypResult ArrayType(CBotToken* &p, CBotCStack* pile, CBotTypResult type)
{
if ( !IsOfType( p, ID_CLBRK ) )
{
pile->SetError(TX_CLBRK, p->GivStart());
pile->SetError(TX_CLBRK, p->GetStart());
return CBotTypResult( -1 );
}
type = CBotTypResult( CBotTypArrayPointer, type );
@ -135,30 +135,30 @@ CBotTypResult TypeParam(CBotToken* &p, CBotCStack* pile)
{
CBotClass* pClass = NULL;
switch (p->GivType())
switch (p->GetType())
{
case ID_INT:
p = p->GivNext();
p = p->GetNext();
return ArrayType(p, pile, CBotTypResult( CBotTypInt ));
case ID_FLOAT:
p = p->GivNext();
p = p->GetNext();
return ArrayType(p, pile, CBotTypResult( CBotTypFloat ));
case ID_BOOLEAN:
case ID_BOOL:
p = p->GivNext();
p = p->GetNext();
return ArrayType(p, pile, CBotTypResult( CBotTypBoolean ));
case ID_STRING:
p = p->GivNext();
p = p->GetNext();
return ArrayType(p, pile, CBotTypResult( CBotTypString ));
case ID_VOID:
p = p->GivNext();
p = p->GetNext();
return CBotTypResult( 0 );
case TokenTypVar:
pClass = CBotClass::Find(p);
if ( pClass != NULL)
{
p = p->GivNext();
p = p->GetNext();
return ArrayType(p, pile,
pClass->IsIntrinsic() ?
CBotTypResult( CBotTypIntrinsic, pClass ) :
@ -203,14 +203,14 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct
// CBotClass* pClass;
func->m_retTyp = TypeParam(p, pStk); // type of the result
if (func->m_retTyp.GivType() >= 0)
if (func->m_retTyp.GetType() >= 0)
{
CBotToken* pp = p;
func->m_token = *p;
if ( IsOfType(p, ID_NOT) )
{
CBotToken d("~" + p->GivString());
CBotToken d("~" + p->GetString());
func->m_token = d;
}
@ -219,7 +219,7 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct
{
if ( IsOfType( p, ID_DBLDOTS ) ) // method for a class
{
func->m_MasterClass = pp->GivString();
func->m_MasterClass = pp->GetString();
CBotClass* pClass = CBotClass::Find(pp);
if ( pClass == NULL ) goto bad;
@ -230,7 +230,7 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct
}
func->m_openpar = p;
func->m_Param = CBotDefParam::Compile( p, pStk );
func->m_closepar = p->GivPrev();
func->m_closepar = p->GetPrev();
if (pStk->IsOk())
{
pStk->SetRetType(func->m_retTyp); // for knowledge what type returns
@ -247,24 +247,24 @@ CBotFunction* CBotFunction::Compile(CBotToken* &p, CBotCStack* pStack, CBotFunct
// initialize variables acording to This
// only saves the pointer to the first,
// the rest is chained
CBotVar* pv = pThis->GivItemList();
CBotVar* pv = pThis->GetItemList();
// int num = 1;
while (pv != NULL)
{
CBotVar* pcopy = CBotVar::Create(pv);
// pcopy->SetInit(2);
pcopy->Copy(pv);
pcopy->SetPrivate(pv->GivPrivate());
// pcopy->SetUniqNum(pv->GivUniqNum()); //num++);
pcopy->SetPrivate(pv->GetPrivate());
// pcopy->SetUniqNum(pv->GetUniqNum()); //num++);
pStk->AddVar(pcopy);
pv = pv->GivNext();
pv = pv->GetNext();
}
}
// and compiles the following instruction block
func->m_openblk = p;
func->m_Block = CBotBlock::Compile(p, pStk, false);
func->m_closeblk = p->GivPrev();
func->m_closeblk = p->GetPrev();
if ( pStk->IsOk() )
{
if ( func->m_bPublic ) // public function, return known for all
@ -309,7 +309,7 @@ CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClas
func->m_retToken = *p;
func->m_retTyp = TypeParam(p, pStack); // type of the result
if (func->m_retTyp.GivType() >= 0)
if (func->m_retTyp.GetType() >= 0)
{
CBotToken* pp = p;
func->m_token = *p;
@ -318,7 +318,7 @@ CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClas
{
if ( IsOfType( p, ID_DBLDOTS ) ) // method for a class
{
func->m_MasterClass = pp->GivString();
func->m_MasterClass = pp->GetString();
CBotClass* pClass = CBotClass::Find(pp);
if ( pClass == NULL )
{
@ -344,8 +344,8 @@ CBotFunction* CBotFunction::Compile1(CBotToken* &p, CBotCStack* pStack, CBotClas
// and skips the following instruction block
do
{
int type = p->GivType();
p = p->GivNext();
int type = p->GetType();
p = p->GetNext();
if (type == ID_OPBLK) level++;
if (type == ID_CLBLK) level--;
}
@ -377,13 +377,13 @@ bool CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
pile->SetBotCall(m_pProg); // bases for routines
if ( pile->GivState() == 0 )
if ( pile->GetState() == 0 )
{
if ( !m_Param->Execute(ppVars, pile) ) return false; // define parameters
pile->IncState();
}
if ( pile->GivState() == 1 && !m_MasterClass.IsEmpty() )
if ( pile->GetState() == 1 && !m_MasterClass.IsEmpty() )
{
// makes "this" known
CBotVar* pThis ;
@ -410,7 +410,7 @@ bool CBotFunction::Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance)
if ( !m_Block->Execute(pile) )
{
if ( pile->GivError() < 0 )
if ( pile->GetError() < 0 )
pile->SetError( 0 );
else
return false;
@ -428,11 +428,11 @@ void CBotFunction::RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInst
pile->SetBotCall(m_pProg); // bases for routines
if ( pile->GivBlock() < 2 )
if ( pile->GetBlock() < 2 )
{
CBotStack* pile2 = pile->RestoreStack(NULL); // one end of stack local to this function
if ( pile2 == NULL ) return;
pile->SetState(pile->GivState() + pile2->GivState());
pile->SetState(pile->GetState() + pile2->GetState());
pile2->Delete();
}
@ -507,7 +507,7 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB
{
for ( pt = this ; pt != NULL ; pt = pt->m_next )
{
if ( pt->m_token.GivString() == name )
if ( pt->m_token.GetString() == name )
{
int i = 0;
int alpha = 0; // signature of parameters
@ -516,15 +516,15 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB
CBotVar* pw = ppVars[i++]; // provided list parameter
while ( pv != NULL && pw != NULL)
{
if (!TypesCompatibles(pv->GivTypResult(), pw->GivTypResult()))
if (!TypesCompatibles(pv->GetTypResult(), pw->GetTypResult()))
{
if ( pFunc == NULL ) TypeOrError = TX_BADPARAM;
break;
}
int d = pv->GivType() - pw->GivType(2);
int d = pv->GetType() - pw->GetType(2);
alpha += d>0 ? d : -10*d; // quality loss, 10 times more expensive!
pv = pv->GivNext();
pv = pv->GetNext();
pw = ppVars[i++];
}
if ( pw != NULL )
@ -562,7 +562,7 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB
{
for ( pt = m_listPublic ; pt != NULL ; pt = pt->m_nextpublic )
{
if ( pt->m_token.GivString() == name )
if ( pt->m_token.GetString() == name )
{
int i = 0;
int alpha = 0; // signature of parameters
@ -571,15 +571,15 @@ CBotFunction* CBotFunction::FindLocalOrPublic(long& nIdent, const char* name, CB
CBotVar* pw = ppVars[i++]; // list of provided parameters
while ( pv != NULL && pw != NULL)
{
if (!TypesCompatibles(pv->GivTypResult(), pw->GivTypResult()))
if (!TypesCompatibles(pv->GetTypResult(), pw->GetTypResult()))
{
if ( pFunc == NULL ) TypeOrError = TX_BADPARAM;
break;
}
int d = pv->GivType() - pw->GivType(2);
int d = pv->GetType() - pw->GetType(2);
alpha += d>0 ? d : -10*d; // quality loss, 10 times more expensive!
pv = pv->GivNext();
pv = pv->GetNext();
pw = ppVars[i++];
}
if ( pw != NULL )
@ -645,7 +645,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS
// preparing parameters on the stack
if ( pStk1->GivState() == 0 )
if ( pStk1->GetState() == 0 )
{
if ( !pt->m_MasterClass.IsEmpty() )
{
@ -677,13 +677,13 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotS
// finally execution of the found function
if ( !pStk3->GivRetVar( // puts the result on the stack
pt->m_Block->Execute(pStk3) )) // GivRetVar said if it is interrupted
if ( !pStk3->GetRetVar( // puts the result on the stack
pt->m_Block->Execute(pStk3) )) // GetRetVar said if it is interrupted
{
if ( !pStk3->IsOk() && pt->m_pProg != m_pProg )
{
#ifdef _DEBUG
if ( m_pProg->GivFunctions()->GivName() == "LaCommande" ) return false;
if ( m_pProg->GetFunctions()->GetName() == "LaCommande" ) return false;
#endif
pStk3->SetPosError(pToken); // indicates the error on the procedure call
}
@ -713,7 +713,7 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars,
pStk1->SetBotCall(pt->m_pProg); // it may have changed module
if ( pStk1->GivBlock() < 2 )
if ( pStk1->GetBlock() < 2 )
{
CBotStack* pStk2 = pStk1->RestoreStack(NULL); // used more
if ( pStk2 == NULL ) return;
@ -739,7 +739,7 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars,
}
}
if ( pStk1->GivState() == 0 )
if ( pStk1->GetState() == 0 )
{
pt->m_Param->RestoreState(pStk3, true);
return;
@ -759,13 +759,13 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar** ppVars,
int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken, CBotClass* pClass)
{
CBotTypResult type;
CBotProgram* pProgCurrent = pStack->GivBotCall();
CBotProgram* pProgCurrent = pStack->GetBotCall();
CBotFunction* pt = FindLocalOrPublic(nIdent, name, ppVars, type, false);
if ( pt != NULL )
{
// DEBUG( "CBotFunction::DoCall" + pt->GivName(), 0, pStack);
// DEBUG( "CBotFunction::DoCall" + pt->GetName(), 0, pStack);
CBotStack* pStk = pStack->AddStack(pt, 2);
// if ( pStk == EOX ) return true;
@ -775,7 +775,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
// preparing parameters on the stack
if ( pStk->GivState() == 0 )
if ( pStk->GetState() == 0 )
{
// sets the variable "this" on the stack
CBotVar* pthis = CBotVar::Create("this", CBotTypNullPointer);
@ -783,7 +783,7 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
pthis->SetUniqNum(-2); // special value
pStk->AddVar(pthis);
CBotClass* pClass = pThis->GivClass()->GivParent();
CBotClass* pClass = pThis->GetClass()->GetParent();
if ( pClass )
{
// sets the variable "super" on the stack
@ -797,19 +797,19 @@ int CBotFunction::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar
pStk->IncState();
}
if ( pStk->GivState() == 1 )
if ( pStk->GetState() == 1 )
{
if ( pt->m_bSynchro )
{
CBotProgram* pProgBase = pStk->GivBotCall(true);
CBotProgram* pProgBase = pStk->GetBotCall(true);
if ( !pClass->Lock(pProgBase) ) return false; // expected to power \TODO attend de pouvoir
}
pStk->IncState();
}
// finally calls the found function
if ( !pStk3->GivRetVar( // puts the result on the stack
pt->m_Block->Execute(pStk3) )) // GivRetVar said if it is interrupted
if ( !pStk3->GetRetVar( // puts the result on the stack
pt->m_Block->Execute(pStk3) )) // GetRetVar said if it is interrupted
{
if ( !pStk3->IsOk() )
{
@ -855,10 +855,10 @@ void CBotFunction::RestoreCall(long& nIdent, const char* name, CBotVar* pThis, C
pt->m_Param->RestoreState(pStk3, true); // parameters
if ( pStk->GivState() > 1 && // latching is effective?
if ( pStk->GetState() > 1 && // latching is effective?
pt->m_bSynchro )
{
CBotProgram* pProgBase = pStk->GivBotCall(true);
CBotProgram* pProgBase = pStk->GetBotCall(true);
pClass->Lock(pProgBase); // locks the class
}
@ -874,21 +874,21 @@ bool CBotFunction::CheckParam(CBotDefParam* pParam)
CBotDefParam* pp = m_Param;
while ( pp != NULL && pParam != NULL )
{
CBotTypResult type1 = pp->GivType();
CBotTypResult type2 = pParam->GivType();
CBotTypResult type1 = pp->GetType();
CBotTypResult type2 = pParam->GetType();
if ( !type1.Compare(type2) ) return false;
pp = pp->GivNext();
pParam = pParam->GivNext();
pp = pp->GetNext();
pParam = pParam->GetNext();
}
return ( pp == NULL && pParam == NULL );
}
CBotString CBotFunction::GivName()
CBotString CBotFunction::GetName()
{
return m_token.GivString();
return m_token.GetString();
}
CBotString CBotFunction::GivParams()
CBotString CBotFunction::GetParams()
{
if ( m_Param == NULL ) return CBotString("()");
@ -897,8 +897,8 @@ CBotString CBotFunction::GivParams()
while (p != NULL)
{
params += p->GivParamString();
p = p->GivNext();
params += p->GetParamString();
p = p->GetNext();
if ( p != NULL ) params += ", ";
}
@ -945,7 +945,7 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)
// mainly not pStack->TokenStack here
// declared variables must remain visible thereafter
pStack->SetStartError(p->GivStart());
pStack->SetStartError(p->GetStart());
if (IsOfType(p, ID_OPENPAR))
{
@ -958,11 +958,11 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)
else list->AddNext(param); // added to the list
CBotClass* pClass = NULL;//= CBotClass::Find(p);
param->m_typename = p->GivString();
param->m_typename = p->GetString();
CBotTypResult type = param->m_type = TypeParam(p, pStack);
// if ( type == CBotTypPointer ) type = CBotTypClass; // we must create a new object
if (param->m_type.GivType() > 0)
if (param->m_type.GetType() > 0)
{
CBotToken* pp = p;
param->m_token = *p;
@ -977,17 +977,17 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)
}
if ( type.Eq(CBotTypArrayPointer) ) type.SetType(CBotTypArrayBody);
CBotVar* var = CBotVar::Create(pp->GivString(), type); // creates the variable
CBotVar* var = CBotVar::Create(pp->GetString(), type); // creates the variable
// if ( pClass ) var->SetClass(pClass);
var->SetInit(2); // mark initialized
param->m_nIdent = CBotVar::NextUniqNum();
var->SetUniqNum(param->m_nIdent);
pStack->AddVar(var); // place on the stack
if (IsOfType(p, ID_COMMA) || p->GivType() == ID_CLOSEPAR)
if (IsOfType(p, ID_COMMA) || p->GetType() == ID_CLOSEPAR)
continue;
}
pStack->SetError(TX_CLOSEPAR, p->GivStart());
pStack->SetError(TX_CLOSEPAR, p->GetStart());
}
pStack->SetError(TX_NOTYP, p);
delete list;
@ -995,7 +995,7 @@ CBotDefParam* CBotDefParam::Compile(CBotToken* &p, CBotCStack* pStack)
}
return list;
}
pStack->SetError(TX_OPENPAR, p->GivStart());
pStack->SetError(TX_OPENPAR, p->GetStart());
return NULL;
}
@ -1016,24 +1016,24 @@ bool CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)
while ( p != NULL )
{
// creates a local variable on the stack
CBotVar* newvar = CBotVar::Create(p->m_token.GivString(), p->m_type);
CBotVar* newvar = CBotVar::Create(p->m_token.GetString(), p->m_type);
// serves to make the transformation of types:
if ( ppVars != NULL && ppVars[i] != NULL )
{
switch (p->m_type.GivType())
switch (p->m_type.GetType())
{
case CBotTypInt:
newvar->SetValInt(ppVars[i]->GivValInt());
newvar->SetValInt(ppVars[i]->GetValInt());
break;
case CBotTypFloat:
newvar->SetValFloat(ppVars[i]->GivValFloat());
newvar->SetValFloat(ppVars[i]->GetValFloat());
break;
case CBotTypString:
newvar->SetValString(ppVars[i]->GivValString());
newvar->SetValString(ppVars[i]->GetValString());
break;
case CBotTypBoolean:
newvar->SetValInt(ppVars[i]->GivValInt());
newvar->SetValInt(ppVars[i]->GetValInt());
break;
case CBotTypIntrinsic:
((CBotVarClass*)newvar)->Copy(ppVars[i], false);
@ -1041,7 +1041,7 @@ bool CBotDefParam::Execute(CBotVar** ppVars, CBotStack* &pj)
case CBotTypPointer:
case CBotTypArrayPointer:
{
newvar->SetPointer(ppVars[i]->GivPointer());
newvar->SetPointer(ppVars[i]->GetPointer());
}
break;
default:
@ -1065,35 +1065,35 @@ void CBotDefParam::RestoreState(CBotStack* &pj, bool bMain)
while ( p != NULL )
{
// creates a local variable on the stack
CBotVar* var = pj->FindVar(p->m_token.GivString());
CBotVar* var = pj->FindVar(p->m_token.GetString());
var->SetUniqNum(p->m_nIdent);
p = p->m_next;
}
}
int CBotDefParam::GivType()
int CBotDefParam::GetType()
{
return m_type.GivType();
return m_type.GetType();
}
CBotTypResult CBotDefParam::GivTypResult()
CBotTypResult CBotDefParam::GetTypResult()
{
return m_type;
}
CBotDefParam* CBotDefParam::GivNext()
CBotDefParam* CBotDefParam::GetNext()
{
return m_next;
}
CBotString CBotDefParam::GivParamString()
CBotString CBotDefParam::GetParamString()
{
CBotString param;
param = m_typename;
param += ' ';
param += m_token.GivString();
param += m_token.GetString();
return param;
}
@ -1122,9 +1122,9 @@ CBotInstr* CBotReturn::Compile(CBotToken* &p, CBotCStack* pStack)
CBotReturn* inst = new CBotReturn(); // creates the object
inst->SetToken( pp );
CBotTypResult type = pStack->GivRetType();
CBotTypResult type = pStack->GetRetType();
if ( type.GivType() == 0 ) // returned void ?
if ( type.GetType() == 0 ) // returned void ?
{
if ( IsOfType( p, ID_SEP ) ) return inst;
pStack->SetError( TX_BADTYPE, pp );
@ -1134,15 +1134,15 @@ CBotInstr* CBotReturn::Compile(CBotToken* &p, CBotCStack* pStack)
inst->m_Instr = CBotExpression::Compile(p, pStack);
if ( pStack->IsOk() )
{
CBotTypResult retType = pStack->GivTypResult(2);
CBotTypResult retType = pStack->GetTypResult(2);
if (TypeCompatible(retType, type, ID_ASS))
{
if ( IsOfType( p, ID_SEP ) )
return inst;
pStack->SetError(TX_ENDOF, p->GivStart());
pStack->SetError(TX_ENDOF, p->GetStart());
}
pStack->SetError(TX_BADTYPE, p->GivStart());
pStack->SetError(TX_BADTYPE, p->GetStart());
}
delete inst;
@ -1154,7 +1154,7 @@ bool CBotReturn::Execute(CBotStack* &pj)
CBotStack* pile = pj->AddStack(this);
// if ( pile == EOX ) return true;
if ( pile->GivState() == 0 )
if ( pile->GetState() == 0 )
{
if ( m_Instr != NULL && !m_Instr->Execute(pile) ) return false; // evaluate the result
// the result is on the stack
@ -1173,7 +1173,7 @@ void CBotReturn::RestoreState(CBotStack* &pj, bool bMain)
CBotStack* pile = pj->RestoreStack(this);
if ( pile == NULL ) return;
if ( pile->GivState() == 0 )
if ( pile->GetState() == 0 )
{
if ( m_Instr != NULL ) m_Instr->RestoreState(pile, bMain); // evaluate the result
return;
@ -1202,9 +1202,9 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
int i = 0;
CBotToken* pp = p;
p = p->GivNext();
p = p->GetNext();
pStack->SetStartError(p->GivStart());
pStack->SetStartError(p->GetStart());
CBotCStack* pile = pStack;
if ( IsOfType(p, ID_OPENPAR) )
@ -1216,11 +1216,11 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
// compile la list of parameters
if (!IsOfType(p, ID_CLOSEPAR)) while (true)
{
start = p->GivStart();
start = p->GetStart();
pile = pile->TokenStack(); // keeps the results on the stack
CBotInstr* param = CBotExpression::Compile(p, pile);
end = p->GivStart();
end = p->GetStart();
if ( inst->m_Parameters == NULL ) inst->m_Parameters = param;
else inst->m_Parameters->AddNext(param); // constructs the list
@ -1232,22 +1232,22 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
if ( param != NULL )
{
if ( pile->GivTypResult().Eq(99) )
if ( pile->GetTypResult().Eq(99) )
{
delete pStack->TokenStack();
pStack->SetError(TX_VOID, p->GivStart());
pStack->SetError(TX_VOID, p->GetStart());
delete inst;
return NULL;
}
ppVars[i] = pile->GivVar();
ppVars[i]->GivToken()->SetPos(start, end);
ppVars[i] = pile->GetVar();
ppVars[i]->GetToken()->SetPos(start, end);
i++;
if (IsOfType(p, ID_COMMA)) continue; // skips the comma
if (IsOfType(p, ID_CLOSEPAR)) break;
}
pStack->SetError(TX_CLOSEPAR, p->GivStart());
pStack->SetError(TX_CLOSEPAR, p->GetStart());
delete pStack->TokenStack();
delete inst;
return NULL;
@ -1257,17 +1257,17 @@ CBotInstr* CBotInstrCall::Compile(CBotToken* &p, CBotCStack* pStack)
// the routine is known?
// CBotClass* pClass = NULL;
inst->m_typRes = pStack->CompileCall(pp, ppVars, inst->m_nFuncIdent);
if ( inst->m_typRes.GivType() >= 20 )
if ( inst->m_typRes.GetType() >= 20 )
{
// if (pVar2!=NULL) pp = pVar2->RetToken();
pStack->SetError( inst->m_typRes.GivType(), pp );
pStack->SetError( inst->m_typRes.GetType(), pp );
delete pStack->TokenStack();
delete inst;
return NULL;
}
delete pStack->TokenStack();
if ( inst->m_typRes.GivType() > 0 )
if ( inst->m_typRes.GetType() > 0 )
{
CBotVar* pRes = CBotVar::Create("", inst->m_typRes);
pStack->SetVar(pRes); // for knowing the type of the result
@ -1298,13 +1298,13 @@ bool CBotInstrCall::Execute(CBotStack* &pj)
if ( p != NULL) while ( true )
{
pile = pile->AddStack(); // place on the stack for the results
if ( pile->GivState() == 0 )
if ( pile->GetState() == 0 )
{
if (!p->Execute(pile)) return false; // interrupted here?
pile->SetState(1); // mark as special for reknowed parameters \TODO marque spéciale pour reconnaîre parameters
}
ppVars[i++] = pile->GivVar();
p = p->GivNext();
ppVars[i++] = pile->GetVar();
p = p->GetNext();
if ( p == NULL) break;
}
ppVars[i] = NULL;
@ -1312,7 +1312,7 @@ bool CBotInstrCall::Execute(CBotStack* &pj)
CBotStack* pile2 = pile->AddStack();
if ( pile2->IfStep() ) return false;
if ( !pile2->ExecuteCall(m_nFuncIdent, GivToken(), ppVars, m_typRes)) return false; // interrupt
if ( !pile2->ExecuteCall(m_nFuncIdent, GetToken(), ppVars, m_typRes)) return false; // interrupt
return pj->Return(pile2); // release the entire stack
}
@ -1336,13 +1336,13 @@ void CBotInstrCall::RestoreState(CBotStack* &pj, bool bMain)
{
pile = pile->RestoreStack(); // place on the stack for the results
if ( pile == NULL ) return;
if ( pile->GivState() == 0 )
if ( pile->GetState() == 0 )
{
p->RestoreState(pile, bMain); // interrupt here!
return;
}
ppVars[i++] = pile->GivVar(); // constructs the list of parameters
p = p->GivNext();
ppVars[i++] = pile->GetVar(); // constructs the list of parameters
p = p->GetNext();
if ( p == NULL) break;
}
ppVars[i] = NULL;
@ -1350,7 +1350,7 @@ void CBotInstrCall::RestoreState(CBotStack* &pj, bool bMain)
CBotStack* pile2 = pile->RestoreStack();
if ( pile2 == NULL ) return;
pile2->RestoreCall(m_nFuncIdent, GivToken(), ppVars);
pile2->RestoreCall(m_nFuncIdent, GetToken(), ppVars);
}
//////////////////////////////////////////////////////////////////////////////
@ -1369,7 +1369,7 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
if ( !IsOfType(p, ID_CLASS) ) return NULL;
CBotString name = p->GivString();
CBotString name = p->GetString();
CBotClass* pOld = CBotClass::Find(name);
if ( pOld != NULL && pOld->m_IsDef )
@ -1384,7 +1384,7 @@ CBotClass* CBotClass::Compile1(CBotToken* &p, CBotCStack* pStack)
CBotClass* pPapa = NULL;
if ( IsOfType( p, ID_EXTENDS ) )
{
CBotString name = p->GivString();
CBotString name = p->GetString();
pPapa = CBotClass::Find(name);
if (!IsOfType(p, TokenTypVar) || pPapa == NULL )
@ -1454,7 +1454,7 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
{
CBotInstr* i = NULL;
if ( p->GivType() != ID_CLBRK )
if ( p->GetType() != ID_CLBRK )
i = CBotExpression::Compile( p, pStack ); // expression for the value
else
i = new CBotEmpty(); // special if not a formula
@ -1463,14 +1463,14 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
if (!pStack->IsOk() || !IsOfType( p, ID_CLBRK ) )
{
pStack->SetError(TX_CLBRK, p->GivStart());
pStack->SetError(TX_CLBRK, p->GetStart());
return false;
}
/* CBotVar* pv = pStack->GivVar();
if ( pv->GivType()>= CBotTypBoolean )
/* CBotVar* pv = pStack->GetVar();
if ( pv->GetType()>= CBotTypBoolean )
{
pStack->SetError(TX_BADTYPE, p->GivStart());
pStack->SetError(TX_BADTYPE, p->GetStart());
return false;
}*/
@ -1478,7 +1478,7 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
else limites->AddNext3(i);
}
if ( p->GivType() == ID_OPENPAR )
if ( p->GetType() == ID_OPENPAR )
{
if ( !bSecond )
{
@ -1498,12 +1498,12 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
CBotFunction* prev = NULL;
while ( pf != NULL )
{
if (pf->GivName() == pp->GivString()) break;
if (pf->GetName() == pp->GetString()) break;
prev = pf;
pf = pf->Next();
}
bool bConstructor = (pp->GivString() == GivName());
bool bConstructor = (pp->GetString() == GetName());
CBotCStack* pile = pStack->TokenStack(NULL, true);
// make "this" known
@ -1531,9 +1531,9 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
{
CBotVar* pcopy = CBotVar::Create(pv);
pcopy->SetInit(!bConstructor || pv->IsStatic());
pcopy->SetUniqNum(pv->GivUniqNum());
pcopy->SetUniqNum(pv->GetUniqNum());
pile->AddVar(pcopy);
pv = pv->GivNext();
pv = pv->GetNext();
}
my = my->m_pParent;
}
@ -1545,7 +1545,7 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
if ( f != NULL )
{
f->m_pProg = pStack->GivBotCall();
f->m_pProg = pStack->GetBotCall();
f->m_bSynchro = bSynchro;
// replaces the element in the chain
f->m_next = pf->m_next;
@ -1572,7 +1572,7 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
{
if ( type.Eq(CBotTypArrayPointer) )
{
i = CBotListArray::Compile(p, pStack, type.GivTypElem());
i = CBotListArray::Compile(p, pStack, type.GetTypElem());
}
else
{
@ -1585,7 +1585,7 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
if ( !bSecond )
{
CBotVar* pv = CBotVar::Create(pp->GivString(), type);
CBotVar* pv = CBotVar::Create(pp->GetString(), type);
pv -> SetStatic( bStatic );
pv -> SetPrivate( mProtect );
@ -1599,7 +1599,7 @@ bool CBotClass::CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond)
{
CBotStack* pile = CBotStack::FirstStack(); // independent stack
while(pile->IsOk() && !pv->m_InitExpr->Execute(pile)); // evaluates the expression without timer
pv->SetVal( pile->GivVar() ) ;
pv->SetVal( pile->GetVar() ) ;
pile->Delete();
}
}
@ -1620,7 +1620,7 @@ CBotClass* CBotClass::Compile(CBotToken* &p, CBotCStack* pStack)
if ( !IsOfType(p, ID_PUBLIC) ) return NULL;
if ( !IsOfType(p, ID_CLASS) ) return NULL;
CBotString name = p->GivString();
CBotString name = p->GetString();
// a name for the class is there?
if (IsOfType(p, TokenTypVar))

8
src/CBot/CBotIf.cpp
View File

@ -95,7 +95,7 @@ bool CBotIf :: Execute(CBotStack* &pj)
if ( pile->IfStep() ) return false;
// according to recovery, it may be in one of two states
if( pile->GivState() == 0 )
if( pile->GetState() == 0 )
{
// evaluates the condition
if ( !m_Condition->Execute(pile) ) return false; // interrupted here?
@ -113,7 +113,7 @@ bool CBotIf :: Execute(CBotStack* &pj)
// second state, evaluates the associated instructions
// the result of the condition is on the stack
if ( pile->GivVal() == true ) // condition was true?
if ( pile->GetVal() == true ) // condition was true?
{
if ( m_Block != NULL && // block may be absent
!m_Block->Execute(pile) ) return false; // interrupted here?
@ -137,7 +137,7 @@ void CBotIf :: RestoreState(CBotStack* &pj, bool bMain)
if ( pile == NULL ) return;
// according to recovery, it may be in one of two states
if( pile->GivState() == 0 )
if( pile->GetState() == 0 )
{
// evaluates the condition
m_Condition->RestoreState(pile, bMain); // interrupted here!
@ -147,7 +147,7 @@ void CBotIf :: RestoreState(CBotStack* &pj, bool bMain)
// second state, evaluates the associated instructions
// the result of the condition is on the stack
if ( pile->GivVal() == true ) // condition was true?
if ( pile->GetVal() == true ) // condition was true?
{
if ( m_Block != NULL ) // block may be absent
m_Block->RestoreState(pile, bMain); // interrupted here!

102
src/CBot/CBotProgram.cpp
View File

@ -87,18 +87,18 @@ bool CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
CBotCStack* pStack = new CBotCStack(NULL);
CBotToken* p = pBaseToken->GivNext(); // skips the first token (separator)
CBotToken* p = pBaseToken->GetNext(); // skips the first token (separator)
pStack->SetBotCall(this); // defined used routines
CBotCall::SetPUser(pUser);
// first made a quick pass just to take the headers of routines and classes
while ( pStack->IsOk() && p != NULL && p->GivType() != 0)
while ( pStack->IsOk() && p != NULL && p->GetType() != 0)
{
if ( IsOfType(p, ID_SEP) ) continue; // semicolons lurking
if ( p->GivType() == ID_CLASS ||
( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS ))
if ( p->GetType() == ID_CLASS ||
( p->GetType() == ID_PUBLIC && p->GetNext()->GetType() == ID_CLASS ))
{
CBotClass* nxt = CBotClass::Compile1(p, pStack);
if (m_pClass == NULL ) m_pClass = nxt;
@ -113,7 +113,7 @@ bool CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
}
if ( !pStack->IsOk() )
{
m_ErrorCode = pStack->GivError(m_ErrorStart, m_ErrorEnd);
m_ErrorCode = pStack->GetError(m_ErrorStart, m_ErrorEnd);
delete m_Prog;
m_Prog = NULL;
delete pBaseToken;
@ -123,14 +123,14 @@ bool CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
// CBotFunction* temp = NULL;
CBotFunction* next = m_Prog; // rewind the list
p = pBaseToken->GivNext(); // returns to the beginning
p = pBaseToken->GetNext(); // returns to the beginning
while ( pStack->IsOk() && p != NULL && p->GivType() != 0 )
while ( pStack->IsOk() && p != NULL && p->GetType() != 0 )
{
if ( IsOfType(p, ID_SEP) ) continue; // semicolons lurking
if ( p->GivType() == ID_CLASS ||
( p->GivType() == ID_PUBLIC && p->GivNext()->GivType() == ID_CLASS ))
if ( p->GetType() == ID_CLASS ||
( p->GetType() == ID_PUBLIC && p->GetNext()->GetType() == ID_CLASS ))
{
m_bCompileClass = true;
CBotClass::Compile(p, pStack); // completes the definition of the class
@ -139,7 +139,7 @@ bool CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
{
m_bCompileClass = false;
CBotFunction::Compile(p, pStack, next);
if (next->IsExtern()) ListFonctions.Add(next->GivName()/* + next->GivParams()*/);
if (next->IsExtern()) ListFonctions.Add(next->GetName()/* + next->GetParams()*/);
next->m_pProg = this; // keeps pointers to the module
next = next->Next();
}
@ -150,7 +150,7 @@ bool CBotProgram::Compile( const char* program, CBotStringArray& ListFonctions,
if ( !pStack->IsOk() )
{
m_ErrorCode = pStack->GivError(m_ErrorStart, m_ErrorEnd);
m_ErrorCode = pStack->GetError(m_ErrorStart, m_ErrorEnd);
delete m_Prog;
m_Prog = NULL;
}
@ -174,7 +174,7 @@ bool CBotProgram::Start(const char* name)
m_pRun = m_Prog;
while (m_pRun != NULL)
{
if ( m_pRun->GivName() == name ) break;
if ( m_pRun->GetName() == name ) break;
m_pRun = m_pRun->m_next;
}
@ -200,7 +200,7 @@ bool CBotProgram::GetPosition(const char* name, int& start, int& stop, CBotGet m
CBotFunction* p = m_Prog;
while (p != NULL)
{
if ( p->GivName() == name ) break;
if ( p->GetName() == name ) break;
p = p->m_next;
}
@ -248,7 +248,7 @@ bool CBotProgram::Run(void* pUser, int timer)
// completed on a mistake?
if (!ok && !m_pStack->IsOk())
{
m_ErrorCode = m_pStack->GivError(m_ErrorStart, m_ErrorEnd);
m_ErrorCode = m_pStack->GetError(m_ErrorStart, m_ErrorEnd);
#if STACKMEM
m_pStack->Delete();
#else
@ -289,12 +289,12 @@ bool CBotProgram::GetRunPos(const char* &FunctionName, int &start, int &end)
return true;
}
CBotVar* CBotProgram::GivStackVars(const char* &FunctionName, int level)
CBotVar* CBotProgram::GetStackVars(const char* &FunctionName, int level)
{
FunctionName = NULL;
if (m_pStack == NULL) return NULL;
return m_pStack->GivStackVars(FunctionName, level);
return m_pStack->GetStackVars(FunctionName, level);
}
void CBotProgram::SetTimer(int n)
@ -302,7 +302,7 @@ void CBotProgram::SetTimer(int n)
CBotStack::SetTimer( n );
}
int CBotProgram::GivError()
int CBotProgram::GetError()
{
return m_ErrorCode;
}
@ -312,7 +312,7 @@ void CBotProgram::SetIdent(long n)
m_Ident = n;
}
long CBotProgram::GivIdent()
long CBotProgram::GetIdent()
{
return m_Ident;
}
@ -334,7 +334,7 @@ bool CBotProgram::GetError(int& code, int& start, int& end, CBotProgram* &pProg)
return code > 0;
}
CBotString CBotProgram::GivErrorText(int code)
CBotString CBotProgram::GetErrorText(int code)
{
CBotString TextError;
@ -349,7 +349,7 @@ CBotString CBotProgram::GivErrorText(int code)
}
CBotFunction* CBotProgram::GivFunctions()
CBotFunction* CBotProgram::GetFunctions()
{
return m_Prog;
}
@ -421,7 +421,7 @@ bool WriteString(FILE* pf, CBotString s)
{
size_t lg1, lg2;
lg1 = s.GivLength();
lg1 = s.GetLength();
if (!WriteWord(pf, lg1)) return false;
lg2 = fwrite(s, 1, lg1, pf );
@ -445,19 +445,19 @@ bool ReadString(FILE* pf, CBotString& s)
bool WriteType(FILE* pf, CBotTypResult type)
{
int typ = type.GivType();
int typ = type.GetType();
if ( typ == CBotTypIntrinsic ) typ = CBotTypClass;
if ( !WriteWord(pf, typ) ) return false;
if ( typ == CBotTypClass )
{
CBotClass* p = type.GivClass();
if ( !WriteString(pf, p->GivName()) ) return false;
CBotClass* p = type.GetClass();
if ( !WriteString(pf, p->GetName()) ) return false;
}
if ( type.Eq( CBotTypArrayBody ) ||
type.Eq( CBotTypArrayPointer ) )
{
if ( !WriteWord(pf, type.GivLimite()) ) return false;
if ( !WriteType(pf, type.GivTypElem()) ) return false;
if ( !WriteWord(pf, type.GetLimite()) ) return false;
if ( !WriteType(pf, type.GetTypElem()) ) return false;
}
return true;
}
@ -507,7 +507,7 @@ bool CBotProgram::SaveState(FILE* pf)
if ( m_pStack != NULL )
{
if (!WriteWord( pf, 1)) return false;
if (!WriteString( pf, m_pRun->GivName() )) return false;
if (!WriteString( pf, m_pRun->GetName() )) return false;
if (!m_pStack->SaveState(pf)) return false;
}
else
@ -551,7 +551,7 @@ bool CBotProgram::RestoreState(FILE* pf)
return true;
}
int CBotProgram::GivVersion()
int CBotProgram::GetVersion()
{
return CBOTVERSION;
}
@ -592,7 +592,7 @@ bool CBotCall::AddFunction(const char* name,
if ( p != NULL ) while ( p->m_next != NULL )
{
if ( p->GivName() == name )
if ( p->GetName() == name )
{
// frees redefined function
if ( pp ) pp->m_next = p->m_next;
@ -631,8 +631,8 @@ CBotVar* MakeListVars(CBotVar** ppVars, bool bSetVal=false)
CBotVar* pp = CBotVar::Create(ppVars[i]);
if (bSetVal) pp->Copy(ppVars[i]);
else
if ( ppVars[i]->GivType() == CBotTypPointer )
pp->SetClass( ppVars[i]->GivClass());
if ( ppVars[i]->GetType() == CBotTypPointer )
pp->SetClass( ppVars[i]->GetClass());
// copy the pointer according to indirections
if (pVar == NULL) pVar = pp;
else pVar->AddNext(pp);
@ -648,7 +648,7 @@ CBotTypResult CBotCall::CompileCall(CBotToken* &p, CBotVar** ppVar, CBotCStack*
{
nIdent = 0;
CBotCall* pt = m_ListCalls;
CBotString name = p->GivString();
CBotString name = p->GetString();
while ( pt != NULL )
{
@ -657,14 +657,14 @@ CBotTypResult CBotCall::CompileCall(CBotToken* &p, CBotVar** ppVar, CBotCStack*
CBotVar* pVar = MakeListVars(ppVar);
CBotVar* pVar2 = pVar;
CBotTypResult r = pt->m_rComp(pVar2, m_pUser);
int ret = r.GivType();
int ret = r.GetType();
// if a class is returned, it is actually a pointer
if ( ret == CBotTypClass ) r.SetType( ret = CBotTypPointer );
if ( ret > 20 )
{
if (pVar2) pStack->SetError(ret, p /*pVar2->GivToken()*/ );
if (pVar2) pStack->SetError(ret, p /*pVar2->GetToken()*/ );
}
delete pVar;
nIdent = pt->m_nFuncIdent;
@ -688,7 +688,7 @@ bool CBotCall::CheckCall(const char* name)
while ( p != NULL )
{
if ( name == p->GivName() ) return true;
if ( name == p->GetName() ) return true;
p = p->m_next;
}
return false;
@ -696,7 +696,7 @@ bool CBotCall::CheckCall(const char* name)
CBotString CBotCall::GivName()
CBotString CBotCall::GetName()
{
return m_name;
}
@ -724,7 +724,7 @@ int CBotCall::DoCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack*
if ( token != NULL )
{
CBotString name = token->GivString();
CBotString name = token->GetString();
while ( pt != NULL )
{
if ( pt->m_name == name )
@ -750,7 +750,7 @@ fund:
CBotVar* pRes = pResult;
int Exception = 0;
int res = pt->m_rExec(pVar, pResult, Exception, pStack->GivPUser());
int res = pt->m_rExec(pVar, pResult, Exception, pStack->GetPUser());
if ( pResult != pRes ) delete pRes; // different result if made
delete pVarToDelete;
@ -766,7 +766,7 @@ fund:
}
pStack->SetVar(pResult);
if ( rettype.GivType() > 0 && pResult == NULL )
if ( rettype.GetType() > 0 && pResult == NULL )
{
pStack->SetError(TX_NORETVAL, token);
}
@ -805,7 +805,7 @@ bool CBotCall::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBot
CBotCall* pt = m_ListCalls;
{
CBotString name = token->GivString();
CBotString name = token->GetString();
while ( pt != NULL )
{
if ( pt->m_name == name )
@ -829,14 +829,14 @@ bool CBotCall::Run(CBotStack* pStack)
{
CBotStack* pile = pStack->AddStackEOX(this);
if ( pile == EOX ) return true;
CBotVar* pVar = pile->GivVar();
CBotVar* pVar = pile->GetVar();
CBotStack* pile2 = pile->AddStack();
CBotVar* pResult = pile2->GivVar();
CBotVar* pResult = pile2->GetVar();
CBotVar* pRes = pResult;
int Exception = 0;
int res = m_rExec(pVar, pResult, Exception, pStack->GivPUser());
int res = m_rExec(pVar, pResult, Exception, pStack->GetPUser());
if (res == false)
{
@ -892,10 +892,10 @@ CBotTypResult CBotCallMethode::CompileCall(const char* name, CBotVar* pThis,
CBotVar* pVar = MakeListVars(ppVar, true);
CBotVar* pVar2 = pVar;
CBotTypResult r = pt->m_rComp(pThis, pVar2);
int ret = r.GivType();
int ret = r.GetType();
if ( ret > 20 )
{
if (pVar2) pStack->SetError(ret, pVar2->GivToken());
if (pVar2) pStack->SetError(ret, pVar2->GetToken());
}
delete pVar;
nIdent = pt->m_nFuncIdent;
@ -907,7 +907,7 @@ CBotTypResult CBotCallMethode::CompileCall(const char* name, CBotVar* pThis,
}
CBotString CBotCallMethode::GivName()
CBotString CBotCallMethode::GetName()
{
return m_name;
}
@ -951,7 +951,7 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
{
if (Exception!=0)
{
// pStack->SetError(Exception, pVar->GivToken());
// pStack->SetError(Exception, pVar->GetToken());
pStack->SetError(Exception, pToken);
}
delete pVarToDelete;
@ -982,7 +982,7 @@ int CBotCallMethode::DoCall(long& nIdent, const char* name, CBotVar* pThis, CBot
{
if (Exception!=0)
{
// pStack->SetError(Exception, pVar->GivToken());
// pStack->SetError(Exception, pVar->GetToken());
pStack->SetError(Exception, pToken);
}
delete pVarToDelete;
@ -1003,12 +1003,12 @@ bool rSizeOf( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
if ( pVar == NULL ) return TX_LOWPARAM;
int i = 0;
pVar = pVar->GivItemList();
pVar = pVar->GetItemList();
while ( pVar != NULL )
{
i++;
pVar = pVar->GivNext();
pVar = pVar->GetNext();
}
pResult->SetValInt(i);
@ -1018,7 +1018,7 @@ bool rSizeOf( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
CBotTypResult cSizeOf( CBotVar* &pVar, void* pUser )
{
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
if ( pVar->GivType() != CBotTypArrayPointer )
if ( pVar->GetType() != CBotTypArrayPointer )
return CBotTypResult( TX_BADPARAM );
return CBotTypResult( CBotTypInt );
}

152
src/CBot/CBotStack.cpp
View File

@ -198,7 +198,7 @@ CBotStack* CBotStack::AddStack2(bool bBlock)
return p;
}
bool CBotStack::GivBlock()
bool CBotStack::GetBlock()
{
return m_bBlock;
}
@ -428,7 +428,7 @@ void CBotStack::SetBreak(int val, const char* name)
// gives on the stack value calculated by the last CBotReturn
bool CBotStack::GivRetVar(bool bRet)
bool CBotStack::GetRetVar(bool bRet)
{
if (m_error == -3)
{
@ -441,7 +441,7 @@ bool CBotStack::GivRetVar(bool bRet)
return bRet; // interrupted by something other than return
}
int CBotStack::GivError(int& start, int& end)
int CBotStack::GetError(int& start, int& end)
{
start = m_start;
end = m_end;
@ -449,16 +449,16 @@ int CBotStack::GivError(int& start, int& end)
}
int CBotStack::GivType(int mode)
int CBotStack::GetType(int mode)
{
if (m_var == NULL) return -1;
return m_var->GivType(mode);
return m_var->GetType(mode);
}
CBotTypResult CBotStack::GivTypResult(int mode)
CBotTypResult CBotStack::GetTypResult(int mode)
{
if (m_var == NULL) return -1;
return m_var->GivTypResult(mode);
return m_var->GetTypResult(mode);
}
void CBotStack::SetType(CBotTypResult& type)
@ -471,14 +471,14 @@ void CBotStack::SetType(CBotTypResult& type)
CBotVar* CBotStack::FindVar(CBotToken* &pToken, bool bUpdate, bool bModif)
{
CBotStack* p = this;
CBotString name = pToken->GivString();
CBotString name = pToken->GetString();
while (p != NULL)
{
CBotVar* pp = p->m_listVar;
while ( pp != NULL)
{
if (pp->GivName() == name)
if (pp->GetName() == name)
{
if ( bUpdate )
pp->Maj(m_pUser, false);
@ -500,7 +500,7 @@ CBotVar* CBotStack::FindVar(const char* name)
CBotVar* pp = p->m_listVar;
while ( pp != NULL)
{
if (pp->GivName() == name)
if (pp->GetName() == name)
{
return pp;
}
@ -519,7 +519,7 @@ CBotVar* CBotStack::FindVar(long ident, bool bUpdate, bool bModif)
CBotVar* pp = p->m_listVar;
while ( pp != NULL)
{
if (pp->GivUniqNum() == ident)
if (pp->GetUniqNum() == ident)
{
if ( bUpdate )
pp->Maj(m_pUser, false);
@ -576,8 +576,8 @@ void CBotStack::SetError(int n, CBotToken* token)
m_error = n;
if (token != NULL)
{
m_start = token->GivStart();
m_end = token->GivEnd();
m_start = token->GetStart();
m_end = token->GetEnd();
}
}
@ -590,8 +590,8 @@ void CBotStack::ResetError(int n, int start, int end)
void CBotStack::SetPosError(CBotToken* token)
{
m_start = token->GivStart();
m_end = token->GivEnd();
m_start = token->GetStart();
m_end = token->GetEnd();
}
void CBotStack::SetTimer(int n)
@ -643,34 +643,34 @@ void CBotStack::SetCopyVar( CBotVar* var )
{
if (m_var) delete m_var; // replacement of a variable
m_var = CBotVar::Create("", var->GivTypResult(2));
m_var = CBotVar::Create("", var->GetTypResult(2));
m_var->Copy( var );
}
CBotVar* CBotStack::GivVar()
CBotVar* CBotStack::GetVar()
{
return m_var;
}
CBotVar* CBotStack::GivPtVar()
CBotVar* CBotStack::GetPtVar()
{
CBotVar* p = m_var;
m_var = NULL; // therefore will not be destroyed
return p;
}
CBotVar* CBotStack::GivCopyVar()
CBotVar* CBotStack::GetCopyVar()
{
if (m_var == NULL) return NULL;
CBotVar* v = CBotVar::Create("", m_var->GivType());
CBotVar* v = CBotVar::Create("", m_var->GetType());
v->Copy( m_var );
return v;
}
long CBotStack::GivVal()
long CBotStack::GetVal()
{
if (m_var == NULL) return 0;
return m_var->GivValInt();
return m_var->GetValInt();
}
@ -693,7 +693,7 @@ void CBotStack::AddVar(CBotVar* pVar)
*pp = pVar; // added after
#ifdef _DEBUG
if ( pVar->GivUniqNum() == 0 ) ASM_TRAP();
if ( pVar->GetUniqNum() == 0 ) ASM_TRAP();
#endif
}
@ -710,7 +710,7 @@ void CBotStack::SetBotCall(CBotProgram* p)
m_bFunc = true;
}
CBotProgram* CBotStack::GivBotCall(bool bFirst)
CBotProgram* CBotStack::GetBotCall(bool bFirst)
{
if ( ! bFirst ) return m_prog;
CBotStack* p = this;
@ -718,7 +718,7 @@ CBotProgram* CBotStack::GivBotCall(bool bFirst)
return p->m_prog;
}
void* CBotStack::GivPUser()
void* CBotStack::GetPUser()
{
return m_pUser;
}
@ -731,19 +731,19 @@ bool CBotStack::ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBo
// first looks by the identifier
res = CBotCall::DoCall(nIdent, NULL, ppVar, this, rettype );
if (res.GivType() >= 0) return res.GivType();
if (res.GetType() >= 0) return res.GetType();
res = m_prog->GivFunctions()->DoCall(nIdent, NULL, ppVar, this, token );
if (res.GivType() >= 0) return res.GivType();
res = m_prog->GetFunctions()->DoCall(nIdent, NULL, ppVar, this, token );
if (res.GetType() >= 0) return res.GetType();
// if not found (recompile?) seeks by name
nIdent = 0;
res = CBotCall::DoCall(nIdent, token, ppVar, this, rettype );
if (res.GivType() >= 0) return res.GivType();
if (res.GetType() >= 0) return res.GetType();
res = m_prog->GivFunctions()->DoCall(nIdent, token->GivString(), ppVar, this, token );
if (res.GivType() >= 0) return res.GivType();
res = m_prog->GetFunctions()->DoCall(nIdent, token->GetString(), ppVar, this, token );
if (res.GetType() >= 0) return res.GetType();
SetError(TX_NOCALL, token);
return true;
@ -754,7 +754,7 @@ void CBotStack::RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar)
if ( m_next == NULL ) return;
if ( !CBotCall::RestoreCall(nIdent, token, ppVar, this) )
m_prog->GivFunctions()->RestoreCall(nIdent, token->GivString(), ppVar, this );
m_prog->GetFunctions()->RestoreCall(nIdent, token->GetString(), ppVar, this );
}
@ -770,7 +770,7 @@ bool SaveVar(FILE* pf, CBotVar* pVar)
if ( !pVar->Save0State(pf)) return false; // common header
if ( !pVar->Save1State(pf) ) return false; // saves as the child class
pVar = pVar->GivNext();
pVar = pVar->GetNext();
}
}
@ -798,17 +798,17 @@ void CBotStack::GetRunPos(const char* &FunctionName, int &start, int &end)
if ( funct == NULL ) return;
CBotToken* t = funct->GivToken();
FunctionName = t->GivString();
CBotToken* t = funct->GetToken();
FunctionName = t->GetString();
// if ( p->m_instr != NULL ) instr = p->m_instr;
t = instr->GivToken();
start = t->GivStart();
end = t->GivEnd();
t = instr->GetToken();
start = t->GetStart();
end = t->GetEnd();
}
CBotVar* CBotStack::GivStackVars(const char* &FunctionName, int level)
CBotVar* CBotStack::GetStackVars(const char* &FunctionName, int level)
{
CBotProgram* prog = m_prog; // current program
FunctionName = NULL;
@ -846,8 +846,8 @@ CBotVar* CBotStack::GivStackVars(const char* &FunctionName, int level)
if ( pp == NULL || pp->m_instr == NULL ) return NULL;
CBotToken* t = pp->m_instr->GivToken();
FunctionName = t->GivString();
CBotToken* t = pp->m_instr->GetToken();
FunctionName = t->GetString();
return p->m_listVar;
}
@ -924,9 +924,9 @@ bool CBotVar::Save0State(FILE* pf)
{
if (!WriteWord(pf, 100+m_mPrivate))return false; // private variable?
if (!WriteWord(pf, m_bStatic))return false; // static variable?
if (!WriteWord(pf, m_type.GivType()))return false; // saves the type (always non-zero)
if (!WriteWord(pf, m_type.GetType()))return false; // saves the type (always non-zero)
if (!WriteWord(pf, m_binit))return false; // variable defined?
return WriteString(pf, m_token->GivString()); // and variable name
return WriteString(pf, m_token->GetString()); // and variable name
}
bool CBotVarInt::Save0State(FILE* pf)
@ -1160,7 +1160,7 @@ CBotCStack* CBotCStack::TokenStack(CBotToken* pToken, bool bBlock)
m_next = p; // channel element
p->m_bBlock = bBlock;
if (pToken != NULL) p->SetStartError(pToken->GivStart());
if (pToken != NULL) p->SetStartError(pToken->GetStart());
return p;
}
@ -1200,42 +1200,42 @@ CBotFunction* CBotCStack::ReturnFunc(CBotFunction* inst, CBotCStack* pfils)
return inst;
}
int CBotCStack::GivError(int& start, int& end)
int CBotCStack::GetError(int& start, int& end)
{
start = m_start;
end = m_end;
return m_error;
}
int CBotCStack::GivError()
int CBotCStack::GetError()
{
return m_error;
}
// type of instruction on the stack
CBotTypResult CBotCStack::GivTypResult(int mode)
CBotTypResult CBotCStack::GetTypResult(int mode)
{
if (m_var == NULL)
return CBotTypResult(99);
return m_var->GivTypResult(mode);
return m_var->GetTypResult(mode);
}
// type of instruction on the stack
int CBotCStack::GivType(int mode)
int CBotCStack::GetType(int mode)
{
if (m_var == NULL)
return 99;
return m_var->GivType(mode);
return m_var->GetType(mode);
}
// pointer on the stack is in what class?
CBotClass* CBotCStack::GivClass()
CBotClass* CBotCStack::GetClass()
{
if ( m_var == NULL )
return NULL;
if ( m_var->GivType(1) != CBotTypPointer ) return NULL;
if ( m_var->GetType(1) != CBotTypPointer ) return NULL;
return m_var->GivClass();
return m_var->GetClass();
}
// type of instruction on the stack
@ -1252,14 +1252,14 @@ void CBotCStack::SetType(CBotTypResult& type)
CBotVar* CBotCStack::FindVar(CBotToken* &pToken)
{
CBotCStack* p = this;
CBotString name = pToken->GivString();
CBotString name = pToken->GetString();
while (p != NULL)
{
CBotVar* pp = p->m_listVar;
while ( pp != NULL)
{
if (name == pp->GivName())
if (name == pp->GetName())
{
return pp;
}
@ -1282,7 +1282,7 @@ CBotVar* CBotCStack::CopyVar(CBotToken& Token)
if ( pVar == NULL) return NULL;
CBotVar* pCopy = CBotVar::Create( "", pVar->GivType() );
CBotVar* pCopy = CBotVar::Create( "", pVar->GetType() );
pCopy->Copy(pVar);
return pCopy;
}
@ -1310,8 +1310,8 @@ void CBotCStack::SetError(int n, CBotToken* p)
{
if (m_error) return; // does not change existing error
m_error = n;
m_start = p->GivStart();
m_end = p->GivEnd();
m_start = p->GetStart();
m_end = p->GetEnd();
}
void CBotCStack::ResetError(int n, int start, int end)
@ -1325,10 +1325,10 @@ bool CBotCStack::NextToken(CBotToken* &p)
{
CBotToken* pp = p;
p = p->GivNext();
p = p->GetNext();
if (p!=NULL) return true;
SetError(TX_ENDOF, pp->GivEnd());
SetError(TX_ENDOF, pp->GetEnd());
return false;
}
@ -1337,7 +1337,7 @@ void CBotCStack::SetBotCall(CBotProgram* p)
m_prog = p;
}
CBotProgram* CBotCStack::GivBotCall()
CBotProgram* CBotCStack::GetBotCall()
{
return m_prog;
}
@ -1347,7 +1347,7 @@ void CBotCStack::SetRetType(CBotTypResult& type)
m_retTyp = type;
}
CBotTypResult CBotCStack::GivRetType()
CBotTypResult CBotCStack::GetRetType()
{
return m_retTyp;
}
@ -1364,11 +1364,11 @@ void CBotCStack::SetCopyVar( CBotVar* var )
if (m_var) delete m_var; // replacement of a variable
if ( var == NULL ) return;
m_var = CBotVar::Create("", var->GivTypResult(2));
m_var = CBotVar::Create("", var->GetTypResult(2));
m_var->Copy( var );
}
CBotVar* CBotCStack::GivVar()
CBotVar* CBotCStack::GetVar()
{
return m_var;
}
@ -1388,7 +1388,7 @@ void CBotCStack::AddVar(CBotVar* pVar)
*pp = pVar; // added after
#ifdef _DEBUG
if ( pVar->GivUniqNum() == 0 ) ASM_TRAP();
if ( pVar->GetUniqNum() == 0 ) ASM_TRAP();
#endif
}
@ -1397,14 +1397,14 @@ void CBotCStack::AddVar(CBotVar* pVar)
bool CBotCStack::CheckVarLocal(CBotToken* &pToken)
{
CBotCStack* p = this;
CBotString name = pToken->GivString();
CBotString name = pToken->GetString();
while (p != NULL)
{
CBotVar* pp = p->m_listVar;
while ( pp != NULL)
{
if (name == pp->GivName())
if (name == pp->GetName())
return true;
pp = pp->m_next;
}
@ -1420,14 +1420,14 @@ CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nId
CBotTypResult val(-1);
val = CBotCall::CompileCall(p, ppVars, this, nIdent);
if (val.GivType() < 0)
if (val.GetType() < 0)
{
val = m_prog->GivFunctions()->CompileCall(p->GivString(), ppVars, nIdent);
if ( val.GivType() < 0 )
val = m_prog->GetFunctions()->CompileCall(p->GetString(), ppVars, nIdent);
if ( val.GetType() < 0 )
{
// pVar = NULL; // the error is not on a particular parameter
SetError( -val.GivType(), p );
val.SetType(-val.GivType());
SetError( -val.GetType(), p );
val.SetType(-val.GetType());
return val;
}
}
@ -1438,14 +1438,14 @@ CBotTypResult CBotCStack::CompileCall(CBotToken* &p, CBotVar** ppVars, long& nId
bool CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
{
CBotString name = pToken->GivString();
CBotString name = pToken->GetString();
if ( CBotCall::CheckCall(name) ) return true;
CBotFunction* pp = m_prog->GivFunctions();
CBotFunction* pp = m_prog->GetFunctions();
while ( pp != NULL )
{
if ( pToken->GivString() == pp->GivName() )
if ( pToken->GetString() == pp->GetName() )
{
// are parameters exactly the same?
if ( pp->CheckParam( pParam ) )
@ -1457,7 +1457,7 @@ bool CBotCStack::CheckCall(CBotToken* &pToken, CBotDefParam* pParam)
pp = CBotFunction::m_listPublic;
while ( pp != NULL )
{
if ( pToken->GivString() == pp->GivName() )
if ( pToken->GetString() == pp->GetName() )
{
// are parameters exactly the same?
if ( pp->CheckParam( pParam ) )

18
src/CBot/CBotString.cpp
View File

@ -138,7 +138,7 @@ CBotString::CBotString(const char* p)
m_ptr = NULL;
if (m_lg>0)
{
m_ptr = (char*)malloc(m_lg+1);
m_ptr = static_cast<char*>(malloc(m_lg+1));
strcpy(m_ptr, p);
}
}
@ -150,7 +150,7 @@ CBotString::CBotString(const CBotString& srcString)
m_ptr = NULL;
if (m_lg>0)
{
m_ptr = (char*)malloc(m_lg+1);
m_ptr = static_cast<char*>(malloc(m_lg+1));
strcpy(m_ptr, srcString.m_ptr);
}
}
@ -158,7 +158,7 @@ CBotString::CBotString(const CBotString& srcString)
int CBotString::GivLength()
int CBotString::GetLength()
{
if (m_ptr == NULL) return 0;
return strlen( m_ptr );
@ -285,7 +285,7 @@ CBotString CBotString::Mid(int start, int lg)
if ( lg < 0 ) lg = m_lg - start;
char* p = (char*)malloc(m_lg+1);
char* p = static_cast<char*>(malloc(m_lg+1));
strcpy(p, m_ptr+start);
p[lg] = 0;
@ -322,7 +322,7 @@ bool CBotString::LoadString(unsigned int id)
m_ptr = NULL;
if (m_lg > 0)
{
m_ptr = (char*)malloc(m_lg+1);
m_ptr = static_cast<char*>(malloc(m_lg+1));
strcpy(m_ptr, str);
return true;
}
@ -339,7 +339,7 @@ const CBotString& CBotString::operator=(const CBotString& stringSrc)
if (m_lg > 0)
{
m_ptr = (char*)malloc(m_lg+1);
m_ptr = static_cast<char*>(malloc(m_lg+1));
strcpy(m_ptr, stringSrc.m_ptr);
}
@ -355,7 +355,7 @@ CBotString operator+(const CBotString& string, const char * lpsz)
const CBotString& CBotString::operator+(const CBotString& stringSrc)
{
char* p = (char*)malloc(m_lg+stringSrc.m_lg+1);
char* p = static_cast<char*>(malloc(m_lg+stringSrc.m_lg+1));
strcpy(p, m_ptr);
char* pp = p + m_lg;
@ -392,7 +392,7 @@ const CBotString& CBotString::operator=(const char* pString)
if (m_lg != 0)
{
m_ptr = (char*)malloc(m_lg+1);
m_ptr = static_cast<char*>(malloc(m_lg+1));
strcpy(m_ptr, pString);
}
}
@ -549,7 +549,7 @@ CBotStringArray::~CBotStringArray()
}
int CBotStringArray::GivSize()
int CBotStringArray::GetSize()
{
return m_nSize;
}

54
src/CBot/CBotToken.cpp
View File

@ -123,25 +123,25 @@ const CBotToken& CBotToken::operator=(const CBotToken& src)
}
int CBotToken::GivType()
int CBotToken::GetType()
{
if (this == NULL) return 0;
if (m_type == TokenTypKeyWord) return m_IdKeyWord;
return m_type;
}
long CBotToken::GivIdKey()
long CBotToken::GetIdKey()
{
return m_IdKeyWord;
}
CBotToken* CBotToken::GivNext()
CBotToken* CBotToken::GetNext()
{
if (this == NULL) return NULL;
return m_next;
}
CBotToken* CBotToken::GivPrev()
CBotToken* CBotToken::GetPrev()
{
if (this == NULL) return NULL;
return m_prev;
@ -159,12 +159,12 @@ void CBotToken::AddNext(CBotToken* p)
}
CBotString& CBotToken::GivString()
CBotString& CBotToken::GetString()
{
return m_Text;
}
CBotString& CBotToken::GivSep()
CBotString& CBotToken::GetSep()
{
return m_Sep;
}
@ -175,13 +175,13 @@ void CBotToken::SetString(const char* name)
}
int CBotToken::GivStart()
int CBotToken::GetStart()
{
if (this == NULL) return -1;
return m_start;
}
int CBotToken::GivEnd()
int CBotToken::GetEnd()
{
if (this == NULL) return -1;
return m_end;
@ -309,7 +309,7 @@ cc: mot += c;
if (CharInList(mot[0], sep3)) // an operational separator?
{
CBotString motc = mot;
while (motc += c, c != 0 && GivKeyWords(motc)>0) // operand seeks the longest possible
while (motc += c, c != 0 && GetKeyWords(motc)>0) // operand seeks the longest possible
{
mot += c; // build the word
c = *(program++); // next character
@ -367,9 +367,9 @@ bis:
if (mot[0] == '\"') token->m_type = TokenTypString;
if (first) token->m_type = 0;
token->m_IdKeyWord = GivKeyWords(mot);
token->m_IdKeyWord = GetKeyWords(mot);
if (token->m_IdKeyWord > 0) token->m_type = TokenTypKeyWord;
else GivKeyDefNum(mot, token) ; // treats DefineNum
else GetKeyDefNum(mot, token) ; // treats DefineNum
return token;
}
@ -391,9 +391,9 @@ CBotToken* CBotToken::CompileTokens(const char* program, int& error)
if (tokenbase == NULL) return NULL;
tokenbase->m_start = pos;
pos += tokenbase->m_Text.GivLength();
pos += tokenbase->m_Text.GetLength();
tokenbase->m_end = pos;
pos += tokenbase->m_Sep.GivLength();
pos += tokenbase->m_Sep.GetLength();
char* pp = p;
while (NULL != (nxt = NextToken(p, error)))
@ -403,11 +403,11 @@ CBotToken* CBotToken::CompileTokens(const char* program, int& error)
prv = nxt; // advance
nxt->m_start = pos;
/* pos += nxt->m_Text.GivLength(); // chain may be shorter (BOA deleted)
/* pos += nxt->m_Text.GetLength(); // chain may be shorter (BOA deleted)
nxt->m_end = pos;
pos += nxt->m_Sep.GivLength();*/
pos += nxt->m_Sep.GetLength();*/
pos += (p - pp); // total size
nxt->m_end = pos - nxt->m_Sep.GivLength();
nxt->m_end = pos - nxt->m_Sep.GetLength();
pp = p;
}
@ -429,15 +429,15 @@ void CBotToken::Delete(CBotToken* pToken)
// search if a word is part of the keywords
int CBotToken::GivKeyWords(const char* w)
int CBotToken::GetKeyWords(const char* w)
{
int i;
int l = m_ListKeyWords.GivSize();
int l = m_ListKeyWords.GetSize();
if (l == 0)
{
LoadKeyWords(); // takes the list for the first time
l = m_ListKeyWords.GivSize();
l = m_ListKeyWords.GetSize();
}
for (i = 0; i < l; i++)
@ -448,10 +448,10 @@ int CBotToken::GivKeyWords(const char* w)
return -1;
}
bool CBotToken::GivKeyDefNum(const char* w, CBotToken* &token)
bool CBotToken::GetKeyDefNum(const char* w, CBotToken* &token)
{
int i;
int l = m_ListKeyDefine.GivSize();
int l = m_ListKeyDefine.GetSize();
for (i = 0; i < l; i++)
{
@ -510,7 +510,7 @@ void CBotToken::LoadKeyWords()
bool CBotToken::DefineNum(const char* name, long val)
{
int i;
int l = m_ListKeyDefine.GivSize();
int l = m_ListKeyDefine.GetSize();
for (i = 0; i < l; i++)
{
@ -525,10 +525,10 @@ bool CBotToken::DefineNum(const char* name, long val)
bool IsOfType(CBotToken* &p, int type1, int type2)
{
if (p->GivType() == type1 ||
p->GivType() == type2 )
if (p->GetType() == type1 ||
p->GetType() == type2 )
{
p = p->GivNext();
p = p->GetNext();
return true;
}
return false;
@ -539,7 +539,7 @@ bool IsOfTypeList(CBotToken* &p, int type1, ...)
{
int i = type1;
int max = 20;
int type = p->GivType();
int type = p->GetType();
va_list marker;
va_start( marker, type1 ); /* Initialize variable arguments. */
@ -548,7 +548,7 @@ bool IsOfTypeList(CBotToken* &p, int type1, ...)
{
if (type == i)
{
p = p->GivNext();
p = p->GetNext();
va_end( marker ); /* Reset variable arguments. */
return true;
}

78
src/CBot/CBotTwoOpExpr.cpp
View File

@ -136,11 +136,11 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
if (left == NULL) return pStack->Return(NULL, pStk); // if error, transmit
// did we expected the operand?
int TypeOp = p->GivType();
int TypeOp = p->GetType();
if ( IsInList( TypeOp, pOperations, typemasque ) )
{
CBotTypResult type1, type2;
type1 = pStk->GivTypResult(); // what kind of the first operand?
type1 = pStk->GetTypResult(); // what kind of the first operand?
if ( TypeOp == ID_LOGIC ) // special case provided for: ? op1: op2;
{
@ -152,25 +152,25 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
CBotLogicExpr* inst = new CBotLogicExpr();
inst->m_condition = left;
p = p->GivNext(); // skip the token of the operation
p = p->GetNext(); // 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());
pStk->SetError( TX_MISDOTS, p->GetStart());
delete inst;
return pStack->Return(NULL, pStk);
}
type1 = pStk->GivTypResult();
type1 = pStk->GetTypResult();
inst->m_op2 = CBotExpression::Compile(p, pStk);
if ( inst->m_op2 == NULL )
{
pStk->SetError( TX_ENDOF, p->GivStart() );
pStk->SetError( TX_ENDOF, p->GetStart() );
delete inst;
return pStack->Return(NULL, pStk);
}
type2 = pStk->GivTypResult();
type2 = pStk->GetTypResult();
if (!TypeCompatible(type1, type2))
{
pStk->SetError( TX_BAD2TYPE, pp );
@ -187,7 +187,7 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
inst->SetToken(p); // stores the operation
p = p->GivNext(); // skip the token of the operation
p = p->GetNext(); // skip the token of the operation
// looking statements that may be suitable for right
@ -196,10 +196,10 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
{
// there is an second operand acceptable
type2 = pStk->GivTypResult(); // what kind of results?
type2 = pStk->GetTypResult(); // what kind of results?
// what kind of result?
int TypeRes = MAX( type1.GivType(3), type2.GivType(3) );
int TypeRes = MAX( type1.GetType(3), type2.GetType(3) );
if ( TypeOp == ID_ADD && type1.Eq(CBotTypString) )
{
TypeRes = CBotTypString;
@ -232,17 +232,17 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
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?
while ( IsInList( p->GetType(), pOperations, typemasque ) ) // same operation(s) follows?
{
TypeOp = p->GivType();
TypeOp = p->GetType();
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
p = p->GetNext(); // advance after
i->m_rightop = CBotTwoOpExpr::Compile( p, pStk, pOp );
type2 = pStk->GivTypResult();
type2 = pStk->GetTypResult();
if ( !TypeCompatible (type1, type2, TypeOp) ) // the results are compatible
{
@ -252,7 +252,7 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
}
if ( TypeRes != CBotTypString )
TypeRes = MAX(type1.GivType(), type2.GivType());
TypeRes = MAX(type1.GetType(), type2.GetType());
inst = i;
}
@ -283,7 +283,7 @@ CBotInstr* CBotTwoOpExpr::Compile(CBotToken* &p, CBotCStack* pStack, int* pOpera
bool IsNan(CBotVar* left, CBotVar* right, int* err = NULL)
{
if ( left ->GivInit() > IS_DEF || right->GivInit() > IS_DEF )
if ( left ->GetInit() > IS_DEF || right->GetInit() > IS_DEF )
{
if ( err != NULL ) *err = TX_OPNAN ;
return true;
@ -302,19 +302,19 @@ bool CBotTwoOpExpr::Execute(CBotStack* &pStack)
// according to recovery, it may be in one of two states
if ( pStk1->GivState() == 0 ) // first state, evaluates the left operand
if ( pStk1->GetState() == 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 )
if ( (GetTokenType() == ID_LOG_AND || GetTokenType() == ID_TXT_AND ) && pStk1->GetVal() == 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 )
if ( (GetTokenType() == ID_LOG_OR||GetTokenType() == ID_TXT_OR) && pStk1->GetVal() == true )
{
CBotVar* res = CBotVar::Create( (CBotToken*)NULL, CBotTypBoolean);
res->SetValInt(true);
@ -334,28 +334,28 @@ bool CBotTwoOpExpr::Execute(CBotStack* &pStack)
// or return in case of recovery
// 2e état, évalue l'opérande de droite
if ( pStk2->GivState() == 0 )
if ( pStk2->GetState() == 0 )
{
if ( !m_rightop->Execute(pStk2) ) return false; // interrupted here?
pStk2->IncState();
}
CBotTypResult type1 = pStk1->GivTypResult(); // what kind of results?
CBotTypResult type2 = pStk2->GivTypResult();
CBotTypResult type1 = pStk1->GetTypResult(); // what kind of results?
CBotTypResult type2 = pStk2->GetTypResult();
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());
int TypeRes = MAX(type1.GetType(), type2.GetType());
if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )
if ( GetTokenType() == ID_ADD && type1.Eq(CBotTypString) )
{
TypeRes = CBotTypString;
}
switch ( GivTokenType() )
switch ( GetTokenType() )
{
case ID_LOG_OR:
case ID_LOG_AND:
@ -377,9 +377,9 @@ bool CBotTwoOpExpr::Execute(CBotStack* &pStack)
CBotVar* result = CBotVar::Create( (CBotToken*)NULL, TypeRes);
// creates a variable to perform the calculation in the appropriate type
TypeRes = MAX(type1.GivType(), type2.GivType());
TypeRes = MAX(type1.GetType(), type2.GetType());
if ( GivTokenType() == ID_ADD && type1.Eq(CBotTypString) )
if ( GetTokenType() == ID_ADD && type1.Eq(CBotTypString) )
{
TypeRes = CBotTypString;
}
@ -387,15 +387,15 @@ bool CBotTwoOpExpr::Execute(CBotStack* &pStack)
CBotVar* temp;
if ( TypeRes == CBotTypPointer ) TypeRes = CBotTypNullPointer;
if ( TypeRes == CBotTypClass ) temp = CBotVar::Create( (CBotToken*)NULL, CBotTypResult(CBotTypIntrinsic, type1.GivClass() ) );
if ( TypeRes == CBotTypClass ) temp = CBotVar::Create( (CBotToken*)NULL, CBotTypResult(CBotTypIntrinsic, type1.GetClass() ) );
else temp = CBotVar::Create( (CBotToken*)NULL, TypeRes );
int err = 0;
// is a operation according to request
CBotVar* left = pStk1->GivVar();
CBotVar* right = pStk2->GivVar();
CBotVar* left = pStk1->GetVar();
CBotVar* right = pStk2->GetVar();
switch (GivTokenType())
switch (GetTokenType())
{
case ID_ADD:
if ( !IsNan(left, right, &err) ) result->Add(left , right); // addition
@ -433,13 +433,13 @@ bool CBotTwoOpExpr::Execute(CBotStack* &pStack)
break;
case ID_EQ:
if ( IsNan(left, right) )
result->SetValInt(left->GivInit() == right->GivInit()) ;
result->SetValInt(left->GetInit() == right->GetInit()) ;
else
result->SetValInt(temp->Eq(left , right)); // equal
break;
case ID_NE:
if ( IsNan(left, right) )
result->SetValInt(left ->GivInit() != right->GivInit()) ;
result->SetValInt(left ->GetInit() != right->GetInit()) ;
else
result->SetValInt(temp->Ne(left , right)); // different
break;
@ -485,7 +485,7 @@ void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, bool bMain)
// according to recovery, it may be in one of two states
if ( pStk1->GivState() == 0 ) // first state, evaluates the left operand
if ( pStk1->GetState() == 0 ) // first state, evaluates the left operand
{
m_leftop->RestoreState(pStk1, bMain); // interrupted here!
return;
@ -495,7 +495,7 @@ void CBotTwoOpExpr::RestoreState(CBotStack* &pStack, bool bMain)
if ( pStk2 == NULL ) return;
// second state, evaluates the right operand
if ( pStk2->GivState() == 0 )
if ( pStk2->GetState() == 0 )
{
m_rightop->RestoreState(pStk2, bMain); // interrupted here!
return;
@ -509,13 +509,13 @@ bool CBotLogicExpr::Execute(CBotStack* &pStack)
// or return in case of recovery
// if ( pStk1 == EOX ) return true;
if ( pStk1->GivState() == 0 )
if ( pStk1->GetState() == 0 )
{
if ( !m_condition->Execute(pStk1) ) return false;
if (!pStk1->SetState(1)) return false;
}
if ( pStk1->GivVal() == true )
if ( pStk1->GetVal() == true )
{
if ( !m_op1->Execute(pStk1) ) return false;
}
@ -534,13 +534,13 @@ void CBotLogicExpr::RestoreState(CBotStack* &pStack, bool bMain)
CBotStack* pStk1 = pStack->RestoreStack(this); // adds an item to the stack
if ( pStk1 == NULL ) return;
if ( pStk1->GivState() == 0 )
if ( pStk1->GetState() == 0 )
{
m_condition->RestoreState(pStk1, bMain);
return;
}
if ( pStk1->GivVal() == true )
if ( pStk1->GetVal() == true )
{
m_op1->RestoreState(pStk1, bMain);
}

406
src/CBot/CBotVar.cpp
View File

File diff suppressed because it is too large Load Diff

168
src/CBot/CBotWhile.cpp
View File

@ -55,7 +55,7 @@ CBotInstr* CBotWhile::Compile(CBotToken* &p, CBotCStack* pStack)
if ( IsOfType( p, TokenTypVar ) &&
IsOfType( p, ID_DOTS ) )
{
inst->m_label = pp->GivString(); // records the name of the label
inst->m_label = pp->GetString(); // records the name of the label
}
inst->SetToken(p);
@ -95,7 +95,7 @@ bool CBotWhile :: Execute(CBotStack* &pj)
if ( pile->IfStep() ) return false;
while( true ) switch( pile->GivState() ) // executes the loop
while( true ) switch( pile->GetState() ) // executes the loop
{ // there are two possible states (depending on recovery)
case 0:
// evaluates the condition
@ -104,7 +104,7 @@ bool CBotWhile :: Execute(CBotStack* &pj)
// the result of the condition is on the stack
// terminates if an error or if the condition is false
if ( !pile->IsOk() || pile->GivVal() != true )
if ( !pile->IsOk() || pile->GetVal() != true )
{
return pj->Return(pile); // sends the results and releases the stack
}
@ -140,7 +140,7 @@ void CBotWhile :: RestoreState(CBotStack* &pj, bool bMain)
CBotStack* pile = pj->RestoreStack(this); // adds an item to the stack
if ( pile == NULL ) return;
switch( pile->GivState() )
switch( pile->GetState() )
{ // there are two possible states (depending on recovery)
case 0:
// evaluates the condition
@ -181,7 +181,7 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack)
if ( IsOfType( p, TokenTypVar ) &&
IsOfType( p, ID_DOTS ) )
{
inst->m_label = pp->GivString(); // register the name of label
inst->m_label = pp->GetString(); // register the name of label
}
inst->SetToken(p);
@ -194,7 +194,7 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack)
CBotToken* ppp = p; // preserves the ^ token (starting position)
if ( NULL != (inst->m_NbIter = CBotExpression::Compile( p, pStk )) )
{
if ( pStk->GivType() < CBotTypLong )
if ( pStk->GetType() < CBotTypLong )
{
if ( IsOfType(p, ID_CLOSEPAR ) )
{
@ -210,14 +210,14 @@ CBotInstr* CBotRepeat::Compile(CBotToken* &p, CBotCStack* pStack)
return pStack->Return(inst, pStk); // return an object to the application
}
}
pStack->SetError(TX_CLOSEPAR, p->GivStart());
pStack->SetError(TX_CLOSEPAR, p->GetStart());
}
pStk->SetStartError(ppp->GivStart());
pStk->SetError( TX_BADTYPE, p->GivStart() );
pStk->SetStartError(ppp->GetStart());
pStk->SetError( TX_BADTYPE, p->GetStart() );
}
pStack->SetError(TX_ENDOF, p);
}
pStack->SetError(TX_OPENPAR, p->GivStart()); // missing parenthesis
pStack->SetError(TX_OPENPAR, p->GetStart()); // missing parenthesis
delete inst; // error, frees up
return pStack->Return(NULL, pStk); // no object, the error is on the stack
@ -233,7 +233,7 @@ bool CBotRepeat :: Execute(CBotStack* &pj)
if ( pile->IfStep() ) return false;
while( true ) switch( pile->GivState() ) // executes the loop
while( true ) switch( pile->GetState() ) // executes the loop
{ // there are two possible states (depending on recovery)
case 0:
// evaluates the number of iterations
@ -243,7 +243,7 @@ bool CBotRepeat :: Execute(CBotStack* &pj)
// terminates if an error or if the condition is false
int n;
if ( !pile->IsOk() || ( n = pile->GivVal() ) < 1 )
if ( !pile->IsOk() || ( n = pile->GetVal() ) < 1 )
{
return pj->Return(pile); // sends the results and releases the stack
}
@ -262,7 +262,7 @@ bool CBotRepeat :: Execute(CBotStack* &pj)
if ( m_Block != NULL &&
!m_Block->Execute(pile) )
{
if (pile->IfContinue(pile->GivState()-1, m_label)) continue; // if continued, will return to test
if (pile->IfContinue(pile->GetState()-1, m_label)) continue; // if continued, will return to test
return pj->BreakReturn(pile, m_label); // sends the results and releases the stack
}
@ -273,7 +273,7 @@ bool CBotRepeat :: Execute(CBotStack* &pj)
}
// returns to the test again
if (!pile->SetState(pile->GivState()-1, 0)) return false;
if (!pile->SetState(pile->GetState()-1, 0)) return false;
continue;
}
}
@ -284,7 +284,7 @@ void CBotRepeat :: RestoreState(CBotStack* &pj, bool bMain)
CBotStack* pile = pj->RestoreStack(this); // adds an item to the stack
if ( pile == NULL ) return;
switch( pile->GivState() )
switch( pile->GetState() )
{ // there are two possible states (depending on recovery)
case 0:
// evaluates the condition
@ -325,7 +325,7 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack)
if ( IsOfType( p, TokenTypVar ) &&
IsOfType( p, ID_DOTS ) )
{
inst->m_label = pp->GivString(); // register the name of label
inst->m_label = pp->GetString(); // register the name of label
}
inst->SetToken(p);
@ -350,10 +350,10 @@ CBotInstr* CBotDo::Compile(CBotToken* &p, CBotCStack* pStack)
{
return pStack->Return(inst, pStk); // return an object to the application
}
pStk->SetError(TX_ENDOF, p->GivStart());
pStk->SetError(TX_ENDOF, p->GetStart());
}
}
pStk->SetError(TX_WHILE, p->GivStart());
pStk->SetError(TX_WHILE, p->GetStart());
}
delete inst; // error, frees up
@ -370,7 +370,7 @@ bool CBotDo :: Execute(CBotStack* &pj)
if ( pile->IfStep() ) return false;
while( true ) switch( pile->GivState() ) // executes the loop
while( true ) switch( pile->GetState() ) // executes the loop
{ // there are two possible states (depending on recovery)
case 0:
// evaluates the associated statement block
@ -396,7 +396,7 @@ bool CBotDo :: Execute(CBotStack* &pj)
// the result of the condition is on the stack
// terminates if an error or if the condition is false
if ( !pile->IsOk() || pile->GivVal() != true )
if ( !pile->IsOk() || pile->GetVal() != true )
{
return pj->Return(pile); // sends the results and releases the stack
}
@ -414,7 +414,7 @@ void CBotDo :: RestoreState(CBotStack* &pj, bool bMain)
CBotStack* pile = pj->RestoreStack(this); // adds an item to the stack
if ( pile == NULL ) return;
switch( pile->GivState() )
switch( pile->GetState() )
{ // there are two possible states (depending on recovery)
case 0:
// restores the assosiated statement's block
@ -459,7 +459,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
if ( IsOfType( p, TokenTypVar ) &&
IsOfType( p, ID_DOTS ) )
{
inst->m_label = pp->GivString(); // register the name of label
inst->m_label = pp->GetString(); // register the name of label
}
inst->SetToken(p);
@ -467,7 +467,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
if ( !IsOfType(p, ID_OPENPAR)) // missing parenthesis ?
{
pStack->SetError(TX_OPENPAR, p->GivStart());
pStack->SetError(TX_OPENPAR, p->GetStart());
return NULL;
}
@ -479,7 +479,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
{
if ( !IsOfType(p, ID_SEP)) // lack the semicolon?
{
pStack->SetError(TX_OPENPAR, p->GivStart());
pStack->SetError(TX_OPENPAR, p->GetStart());
delete inst;
return pStack->Return(NULL, pStk); // no object, the error is on the stack
}
@ -488,7 +488,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
{
if ( !IsOfType(p, ID_SEP)) // lack the semicolon?
{
pStack->SetError(TX_OPENPAR, p->GivStart());
pStack->SetError(TX_OPENPAR, p->GetStart());
delete inst;
return pStack->Return(NULL, pStk); // no object, the error is on the stack
}
@ -503,7 +503,7 @@ CBotInstr* CBotFor::Compile(CBotToken* &p, CBotCStack* pStack)
if ( pStk->IsOk() )
return pStack->Return(inst, pStk);;
}
pStack->SetError(TX_CLOSEPAR, p->GivStart());
pStack->SetError(TX_CLOSEPAR, p->GetStart());
}
}
}
@ -522,7 +522,7 @@ bool CBotFor :: Execute(CBotStack* &pj)
if ( pile->IfStep() ) return false;
while( true ) switch( pile->GivState() ) // executes the loop
while( true ) switch( pile->GetState() ) // executes the loop
{ // there are four possible states (depending on recovery)
case 0:
// initialize
@ -539,7 +539,7 @@ bool CBotFor :: Execute(CBotStack* &pj)
// the result of the condition is on the stack
// terminates if an error or if the condition is false
if ( !pile->IsOk() || pile->GivVal() != true )
if ( !pile->IsOk() || pile->GetVal() != true )
{
return pj->Return(pile); // sends the results and releases the stack
}
@ -583,7 +583,7 @@ void CBotFor :: RestoreState(CBotStack* &pj, bool bMain)
CBotStack* pile = pj->RestoreStack(this); // adds an item to the stack (variables locales)
if ( pile == NULL ) return;
switch( pile->GivState() )
switch( pile->GetState() )
{ // there are four possible states (depending on recovery)
case 0:
// initialize
@ -669,13 +669,13 @@ bool CBotListExpression::Execute(CBotStack* &pj)
CBotStack* pile = pj->AddStack(); // essential
CBotInstr* p = m_Expr; // the first expression
int state = pile->GivState();
while (state-->0) p = p->GivNext(); // returns to the interrupted operation
int state = pile->GetState();
while (state-->0) p = p->GetNext(); // returns to the interrupted operation
if ( p != NULL ) while (true)
{
if ( !p->Execute(pile) ) return false;
p = p->GivNext();
p = p->GetNext();
if ( p == NULL ) break;
if (!pile->IncState()) return false; // ready for next
}
@ -691,7 +691,7 @@ void CBotListExpression::RestoreState(CBotStack* &pj, bool bMain)
{
pile = pj->RestoreStack();
if ( pile == NULL ) return;
state = pile->GivState();
state = pile->GetState();
}
CBotInstr* p = m_Expr; // the first expression
@ -699,7 +699,7 @@ void CBotListExpression::RestoreState(CBotStack* &pj, bool bMain)
while (p != NULL && state-->0)
{
p->RestoreState(pile, false);
p = p->GivNext(); // returns to the interrupted operation
p = p->GetNext(); // returns to the interrupted operation
}
if ( p != NULL )
@ -741,7 +741,7 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)
{
if ( NULL != (inst->m_Value = CBotExpression::Compile( p, pStk )) )
{
if ( pStk->GivType() < CBotTypLong )
if ( pStk->GetType() < CBotTypLong )
{
if ( IsOfType(p, ID_CLOSEPAR ) )
{
@ -751,7 +751,7 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)
while( !IsOfType( p, ID_CLBLK ) )
{
if ( p->GivType() == ID_CASE || p->GivType() == ID_DEFAULT)
if ( p->GetType() == ID_CASE || p->GetType() == ID_DEFAULT)
{
CBotCStack* pStk2 = pStk->TokenStack(p); // un petit bout de pile svp
@ -769,7 +769,7 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)
if ( inst->m_Block == NULL )
{
pStk->SetError(TX_NOCASE, p->GivStart());
pStk->SetError(TX_NOCASE, p->GetStart());
delete inst;
return pStack->Return(NULL, pStk);
}
@ -793,21 +793,21 @@ CBotInstr* CBotSwitch::Compile(CBotToken* &p, CBotCStack* pStack)
if ( inst->m_Block == NULL )
{
pStk->SetError(TX_NOCASE, p->GivStart());
pStk->SetError(TX_NOCASE, p->GetStart());
delete inst;
return pStack->Return(NULL, pStk);
}
// the statement block is ok
return pStack->Return(inst, pStk); // return an object to the application
}
pStk->SetError( TX_OPENBLK, p->GivStart() );
pStk->SetError( TX_OPENBLK, p->GetStart() );
}
pStk->SetError( TX_CLOSEPAR, p->GivStart() );
pStk->SetError( TX_CLOSEPAR, p->GetStart() );
}
pStk->SetError( TX_BADTYPE, p->GivStart() );
pStk->SetError( TX_BADTYPE, p->GetStart() );
}
}
pStk->SetError( TX_OPENPAR, p->GivStart());
pStk->SetError( TX_OPENPAR, p->GetStart());
delete inst; // error, frees up
return pStack->Return(NULL, pStk); // no object, the error is on the stack
@ -822,7 +822,7 @@ bool CBotSwitch :: Execute(CBotStack* &pj)
CBotInstr* p = m_Block; // first expression
int state = pile1->GivState();
int state = pile1->GetState();
if (state == 0)
{
if ( !m_Value->Execute(pile1) ) return false;
@ -834,14 +834,14 @@ bool CBotSwitch :: Execute(CBotStack* &pj)
if ( state == -1 )
{
state = 0;
int val = pile1->GivVal(); // result of the value
int val = pile1->GetVal(); // result of the value
CBotStack* pile2 = pile1->AddStack();
while ( p != NULL ) // search for the corresponding case in a list
{
state++;
if ( p->CompCase( pile2, val ) ) break; // found the case
p = p->GivNext();
p = p->GetNext();
}
pile2->Delete();
@ -851,13 +851,13 @@ bool CBotSwitch :: Execute(CBotStack* &pj)
}
p = m_Block; // returns to the beginning
while (state-->0) p = p->GivNext(); // advance in the list
while (state-->0) p = p->GetNext(); // advance in the list
while( p != NULL )
{
if ( !p->Execute(pile1) ) return pj->BreakReturn(pile1);
if ( !pile1->IncState() ) return false;
p = p->GivNext();
p = p->GetNext();
}
return pj->Return(pile1);
}
@ -871,7 +871,7 @@ void CBotSwitch :: RestoreState(CBotStack* &pj, bool bMain)
CBotInstr* p = m_Block; // first expression
int state = pile1->GivState();
int state = pile1->GetState();
if (state == 0)
{
m_Value->RestoreState(pile1, bMain);
@ -887,7 +887,7 @@ void CBotSwitch :: RestoreState(CBotStack* &pj, bool bMain)
while ( p != NULL && state-- > 0 )
{
p->RestoreState(pile1, false);
p = p->GivNext(); // advance in the list
p = p->GetNext(); // advance in the list
}
if( p != NULL )
@ -923,7 +923,7 @@ CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack)
inst->SetToken(p);
if (!IsOfType(p, ID_CASE, ID_DEFAULT)) return NULL; // should never happen
if ( pp->GivType() == ID_CASE )
if ( pp->GetType() == ID_CASE )
{
pp = p;
inst->m_Value = CBotExprNum::Compile(p, pStack);
@ -936,7 +936,7 @@ CBotInstr* CBotCase::Compile(CBotToken* &p, CBotCStack* pStack)
}
if ( !IsOfType( p, ID_DOTS ))
{
pStack->SetError( TX_MISDOTS, p->GivStart() );
pStack->SetError( TX_MISDOTS, p->GetStart() );
delete inst;
return NULL;
}
@ -963,7 +963,7 @@ bool CBotCase::CompCase(CBotStack* &pile, int val)
if ( m_Value == NULL ) return true; // "default" case
while (!m_Value->Execute(pile)); // puts the value on the correspondent stack (without interruption)
return (pile->GivVal() == val); // compared with the given value
return (pile->GetVal() == val); // compared with the given value
}
///////////////////////////////////////////////////////////////////////////
@ -983,7 +983,7 @@ CBotBreak::~CBotBreak()
CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack)
{
CBotToken* pp = p; // preserves at the ^ token (starting position)
int type = p->GivType();
int type = p->GetType();
if (!IsOfType(p, ID_BREAK, ID_CONTINUE)) return NULL; // should never happen
@ -999,7 +999,7 @@ CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack)
pp = p;
if ( IsOfType( p, TokenTypVar ) )
{
inst->m_label = pp->GivString(); // register the name of label
inst->m_label = pp->GetString(); // register the name of label
if ( !ChkLvl(inst->m_label, type ) )
{
delete inst;
@ -1014,7 +1014,7 @@ CBotInstr* CBotBreak::Compile(CBotToken* &p, CBotCStack* pStack)
}
delete inst;
pStack->SetError(TX_ENDOF, p->GivStart());
pStack->SetError(TX_ENDOF, p->GetStart());
return NULL; // no object, the error is on the stack
}
@ -1027,7 +1027,7 @@ bool CBotBreak :: Execute(CBotStack* &pj)
if ( pile->IfStep() ) return false;
pile->SetBreak(m_token.GivType()==ID_BREAK ? 1 : 2, m_label);
pile->SetBreak(m_token.GetType()==ID_BREAK ? 1 : 2, m_label);
return pj->Return(pile);
}
@ -1070,7 +1070,7 @@ CBotInstr* CBotTry::Compile(CBotToken* &p, CBotCStack* pStack)
inst->m_Block = CBotBlock::CompileBlkOrInst( p, pStk );
CBotCatch** pn = &inst->m_ListCatch;
while (pStk->IsOk() && p->GivType() == ID_CATCH)
while (pStk->IsOk() && p->GetType() == ID_CATCH)
{
CBotCatch* i = CBotCatch::Compile(p, pStk);
*pn = i;
@ -1108,7 +1108,7 @@ bool CBotTry :: Execute(CBotStack* &pj)
CBotStack* pile0 = pj->AddStack2(); // adds an element to the secondary stack
CBotStack* pile2 = pile0->AddStack();
if ( pile1->GivState() == 0 )
if ( pile1->GetState() == 0 )
{
if ( m_Block->Execute(pile1) )
{
@ -1116,7 +1116,7 @@ bool CBotTry :: Execute(CBotStack* &pj)
pile1->SetState(-2); // passes final
}
val = pile1->GivError();
val = pile1->GetError();
if ( val == 0 && CBotStack::m_initimer == 0 ) // mode step?
return false; // does not make the catch
@ -1132,8 +1132,8 @@ bool CBotTry :: Execute(CBotStack* &pj)
// see what it returns
CBotCatch* pc = m_ListCatch;
int state = (short)pile1->GivState(); // where were we?
val = pile2->GivState(); // what error?
int state = (short)pile1->GetState(); // where were we?
val = pile2->GetState(); // what error?
pile0->SetState(1); // marking the GetRunPos
if ( val >= 0 && state > 0 ) while ( pc != NULL )
@ -1147,7 +1147,7 @@ bool CBotTry :: Execute(CBotStack* &pj)
}
if ( --state <= 0 )
{
if ( pile2->GivVal() == true )
if ( pile2->GetVal() == true )
{
// pile0->SetState(1);
@ -1163,15 +1163,15 @@ bool CBotTry :: Execute(CBotStack* &pj)
pc = pc->m_next;
}
if ( m_FinalInst != NULL &&
pile1->GivState() > 0 && val != 0 ) pile1->SetState(-1);// if stop then made the final
pile1->GetState() > 0 && val != 0 ) pile1->SetState(-1);// if stop then made the final
if (pile1->GivState() <= -1)
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->GivState()==-1 ? val : 0); // gives the initial error
pile2->SetError(pile1->GetState()==-1 ? val : 0); // gives the initial error
return pj->Return(pile2);
}
@ -1200,7 +1200,7 @@ void CBotTry :: RestoreState(CBotStack* &pj, bool bMain)
if ( pile2 == NULL ) return;
m_Block->RestoreState(pile1, bMain);
if ( pile0->GivState() == 0 )
if ( pile0->GetState() == 0 )
{
return;
}
@ -1209,8 +1209,8 @@ void CBotTry :: RestoreState(CBotStack* &pj, bool bMain)
// see what it returns
CBotCatch* pc = m_ListCatch;
int state = pile1->GivState(); // where were we ?
val = pile2->GivState(); // what error ?
int state = pile1->GetState(); // where were we ?
val = pile2->GetState(); // what error ?
if ( val >= 0 && state > 0 ) while ( pc != NULL )
{
@ -1223,7 +1223,7 @@ void CBotTry :: RestoreState(CBotStack* &pj, bool bMain)
}
if ( --state <= 0 )
{
if ( pile2->GivVal() == true )
if ( pile2->GetVal() == true )
{
pc->RestoreState(pile2, bMain); // execute the operation
return;
@ -1232,7 +1232,7 @@ void CBotTry :: RestoreState(CBotStack* &pj, bool bMain)
pc = pc->m_next;
}
if (pile1->GivState() <= -1)
if (pile1->GetState() <= -1)
{
m_FinalInst->RestoreState(pile2, bMain);
return;
@ -1263,7 +1263,7 @@ CBotCatch::~CBotCatch()
CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack)
{
CBotCatch* inst = new CBotCatch(); // creates the object
pStack->SetStartError(p->GivStart());
pStack->SetStartError(p->GetStart());
inst->SetToken(p);
if (!IsOfType(p, ID_CATCH)) return NULL; // should never happen
@ -1271,8 +1271,8 @@ CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack)
if (IsOfType(p, ID_OPENPAR))
{
inst->m_Cond = CBotExpression::Compile(p, pStack);
if (( pStack->GivType() < CBotTypLong ||
pStack->GivTypResult().Eq(CBotTypBoolean) )&& pStack->IsOk() )
if (( pStack->GetType() < CBotTypLong ||
pStack->GetTypResult().Eq(CBotTypBoolean) )&& pStack->IsOk() )
{
if (IsOfType(p, ID_CLOSEPAR))
{
@ -1280,11 +1280,11 @@ CBotCatch* CBotCatch::Compile(CBotToken* &p, CBotCStack* pStack)
if ( pStack->IsOk() )
return inst; // return an object to the application
}
pStack->SetError(TX_CLOSEPAR, p->GivStart());
pStack->SetError(TX_CLOSEPAR, p->GetStart());
}
pStack->SetError(TX_BADTYPE, p->GivStart());
pStack->SetError(TX_BADTYPE, p->GetStart());
}
pStack->SetError(TX_OPENPAR, p->GivStart());
pStack->SetError(TX_OPENPAR, p->GetStart());
delete inst; // error, frees up
return NULL; // no object, the error is on the stack
}
@ -1313,10 +1313,10 @@ bool CBotCatch :: TestCatch(CBotStack* &pile, int val)
{
if ( !m_Cond->Execute(pile) ) return false;
if ( val > 0 || pile->GivType() != CBotTypBoolean )
if ( val > 0 || pile->GetType() != CBotTypBoolean )
{
CBotVar* var = CBotVar::Create((CBotToken*)NULL, CBotTypBoolean);
var->SetValInt( pile->GivVal() == val );
var->SetValInt( pile->GetVal() == val );
pile->SetVar(var); // calls on the stack
}
@ -1342,7 +1342,7 @@ CBotThrow::~CBotThrow()
CBotInstr* CBotThrow::Compile(CBotToken* &p, CBotCStack* pStack)
{
pStack->SetStartError(p->GivStart());
pStack->SetStartError(p->GetStart());
CBotThrow* inst = new CBotThrow(); // creates the object
inst->SetToken(p);
@ -1353,7 +1353,7 @@ CBotInstr* CBotThrow::Compile(CBotToken* &p, CBotCStack* pStack)
inst->m_Value = CBotExpression::Compile( p, pStack );
if (pStack->GivType() < CBotTypLong && pStack->IsOk())
if (pStack->GetType() < CBotTypLong && pStack->IsOk())
{
return inst; // return an object to the application
}
@ -1370,7 +1370,7 @@ bool CBotThrow :: Execute(CBotStack* &pj)
CBotStack* pile = pj->AddStack(this);
// if ( pile == EOX ) return true;
if ( pile->GivState() == 0 )
if ( pile->GetState() == 0 )
{
if ( !m_Value->Execute(pile) ) return false;
pile->IncState();
@ -1378,7 +1378,7 @@ bool CBotThrow :: Execute(CBotStack* &pj)
if ( pile->IfStep() ) return false;
int val = pile->GivVal();
int val = pile->GetVal();
if ( val < 0 ) val = TX_BADTHROW;
pile->SetError( val, &m_token );
return pj->Return( pile );
@ -1391,7 +1391,7 @@ void CBotThrow :: RestoreState(CBotStack* &pj, bool bMain)
CBotStack* pile = pj->RestoreStack(this);
if ( pile == NULL ) return;
if ( pile->GivState() == 0 )
if ( pile->GetState() == 0 )
{
m_Value->RestoreState(pile, bMain);
return;
@ -1425,7 +1425,7 @@ CBotInstr* CBotStartDebugDD::Compile(CBotToken* &p, CBotCStack* pStack)
bool CBotStartDebugDD :: Execute(CBotStack* &pj)
{
CBotProgram* p = pj->GivBotCall();
CBotProgram* p = pj->GetBotCall();
p->m_bDebugDD = true;
return true;

92
src/CBot/ClassFILE.cpp
View File

@ -68,25 +68,25 @@ bool rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exceptio
if ( pVar == NULL ) return true;
// must be a string
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
if ( pVar->GetType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
CBotString filename = pVar->GivValString();
CBotString filename = pVar->GetValString();
PrepareFilename(filename); //DR
// there may be a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar != NULL )
{
// recovers the mode
mode = pVar->GivValString();
mode = pVar->GetValString();
if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return false; }
// no third parameter, only two or one possible
if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return false; }
if ( pVar->GetNext() != NULL ) { Exception = CBotErrOverParam; return false; }
}
// save the file name
pVar = pThis->GivItem("filename");
pVar = pThis->GetItem("filename");
pVar->SetValString(filename);
if ( ! mode.IsEmpty() )
@ -98,7 +98,7 @@ bool rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exceptio
m_CompteurFileOpen ++;
// save the handle of file
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
pVar->SetValInt((long)pFile);
}
@ -112,18 +112,18 @@ CBotTypResult cfconstruct (CBotVar* pThis, CBotVar* &pVar)
if ( pVar == NULL ) return CBotTypResult( 0 );
// must be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
// there may be a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar != NULL )
{
// must be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
// no third parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
if ( pVar->GetNext() != NULL ) return CBotTypResult( CBotErrOverParam );
}
// le r<>sultat est de type void (constructeur)
@ -137,12 +137,12 @@ CBotTypResult cfconstruct (CBotVar* pThis, CBotVar* &pVar)
bool rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
// retrieves the element "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
// not open? no problem
if ( pVar->GivInit() != IS_DEF) return true;
if ( pVar->GetInit() != IS_DEF) return true;
FILE* pFile= (FILE*)pVar->GivValInt();
FILE* pFile= (FILE*)pVar->GetValInt();
fclose(pFile);
m_CompteurFileOpen --;
@ -162,38 +162,38 @@ bool rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
if ( pVar == NULL ) { Exception = CBotErrLowParam; return false; }
// must be a string
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
if ( pVar->GetType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
// there may be a second parameter
if ( pVar->GivNext() != NULL )
if ( pVar->GetNext() != NULL )
{
// in this case the first parameter is the file name
CBotString filename = pVar->GivValString();
CBotString filename = pVar->GetValString();
PrepareFilename(filename); //DR
// saves the file name
CBotVar* pVar2 = pThis->GivItem("filename");
CBotVar* pVar2 = pThis->GetItem("filename");
pVar2->SetValString(filename);
// next parameter is the mode
pVar = pVar -> GivNext();
pVar = pVar -> GetNext();
}
CBotString mode = pVar->GivValString();
CBotString mode = pVar->GetValString();
if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return false; }
// No third parameter
if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return false; }
if ( pVar->GetNext() != NULL ) { Exception = CBotErrOverParam; return false; }
// retrieves the element "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
// which must not be initialized
if ( pVar->GivInit() == IS_DEF) { Exception = CBotErrFileOpen; return false; }
if ( pVar->GetInit() == IS_DEF) { Exception = CBotErrFileOpen; return false; }
// contains filename
pVar = pThis->GivItem("filename");
CBotString filename = pVar->GivValString();
pVar = pThis->GetItem("filename");
CBotString filename = pVar->GetValString();
PrepareFilename(filename); //DD! (if the name was assigned by h.filename = "...";
@ -208,7 +208,7 @@ bool rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
m_CompteurFileOpen ++;
// saves the handle of file
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
pVar->SetValInt((long)pFile);
pResult->SetValInt(true); //DR
@ -222,19 +222,19 @@ CBotTypResult cfopen (CBotVar* pThis, CBotVar* &pVar)
if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );
// must be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
// there may be a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar != NULL )
{
// must be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
// no third parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
if ( pVar->GetNext() != NULL ) return CBotTypResult( CBotErrOverParam );
}
// the result is of type bool
@ -251,11 +251,11 @@ bool rfclose (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
if ( pVar != NULL ) return CBotErrOverParam;
// retrieves the element "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
if ( pVar->GetInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
FILE* pFile= (FILE*)pVar->GivValInt();
FILE* pFile= (FILE*)pVar->GetValInt();
fclose(pFile);
m_CompteurFileOpen --;
@ -283,16 +283,16 @@ bool rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
if ( pVar == NULL ) { Exception = CBotErrLowParam; return false; }
// must be a string
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
if ( pVar->GetType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
CBotString param = pVar->GivValString();
CBotString param = pVar->GetValString();
//retrieves the element "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
if ( pVar->GetInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
FILE* pFile= (FILE*)pVar->GivValInt();
FILE* pFile= (FILE*)pVar->GetValInt();
int res = fputs(param+CBotString("\n"), pFile);
@ -309,10 +309,10 @@ CBotTypResult cfwrite (CBotVar* pThis, CBotVar* &pVar)
if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );
// must be a string
if ( pVar->GivType() != CBotTypString ) return CBotTypResult( CBotErrBadString );
if ( pVar->GetType() != CBotTypString ) return CBotTypResult( CBotErrBadString );
// no other parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
if ( pVar->GetNext() != NULL ) return CBotTypResult( CBotErrOverParam );
// function returns "void" result
return CBotTypResult( 0 );
@ -327,11 +327,11 @@ bool rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
if ( pVar != NULL ) { Exception = CBotErrOverParam; return false; }
//retrieves the element "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
if ( pVar->GetInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
FILE* pFile= (FILE*)pVar->GivValInt();
FILE* pFile= (FILE*)pVar->GetValInt();
char chaine[2000];
int i;
@ -368,11 +368,11 @@ bool rfeof (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
if ( pVar != NULL ) { Exception = CBotErrOverParam; return false; }
// retrieves the element "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
if ( pVar->GetInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
FILE* pFile= (FILE*)pVar->GivValInt();
FILE* pFile= (FILE*)pVar->GetValInt();
pResult->SetValInt( feof( pFile ) );

126
src/CBot/StringFunctions.cpp
View File

@ -26,16 +26,16 @@ bool rStrLen( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// to be a string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
if ( pVar->GetType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// no second parameter
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
if ( pVar->GetNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
// get the contents of the string
CBotString s = pVar->GivValString();
CBotString s = pVar->GetValString();
// puts the length of the stack
pResult->SetValInt( s.GivLength() );
pResult->SetValInt( s.GetLength() );
return true;
}
@ -48,11 +48,11 @@ CBotTypResult cIntStr( CBotVar* &pVar, void* pUser )
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
// to be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( TX_BADPARAM );
// no second parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
if ( pVar->GetNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
// the end result is an integer
return CBotTypResult( CBotTypInt );
@ -68,23 +68,23 @@ bool rStrLeft( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// to be a string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
if ( pVar->GetType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// get the contents of the string
CBotString s = pVar->GivValString();
CBotString s = pVar->GetValString();
// it takes a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// which must be a number
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
if ( pVar->GetType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
// retrieves this number
int n = pVar->GivValInt();
int n = pVar->GetValInt();
// no third parameter
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
if ( pVar->GetNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
// takes the interesting part
s = s.Left( n );
@ -103,19 +103,19 @@ CBotTypResult cStrStrInt( CBotVar* &pVar, void* pUser )
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
// to be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
// it takes a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
// which must be a number
if ( pVar->GivType() > CBotTypDouble )
if ( pVar->GetType() > CBotTypDouble )
return CBotTypResult( TX_BADNUM );
// no third parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
if ( pVar->GetNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
// the end result is a string
return CBotTypResult( CBotTypString );
@ -130,23 +130,23 @@ bool rStrRight( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// to be a string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
if ( pVar->GetType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// get the contents of the string
CBotString s = pVar->GivValString();
CBotString s = pVar->GetValString();
// it takes a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// which must be a number
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
if ( pVar->GetType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
// retrieves this number
int n = pVar->GivValInt();
int n = pVar->GetValInt();
// no third parameter
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
if ( pVar->GetNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
// takes the interesting part
s = s.Right( n );
@ -165,34 +165,34 @@ bool rStrMid( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// to be a string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
if ( pVar->GetType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// get the contents of the string
CBotString s = pVar->GivValString();
CBotString s = pVar->GetValString();
// it takes a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// which must be a number
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
if ( pVar->GetType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
// retrieves this number
int n = pVar->GivValInt();
int n = pVar->GetValInt();
// third parameter optional
if ( pVar->GivNext() != NULL )
if ( pVar->GetNext() != NULL )
{
pVar = pVar->GivNext();
pVar = pVar->GetNext();
// which must be a number
if ( pVar->GivType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
if ( pVar->GetType() > CBotTypDouble ) { ex = TX_BADNUM ; return true; }
// retrieves this number
int l = pVar->GivValInt();
int l = pVar->GetValInt();
// but no fourth parameter
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
if ( pVar->GetNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
// takes the interesting part
s = s.Mid( n, l );
@ -217,28 +217,28 @@ CBotTypResult cStrStrIntInt( CBotVar* &pVar, void* pUser )
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
// to be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
// it takes a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
// which must be a number
if ( pVar->GivType() > CBotTypDouble )
if ( pVar->GetType() > CBotTypDouble )
return CBotTypResult( TX_BADNUM );
// third parameter optional
if ( pVar->GivNext() != NULL )
if ( pVar->GetNext() != NULL )
{
pVar = pVar->GivNext();
pVar = pVar->GetNext();
// which must be a number
if ( pVar->GivType() > CBotTypDouble )
if ( pVar->GetType() > CBotTypDouble )
return CBotTypResult( TX_BADNUM );
// no fourth parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
if ( pVar->GetNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
}
// the end result is a string
@ -255,15 +255,15 @@ bool rStrVal( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// to be a string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
if ( pVar->GetType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// get the contents of the string
CBotString s = pVar->GivValString();
CBotString s = pVar->GetValString();
// but no second parameter
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
if ( pVar->GetNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
float val = GivNumFloat(s);
float val = GetNumFloat(s);
// puts the value on the stack
pResult->SetValFloat( val );
@ -279,11 +279,11 @@ CBotTypResult cFloatStr( CBotVar* &pVar, void* pUser )
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
// to be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
// no second parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
if ( pVar->GetNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
// the end result is a number
return CBotTypResult( CBotTypFloat );
@ -299,23 +299,23 @@ bool rStrFind( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// to be a string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
if ( pVar->GetType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// get the contents of the string
CBotString s = pVar->GivValString();
CBotString s = pVar->GetValString();
// it takes a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// to be a string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
if ( pVar->GetType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// retrieves this number
CBotString s2 = pVar->GivValString();
CBotString s2 = pVar->GetValString();
// no third parameter
if ( pVar->GivNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
if ( pVar->GetNext() != NULL ) { ex = TX_OVERPARAM ; return true; }
// puts the result on the stack
int res = s.Find(s2);
@ -333,19 +333,19 @@ CBotTypResult cIntStrStr( CBotVar* &pVar, void* pUser )
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
// to be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
// it takes a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
// to be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
// no third parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
if ( pVar->GetNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
// the end result is a number
return CBotTypResult( CBotTypInt );
@ -360,13 +360,13 @@ bool rStrUpper( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// to be a string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
if ( pVar->GetType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// get the contents of the string
CBotString s = pVar->GivValString();
CBotString s = pVar->GetValString();
// but no second parameter
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
if ( pVar->GetNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
s.MakeUpper();
@ -385,13 +385,13 @@ bool rStrLower( CBotVar* pVar, CBotVar* pResult, int& ex, void* pUser )
if ( pVar == NULL ) { ex = TX_LOWPARAM ; return true; }
// to be a string
if ( pVar->GivType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
if ( pVar->GetType() != CBotTypString ) { ex = TX_BADSTRING ; return true; }
// get the contents of the string
CBotString s = pVar->GivValString();
CBotString s = pVar->GetValString();
// but no second parameter
if ( pVar->GivNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
if ( pVar->GetNext() != NULL ){ ex = TX_OVERPARAM ; return true; }
s.MakeLower();
@ -410,11 +410,11 @@ CBotTypResult cStrStr( CBotVar* &pVar, void* pUser )
if ( pVar == NULL ) return CBotTypResult( TX_LOWPARAM );
// to be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( TX_BADSTRING );
// no second parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
if ( pVar->GetNext() != NULL ) return CBotTypResult( TX_OVERPARAM );
// the end result is a string
return CBotTypResult( CBotTypString );

14
src/CBot/tests/CBot_console/src/app/CBotConsole.cpp
View File

@ -50,7 +50,7 @@ uint ThreadProc(ThreadInfo *info)
int level = 0;
do
{
CBotVar* t = info->m_pProg->GivStackVars(FN, level--);
CBotVar* t = info->m_pProg->GetStackVars(FN, level--);
if ( FN != FunctionName ) break;
if ( t != NULL )
{
@ -59,8 +59,8 @@ uint ThreadProc(ThreadInfo *info)
{
if (s.IsEmpty()) s+= "Stack -> ";
else s+= " , ";
s += t->GivValString();
t = t->GivNext();
s += t->GetValString();
t = t->GetNext();
}
AfxMessageBox(s);
}
@ -75,7 +75,7 @@ uint ThreadProc(ThreadInfo *info)
{
std::cout << "\nInterrupt\n";
}
else if (info->m_pProg->GivError() == 0)
else if (info->m_pProg->GetError() == 0)
{
time(&t1);
double prog_time = difftime(t0,t1);
@ -98,7 +98,7 @@ long CBotConsole::EndProg()
if (m_pProg->GetError(m_code, m_start, m_end))
{
CBotString TextError;
TextError = CBotProgram::GivErrorText(m_code);
TextError = CBotProgram::GetErrorText(m_code);
std::cout << TextError;
return 1;
}
@ -125,7 +125,7 @@ void CBotConsole::OnOK()
if ( m_pProg->GetError(err, start, end) )
{
CBotString TextError;
TextError = CBotProgram::GivErrorText(err);
TextError = CBotProgram::GetErrorText(err);
std::cout << TextError;
return;
}
@ -162,7 +162,7 @@ bool CBotConsole::OnInitDialog()
// CDialog::OnInitDialog();
std::cout << "Following functions are availible:\n";
for ( int i = 0; i < m_pListe->GivSize(); i++ )
for ( int i = 0; i < m_pListe->GetSize(); i++ )
{
CBotString x = (*m_pListe)[i] + CBotString("\n");
std::cout << x;

10
src/CBot/tests/CBot_console/src/app/CBotDoc.cpp
View File

@ -46,18 +46,18 @@ void CBotDoc::OnRun()
delete m_pProg;
m_pProg = NULL;
TextError = CBotProgram::GivErrorText( code );
TextError = CBotProgram::GetErrorText( code );
std::cout << TextError << std::endl;
return;
}
if( m_Liste.GivSize() == 0 )
if( m_Liste.GetSize() == 0 )
{
std::cout << "No function marked \"extern\" !\n";
return;
}
for ( int i = 0; i < m_Liste.GivSize(); i++ )
for ( int i = 0; i < m_Liste.GetSize(); i++ )
{
int start, stop;
m_pProg->GetPosition(m_Liste[i], start, stop, GetPosNom, GetPosParam);
@ -76,7 +76,7 @@ void CBotDoc::OnRun()
// {
// std::string TextError;
//
// TextError = m_pProg->GivErrorText( dlg.m_code );
// TextError = m_pProg->GetErrorText( dlg.m_code );
//
// std::cout <<TextError;
// }
@ -105,7 +105,7 @@ bool CBotDoc::Compile()
// m_pEdit->SetSel( start, end );
// m_pEdit->SetFocus(); // higlights part of problem
TextError = CBotProgram::GivErrorText( code );
TextError = CBotProgram::GetErrorText( code );
std::cout << TextError ;
return false;

16
src/CBot/tests/CBot_console/src/app/CClass.cpp
View File

@ -6,20 +6,20 @@ void rMajObject( CBotVar* pThis, void* pUser )
{
if (!pThis->IsElemOfClass("object"))
return ;
CBotVar* pPos = pThis->GivItem("position");
CBotVar* pX = pPos->GivItem("x");
CBotVar* pY = pPos->GivItem("y");
CBotVar* pZ = pPos->GivItem("z");
// CBotVar* pPt = pThis->GivItem("transport");
CBotVar* pPos = pThis->GetItem("position");
CBotVar* pX = pPos->GetItem("x");
CBotVar* pY = pPos->GetItem("y");
CBotVar* pZ = pPos->GetItem("z");
// CBotVar* pPt = pThis->GetItem("transport");
CBotString p = pX->GivValString();
CBotString p = pX->GetValString();
// pX->SetValFloat( pUser == (void*)1 ? (float)12.5 : (float)44.4 );
pZ->SetValFloat( (float)0 );
pY->SetValFloat( (float)-3.33 );
pX->SetValFloat( pX->GivValFloat() + 10 ) ;
pX->SetValFloat( pX->GetValFloat() + 10 ) ;
// pX = pThis->GivItem( "xx" );
// pX = pThis->GetItem( "xx" );
// pX->SetValFloat( (float)22 );
// crée une instance sur une classe object

36
src/CBot/tests/CBot_console/src/app/routines.cpp
View File

@ -33,16 +33,16 @@ bool rShow( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser )
{
string::string ss;
ss.LoadString( TX_TYPENAMES + pVar->GivType() );
ss.LoadString( TX_TYPENAMES + pVar->GetType() );
s += ss + " ";
ss = pVar->GivName();
ss = pVar->GetName();
if (ss.IsEmpty()) ss = "<sans nom>";
s += ss + " = ";
s += pVar->GivValString();
s += pVar->GetValString();
s += "\n";
pVar = pVar->GivNext();
pVar = pVar->GetNext();
}
AfxMessageBox(s, MB_OK|MB_ICONINFORMATION);
@ -70,8 +70,8 @@ bool rPrintLn( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser )
while ( pVar != NULL )
{
if ( !s.empty() ) s += " ";
s += pVar->GivValString();
pVar = pVar->GivNext();
s += pVar->GetValString();
pVar = pVar->GetNext();
}
s += "\n";
@ -85,8 +85,8 @@ bool rPrint( CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser )
while ( pVar != NULL )
{
if ( !s.empty() ) s += " ";
s += pVar->GivValString();
pVar = pVar->GivNext();
s += pVar->GetValString();
pVar = pVar->GetNext();
}
s += " ";
std::cout << s;
@ -107,13 +107,13 @@ bool rCPoint( CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception )
{
if ( pVar == NULL )return true; // constructor with no parameters is ok
CBotVar* pX = pThis->GivItem("x");
pX->SetValFloat( pVar->GivValFloat() );
pVar = pVar->GivNext();
CBotVar* pX = pThis->GetItem("x");
pX->SetValFloat( pVar->GetValFloat() );
pVar = pVar->GetNext();
CBotVar* pY = pThis->GivItem("y");
pY->SetValFloat( pVar->GivValFloat() );
pVar = pVar->GivNext();
CBotVar* pY = pThis->GetItem("y");
pY->SetValFloat( pVar->GetValFloat() );
pVar = pVar->GetNext();
return true; // pas d'interruption
}
@ -124,14 +124,14 @@ CBotTypResult cCPoint( CBotVar* pThis, CBotVar* &pVar)
if ( pVar == NULL ) return CBotTypResult(0);
// numeric type of parameter please
if ( pVar->GivType() > CBotTypDouble ) return CBotTypResult(5011);
pVar = pVar->GivNext();
if ( pVar->GetType() > CBotTypDouble ) return CBotTypResult(5011);
pVar = pVar->GetNext();
// there must be a second parameter
if ( pVar == NULL ) return 5028;
// also numeric
if ( pVar->GivType() > CBotTypDouble )return CBotTypResult(5011);
pVar = pVar->GivNext();
if ( pVar->GetType() > CBotTypDouble )return CBotTypResult(5011);
pVar = pVar->GetNext();
// and not more than 2 parameters please
if ( pVar != NULL ) return CBotTypResult(5026);

6
src/object/auto/auto.cpp
View File

@ -91,21 +91,21 @@ void CAuto::Start(int param)
}
// Give a type.
// Gete a type.
bool CAuto::SetType(ObjectType type)
{
return false;
}
// Gives a value.
// Getes a value.
bool CAuto::SetValue(int rank, float value)
{
return false;
}
// Gives the string.
// Getes the string.
bool CAuto::SetString(char *string)
{

6
src/object/auto/autoegg.cpp
View File

@ -115,7 +115,7 @@ void CAutoEgg::Init()
}
// Gives a value.
// Getes a value.
bool CAutoEgg::SetType(ObjectType type)
{
@ -123,7 +123,7 @@ bool CAutoEgg::SetType(ObjectType type)
return true;
}
// Gives a value.
// Getes a value.
bool CAutoEgg::SetValue(int rank, float value)
{
@ -132,7 +132,7 @@ bool CAutoEgg::SetValue(int rank, float value)
return true;
}
// Gives the string.
// Getes the string.
bool CAutoEgg::SetString(char *string)
{

6
src/object/motion/motion.cpp
View File

@ -201,7 +201,7 @@ bool CMotion::Read(char *line)
}
// Gives the linear vibration.
// Getes the linear vibration.
void CMotion::SetLinVibration(Math::Vector dir)
{
@ -213,7 +213,7 @@ Math::Vector CMotion::RetLinVibration()
return m_linVibration;
}
// Gives the circular vibration.
// Getes the circular vibration.
void CMotion::SetCirVibration(Math::Vector dir)
{
@ -225,7 +225,7 @@ Math::Vector CMotion::RetCirVibration()
return m_cirVibration;
}
// Gives the tilt.
// Getes the tilt.
void CMotion::SetInclinaison(Math::Vector dir)
{

2
src/object/motion/motiontoto.cpp
View File

@ -219,7 +219,7 @@ void CMotionToto::StopDisplayInfo()
m_bQuickPos = true;
}
// Gives the position of the mouse.
// Getes the position of the mouse.
void CMotionToto::SetMousePos(Math::Point pos)
{

60
src/object/object.cpp
View File

@ -131,83 +131,83 @@ void uObject(CBotVar* botThis, void* user)
physics = object->RetPhysics();
// Updates the object's type.
pVar = botThis->GivItemList(); // "category"
pVar = botThis->GetItemList(); // "category"
type = object->RetType();
pVar->SetValInt(type, object->RetName());
// Updates the position of the object.
pVar = pVar->GivNext(); // "position"
pVar = pVar->GetNext(); // "position"
if ( object->RetTruck() == 0 )
{
pos = object->RetPosition(0);
pos.y -= object->RetWaterLevel(); // relative to sea level!
pSub = pVar->GivItemList(); // "x"
pSub = pVar->GetItemList(); // "x"
pSub->SetValFloat(pos.x/g_unit);
pSub = pSub->GivNext(); // "y"
pSub = pSub->GetNext(); // "y"
pSub->SetValFloat(pos.z/g_unit);
pSub = pSub->GivNext(); // "z"
pSub = pSub->GetNext(); // "z"
pSub->SetValFloat(pos.y/g_unit);
}
else // object transported?
{
pSub = pVar->GivItemList(); // "x"
pSub = pVar->GetItemList(); // "x"
pSub->SetInit(IS_NAN);
pSub = pSub->GivNext(); // "y"
pSub = pSub->GetNext(); // "y"
pSub->SetInit(IS_NAN);
pSub = pSub->GivNext(); // "z"
pSub = pSub->GetNext(); // "z"
pSub->SetInit(IS_NAN);
}
// Updates the angle.
pos = object->RetAngle(0);
pos += object->RetInclinaison();
pVar = pVar->GivNext(); // "orientation"
pVar = pVar->GetNext(); // "orientation"
pVar->SetValFloat(360.0f-Math::Mod(pos.y*180.0f/Math::PI, 360.0f));
pVar = pVar->GivNext(); // "pitch"
pVar = pVar->GetNext(); // "pitch"
pVar->SetValFloat(pos.z*180.0f/Math::PI);
pVar = pVar->GivNext(); // "roll"
pVar = pVar->GetNext(); // "roll"
pVar->SetValFloat(pos.x*180.0f/Math::PI);
// Updates the energy level of the object.
pVar = pVar->GivNext(); // "energyLevel"
pVar = pVar->GetNext(); // "energyLevel"
value = object->RetEnergy();
pVar->SetValFloat(value);
// Updates the shield level of the object.
pVar = pVar->GivNext(); // "shieldLevel"
pVar = pVar->GetNext(); // "shieldLevel"
value = object->RetShield();
pVar->SetValFloat(value);
// Updates the temperature of the reactor.
pVar = pVar->GivNext(); // "temperature"
pVar = pVar->GetNext(); // "temperature"
if ( physics == 0 ) value = 0.0f;
else value = 1.0f-physics->RetReactorRange();
pVar->SetValFloat(value);
// Updates the height above the ground.
pVar = pVar->GivNext(); // "altitude"
pVar = pVar->GetNext(); // "altitude"
if ( physics == 0 ) value = 0.0f;
else value = physics->RetFloorHeight();
pVar->SetValFloat(value/g_unit);
// Updates the lifetime of the object.
pVar = pVar->GivNext(); // "lifeTime"
pVar = pVar->GetNext(); // "lifeTime"
value = object->RetAbsTime();
pVar->SetValFloat(value);
// Updates the material of the object.
pVar = pVar->GivNext(); // "material"
pVar = pVar->GetNext(); // "material"
iValue = object->RetMaterial();
pVar->SetValInt(iValue);
// Updates the type of battery.
pVar = pVar->GivNext(); // "energyCell"
pVar = pVar->GetNext(); // "energyCell"
power = object->RetPower();
if ( power == 0 ) pVar->SetPointer(0);
else pVar->SetPointer(power->RetBotVar());
// Updates the transported object's type.
pVar = pVar->GivNext(); // "load"
pVar = pVar->GetNext(); // "load"
fret = object->RetFret();
if ( fret == 0 ) pVar->SetPointer(0);
else pVar->SetPointer(fret->RetBotVar());
@ -1468,7 +1468,7 @@ void CObject::FloorAdjust()
}
// Gives the linear vibration.
// Getes the linear vibration.
void CObject::SetLinVibration(Math::Vector dir)
{
@ -1486,7 +1486,7 @@ Math::Vector CObject::RetLinVibration()
return m_linVibration;
}
// Gives the circular vibration.
// Getes the circular vibration.
void CObject::SetCirVibration(Math::Vector dir)
{
@ -1504,7 +1504,7 @@ Math::Vector CObject::RetCirVibration()
return m_cirVibration;
}
// Gives the inclination.
// Getes the inclination.
void CObject::SetInclinaison(Math::Vector dir)
{
@ -1523,7 +1523,7 @@ Math::Vector CObject::RetInclinaison()
}
// Gives the position of center of the object.
// Getes the position of center of the object.
void CObject::SetPosition(int part, const Math::Vector &pos)
{
@ -1649,7 +1649,7 @@ Math::Vector CObject::RetPosition(int part)
return m_objectPart[part].position;
}
// Gives the rotation around three axis.
// Getes the rotation around three axis.
void CObject::SetAngle(int part, const Math::Vector &angle)
{
@ -1667,7 +1667,7 @@ Math::Vector CObject::RetAngle(int part)
return m_objectPart[part].angle;
}
// Gives the rotation about the axis Y.
// Getes the rotation about the axis Y.
void CObject::SetAngleY(int part, float angle)
{
@ -1680,7 +1680,7 @@ void CObject::SetAngleY(int part, float angle)
}
}
// Gives the rotation about the axis X.
// Getes the rotation about the axis X.
void CObject::SetAngleX(int part, float angle)
{
@ -1688,7 +1688,7 @@ void CObject::SetAngleX(int part, float angle)
m_objectPart[part].bRotate = true; // it will recalculate the matrices
}
// Gives the rotation about the axis Z.
// Getes the rotation about the axis Z.
void CObject::SetAngleZ(int part, float angle)
{
@ -1712,7 +1712,7 @@ float CObject::RetAngleZ(int part)
}
// Gives the global zoom.
// Getes the global zoom.
void CObject::SetZoom(int part, float zoom)
{
@ -7431,7 +7431,7 @@ void CObject::UpdateSelectParticule()
}
// Gives the pointer to the current script execution.
// Getes the pointer to the current script execution.
void CObject::SetRunScript(CScript* script)
{
@ -7498,7 +7498,7 @@ int CObject::RetDefRank()
}
// Gives the object name for the tooltip.
// Getes the object name for the tooltip.
bool CObject::GetTooltipName(char* name)
{

132
src/object/robotmain.cpp
View File

@ -145,25 +145,25 @@ bool rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exceptio
if ( pVar == NULL ) return true;
// must be a character string
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
if ( pVar->GetType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
CBotString filename = pVar->GivValString();
CBotString filename = pVar->GetValString();
PrepareFilename(filename);
// there may be a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar != NULL )
{
// recover mode
mode = pVar->GivValString();
mode = pVar->GetValString();
if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return false; }
// no third parameter
if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return false; }
if ( pVar->GetNext() != NULL ) { Exception = CBotErrOverParam; return false; }
}
// saves the file name
pVar = pThis->GivItem("filename");
pVar = pThis->GetItem("filename");
pVar->SetValString(filename);
if ( ! mode.IsEmpty() )
@ -175,7 +175,7 @@ bool rfconstruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exceptio
m_CompteurFileOpen ++;
// save the channel file
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
pVar->SetValInt((long)pFile);
}
@ -189,18 +189,18 @@ CBotTypResult cfconstruct (CBotVar* pThis, CBotVar* &pVar)
if ( pVar == NULL ) return CBotTypResult( 0 );
// must be a character string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
// there may be a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar != NULL )
{
// which must be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
// no third parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
if ( pVar->GetNext() != NULL ) return CBotTypResult( CBotErrOverParam );
}
// the result is void (constructor)
@ -214,12 +214,12 @@ CBotTypResult cfconstruct (CBotVar* pThis, CBotVar* &pVar)
bool rfdestruct (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
{
// retrieve the item "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
// don't open? no problem :)
if ( pVar->GivInit() != IS_DEF) return true;
if ( pVar->GetInit() != IS_DEF) return true;
FILE* pFile= (FILE*)pVar->GivValInt();
FILE* pFile= (FILE*)pVar->GetValInt();
fclose(pFile);
m_CompteurFileOpen --;
@ -239,38 +239,38 @@ bool rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
if ( pVar == NULL ) { Exception = CBotErrLowParam; return false; }
// which must be a character string
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
if ( pVar->GetType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
// There may be a second parameter
if ( pVar->GivNext() != NULL )
if ( pVar->GetNext() != NULL )
{
// if the first parameter is the file name
CBotString filename = pVar->GivValString();
CBotString filename = pVar->GetValString();
PrepareFilename(filename);
// saves the file name
CBotVar* pVar2 = pThis->GivItem("filename");
CBotVar* pVar2 = pThis->GetItem("filename");
pVar2->SetValString(filename);
// next parameter is the mode
pVar = pVar -> GivNext();
pVar = pVar -> GetNext();
}
CBotString mode = pVar->GivValString();
CBotString mode = pVar->GetValString();
if ( mode != "r" && mode != "w" ) { Exception = CBotErrBadParam; return false; }
// no third parameter
if ( pVar->GivNext() != NULL ) { Exception = CBotErrOverParam; return false; }
if ( pVar->GetNext() != NULL ) { Exception = CBotErrOverParam; return false; }
// retrieve the item "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
// which must not be initialized
if ( pVar->GivInit() == IS_DEF) { Exception = CBotErrFileOpen; return false; }
if ( pVar->GetInit() == IS_DEF) { Exception = CBotErrFileOpen; return false; }
// file contains the name
pVar = pThis->GivItem("filename");
CBotString filename = pVar->GivValString();
pVar = pThis->GetItem("filename");
CBotString filename = pVar->GetValString();
PrepareFilename(filename); // if the name was h.filename attribute = "...";
@ -285,7 +285,7 @@ bool rfopen (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
m_CompteurFileOpen ++;
// Registered the channel file
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
pVar->SetValInt((long)pFile);
pResult->SetValInt(true);
@ -299,19 +299,19 @@ CBotTypResult cfopen (CBotVar* pThis, CBotVar* &pVar)
if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );
// which must be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
// there may be a second parameter
pVar = pVar->GivNext();
pVar = pVar->GetNext();
if ( pVar != NULL )
{
// which must be a string
if ( pVar->GivType() != CBotTypString )
if ( pVar->GetType() != CBotTypString )
return CBotTypResult( CBotErrBadString );
// no third parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
if ( pVar->GetNext() != NULL ) return CBotTypResult( CBotErrOverParam );
}
// the result is bool
@ -328,11 +328,11 @@ bool rfclose (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
if ( pVar != NULL ) return CBotErrOverParam;
// retrieve the item "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
if ( pVar->GetInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
FILE* pFile= (FILE*)pVar->GivValInt();
FILE* pFile= (FILE*)pVar->GetValInt();
fclose(pFile);
m_CompteurFileOpen --;
@ -360,16 +360,16 @@ bool rfwrite (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
if ( pVar == NULL ) { Exception = CBotErrLowParam; return false; }
// which must be a character string
if ( pVar->GivType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
if ( pVar->GetType() != CBotTypString ) { Exception = CBotErrBadString; return false; }
CBotString param = pVar->GivValString();
CBotString param = pVar->GetValString();
// retrieve the item "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
if ( pVar->GetInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
FILE* pFile= (FILE*)pVar->GivValInt();
FILE* pFile= (FILE*)pVar->GetValInt();
int res = fputs(param+CBotString("\n"), pFile);
@ -386,10 +386,10 @@ CBotTypResult cfwrite (CBotVar* pThis, CBotVar* &pVar)
if ( pVar == NULL ) return CBotTypResult( CBotErrLowParam );
// which must be a character string
if ( pVar->GivType() != CBotTypString ) return CBotTypResult( CBotErrBadString );
if ( pVar->GetType() != CBotTypString ) return CBotTypResult( CBotErrBadString );
// no other parameter
if ( pVar->GivNext() != NULL ) return CBotTypResult( CBotErrOverParam );
if ( pVar->GetNext() != NULL ) return CBotTypResult( CBotErrOverParam );
// the function returns a void result
return CBotTypResult( 0 );
@ -404,11 +404,11 @@ bool rfread (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
if ( pVar != NULL ) { Exception = CBotErrOverParam; return false; }
// retrieve the item "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
if ( pVar->GetInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
FILE* pFile= (FILE*)pVar->GivValInt();
FILE* pFile= (FILE*)pVar->GetValInt();
char chaine[2000];
int i;
@ -445,11 +445,11 @@ bool rfeof (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception)
if ( pVar != NULL ) { Exception = CBotErrOverParam; return false; }
// retrieve the item "handle"
pVar = pThis->GivItem("handle");
pVar = pThis->GetItem("handle");
if ( pVar->GivInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
if ( pVar->GetInit() != IS_DEF) { Exception = CBotErrNotOpen; return false; }
FILE* pFile= (FILE*)pVar->GivValInt();
FILE* pFile= (FILE*)pVar->GetValInt();
pResult->SetValInt( feof( pFile ) );
@ -516,13 +516,13 @@ CBotTypResult cPoint(CBotVar* pThis, CBotVar* &var)
if ( var == NULL ) return CBotTypResult(0); // ok if no parameter
// First parameter (x):
if ( var->GivType() > CBotTypDouble ) return CBotTypResult(CBotErrBadNum);
var = var->GivNext();
if ( var->GetType() > CBotTypDouble ) return CBotTypResult(CBotErrBadNum);
var = var->GetNext();
// Second parameter (y):
if ( var == NULL ) return CBotTypResult(CBotErrLowParam);
if ( var->GivType() > CBotTypDouble ) return CBotTypResult(CBotErrBadNum);
var = var->GivNext();
if ( var->GetType() > CBotTypDouble ) return CBotTypResult(CBotErrBadNum);
var = var->GetNext();
// Third parameter (z):
if ( var == NULL ) // only 2 parameters?
@ -530,8 +530,8 @@ CBotTypResult cPoint(CBotVar* pThis, CBotVar* &var)
return CBotTypResult(0); // this function returns void
}
if ( var->GivType() > CBotTypDouble ) return CBotTypResult(CBotErrBadNum);
var = var->GivNext();
if ( var->GetType() > CBotTypDouble ) return CBotTypResult(CBotErrBadNum);
var = var->GetNext();
if ( var != NULL ) return CBotTypResult(CBotErrOverParam);
return CBotTypResult(0); // this function returns void
@ -545,49 +545,49 @@ bool rPoint(CBotVar* pThis, CBotVar* var, CBotVar* pResult, int& Exception)
if ( var == NULL ) return true; // constructor with no parameters is ok
if ( var->GivType() > CBotTypDouble )
if ( var->GetType() > CBotTypDouble )
{
Exception = CBotErrBadNum; return false;
}
pX = pThis->GivItem("x");
pX = pThis->GetItem("x");
if ( pX == NULL )
{
Exception = CBotErrUndefItem; return false;
}
pX->SetValFloat( var->GivValFloat() );
var = var->GivNext();
pX->SetValFloat( var->GetValFloat() );
var = var->GetNext();
if ( var == NULL )
{
Exception = CBotErrLowParam; return false;
}
if ( var->GivType() > CBotTypDouble )
if ( var->GetType() > CBotTypDouble )
{
Exception = CBotErrBadNum; return false;
}
pY = pThis->GivItem("y");
pY = pThis->GetItem("y");
if ( pY == NULL )
{
Exception = CBotErrUndefItem; return false;
}
pY->SetValFloat( var->GivValFloat() );
var = var->GivNext();
pY->SetValFloat( var->GetValFloat() );
var = var->GetNext();
if ( var == NULL )
{
return true; // ok with only two parameters
}
pZ = pThis->GivItem("z");
pZ = pThis->GetItem("z");
if ( pZ == NULL )
{
Exception = CBotErrUndefItem; return false;
}
pZ->SetValFloat( var->GivValFloat() );
var = var->GivNext();
pZ->SetValFloat( var->GetValFloat() );
var = var->GetNext();
if ( var != NULL )
{
@ -6451,7 +6451,7 @@ bool CRobotMain::IOWriteScene(char *filename, char *filecbot, char *info)
version = 1;
fWrite(&version, sizeof(long), 1, file); // version of COLOBOT
version = CBotProgram::GivVersion();
version = CBotProgram::GetVersion();
fWrite(&version, sizeof(long), 1, file); // version of CBOT
objRank = 0;
@ -6687,7 +6687,7 @@ CObject* CRobotMain::IOReadScene(char *filename, char *filecbot)
if ( version == 1 )
{
fRead(&version, sizeof(long), 1, file); // version of CBOT
if ( version == CBotProgram::GivVersion() )
if ( version == CBotProgram::GetVersion() )
{
objRank = 0;
for ( i=0 ; i<1000000 ; i++ )
@ -7200,7 +7200,7 @@ void CRobotMain::SetGamerName(char *name)
ReadFreeParam();
}
// Gives the player's name.
// Getes the player's name.
char* CRobotMain::RetGamerName()
{