immibis
/
colobot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
colobot/src/CBot/CBot.h

1625 lines
43 KiB
C++
Raw Blame History

// * This file is part of the COLOBOT source code
// * Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
// *
// * This program is free software: you can redistribute it and/or modify
// * it under the terms of the GNU General Public License as published by
// * the Free Software Foundation, either version 3 of the License, or
// * (at your option) any later version.
// *
// * This program is distributed in the hope that it will be useful,
// * but WITHOUT ANY WARRANTY; without even the implied warranty of
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// * GNU General Public License for more details.
// *
// * You should have received a copy of the GNU General Public License
// * along with this program. If not, see .
// derni<6E>re r<>vision : 03/10/2002 DD
#define EXTENDS TRUE
#include "resource.h"
#include "CBotDll.h" // d<>finitions publiques
#include "CBotToken.h" // gestion des tokens
#define STACKRUN TRUE // reprise de l'ex<65>cution direct sur une routine suspendue
#define STACKMEM TRUE // pr<70>r<EFBFBD>serve la m<>moire pour la pile d'ex<65>cution
#define MAXSTACK 990 // taille du stack r<>serv<72>
#define EOX (CBotStack*)-1 // marqueur condition sp<73>ciale
/////////////////////////////////////////////////////////////////////
// r<>sum<75> des classes utilis<69>es, d<>finies ci-apr<70>s
class CBotCompExpr; // une expression telle que
// () <= ()
class CBotAddExpr; // une expression telle que
// () + ()
class CBotParExpr; // un <20>l<EFBFBD>ment de base ou entre parenth<74>se
// Toto.truc
// 12.5
// "chaine"
// ( expression )
class CBotExprVar; // un nom de variable tel que
// Toto
// chose.truc.machin
class CBotWhile; // while (...) {...};
class CBotIf; // if (...) {...} else {...}
class CBotDefParam; // liste de param<61>tres d'une fonction
class CBotRepeat; // repeat (nb) {...}
////////////////////////////////////////////////////////////////////////
// Gestion de la pile d'ex<65>cution
////////////////////////////////////////////////////////////////////////
// en fait, en externe, la seule chose qu'il est possible de faire
// c'est de cr<63>er une instance d'une pile
// pour l'utiliser pour la routine CBotProgram::Execute(CBotStack)
class CBotStack
{
private:
CBotStack* m_next;
CBotStack* m_next2;
CBotStack* m_prev;
friend class CBotInstArray;
#ifdef _DEBUG
int m_index;
#endif
int m_state;
int m_step;
static int m_error;
static int m_start;
static int m_end;
static
CBotVar* m_retvar; // r<>sultat d'un return
CBotVar* m_var; // r<>sultat des op<6F>rations
CBotVar* m_listVar; // les variables d<>clar<61>es <20> ce niveau
BOOL m_bBlock; // fait partie d'un bloc (variables sont locales <20> ce bloc)
BOOL m_bOver; // limites de la pile ?
// BOOL m_bDontDelete; // sp<73>cial, ne pas d<>truire les variables au delete
CBotProgram* m_prog; // les fonctions d<>finies par user
static
int m_initimer;
static
int m_timer;
static
CBotString m_labelBreak;
static
void* m_pUser;
CBotInstr* m_instr; // l'instruction correspondante
BOOL m_bFunc; // une entr<74>e d'une fonction ?
CBotCall* m_call; // point de reprise dans un call extern
friend class CBotTry;
public:
#if STACKMEM
static
CBotStack* FirstStack();
void Delete();
#endif
CBotStack(CBotStack* ppapa);
~CBotStack();
BOOL StackOver();
int GivError(int& start, int& end);
int GivError(); // rend le num<75>ro d'erreur retourn<72>
void Reset(void* pUser); // plus d'erreur, timer au d<>but
void SetType(CBotTypResult& type); // d<>termine le type
int GivType(int mode = 0); // donne le type de valeur sur le stack
CBotTypResult GivTypResult(int mode = 0); // donne le type complet de valeur sur le stack
// void AddVar(CBotVar* p, BOOL bDontDelete=FALSE); // ajoute une variable locale
void AddVar(CBotVar* p); // ajoute une variable locale
// void RestoreVar(CBotVar* pVar);
CBotVar* FindVar(CBotToken* &p, BOOL bUpdate = FALSE,
BOOL bModif = FALSE); // trouve une variable
CBotVar* FindVar(CBotToken& Token, BOOL bUpdate = FALSE,
BOOL bModif = FALSE);
CBotVar* FindVar(const char* name);
CBotVar* FindVar(long ident, BOOL bUpdate = FALSE,
BOOL bModif = FALSE);
CBotVar* CopyVar(CBotToken& Token, BOOL bUpdate = FALSE); // trouve et rend une copie
CBotStack* AddStack(CBotInstr* instr = NULL, BOOL bBlock = FALSE); // <20>tend le stack
CBotStack* AddStackEOX(CBotCall* instr = NULL, BOOL bBlock = FALSE); // <20>tend le stack
CBotStack* RestoreStack(CBotInstr* instr = NULL);
CBotStack* RestoreStackEOX(CBotCall* instr = NULL);
CBotStack* AddStack2(BOOL bBlock = FALSE); // <20>tend le stack
BOOL Return(CBotStack* pFils); // transmet le r<>sultat au dessus
BOOL ReturnKeep(CBotStack* pFils); // transmet le r<>sultat sans r<>duire la pile
BOOL BreakReturn(CBotStack* pfils, const char* name = NULL);
// en cas de break <20>ventuel
BOOL IfContinue(int state, const char* name);
// ou de "continue"
BOOL IsOk();
BOOL SetState(int n, int lim = -10); // s<>lectionne un <20>tat
int GivState(); // dans quel <20>tat j'<27>re ?
BOOL IncState(int lim = -10); // passe <20> l'<27>tat suivant
BOOL IfStep(); // faire du pas <20> pas ?
BOOL Execute();
void SetVar( CBotVar* var );
void SetCopyVar( CBotVar* var );
CBotVar* GivVar();
CBotVar* GivCopyVar();
CBotVar* GivPtVar();
BOOL GivRetVar(BOOL bRet);
long GivVal();
void SetStartError(int pos);
void SetError(int n, CBotToken* token = NULL);
void SetPosError(CBotToken* token);
void ResetError(int n, int start, int end);
void SetBreak(int val, const char* name);
void SetBotCall(CBotProgram* p);
CBotProgram* GivBotCall(BOOL bFirst = FALSE);
void* GivPUser();
BOOL GivBlock();
// BOOL ExecuteCall(CBotToken* token, CBotVar** ppVar, CBotTypResult& rettype);
BOOL ExecuteCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotTypResult& rettype);
void RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar);
BOOL SaveState(FILE* pf);
BOOL RestoreState(FILE* pf, CBotStack* &pStack);
static
void SetTimer(int n);
void GetRunPos(const char* &FunctionName, int &start, int &end);
CBotVar* GivStackVars(const char* &FunctionName, int level);
int m_temp;
};
// les routines inline doivent <20>tre d<>clar<61>es dans le fichier .h
inline BOOL CBotStack::IsOk()
{
return (m_error == 0);
}
inline int CBotStack::GivState()
{
return m_state;
}
inline int CBotStack::GivError()
{
return m_error;
}
////////////////////////////////////////////////////////////////////////
// Gestion de la pile de compilation
////////////////////////////////////////////////////////////////////////
class CBotCStack
{
private:
CBotCStack* m_next;
CBotCStack* m_prev;
static
int m_error;
static
int m_end;
int m_start;
CBotVar* m_var; // r<>sultat des op<6F>rations
BOOL m_bBlock; // fait partie d'un bloc (variables sont locales <20> ce bloc)
CBotVar* m_listVar;
static
CBotProgram* m_prog; // liste des fonctions compil<69>es
static
CBotTypResult m_retTyp;
// static
// CBotToken* m_retClass;
public:
CBotCStack(CBotCStack* ppapa);
~CBotCStack();
BOOL IsOk();
int GivError();
int GivError(int& start, int& end);
// rend le num<75>ro d'erreur retourn<72>
void SetType(CBotTypResult& type);// d<>termine le type
CBotTypResult GivTypResult(int mode = 0); // donne le type de valeur sur le stack
int GivType(int mode = 0); // donne le type de valeur sur le stack
CBotClass* GivClass(); // donne la classe de la valeur sur le stack
void AddVar(CBotVar* p); // ajoute une variable locale
CBotVar* FindVar(CBotToken* &p); // trouve une variable
CBotVar* FindVar(CBotToken& Token);
BOOL CheckVarLocal(CBotToken* &pToken);
CBotVar* CopyVar(CBotToken& Token); // trouve et rend une copie
CBotCStack* TokenStack(CBotToken* pToken = NULL, BOOL bBlock = FALSE);
CBotInstr* Return(CBotInstr* p, CBotCStack* pParent); // transmet le r<>sultat au dessus
CBotFunction* ReturnFunc(CBotFunction* p, CBotCStack* pParent); // transmet le r<>sultat au dessus
void SetVar( CBotVar* var );
void SetCopyVar( CBotVar* var );
CBotVar* GivVar();
void SetStartError(int pos);
void SetError(int n, int pos);
void SetError(int n, CBotToken* p);
void ResetError(int n, int start, int end);
void SetRetType(CBotTypResult& type);
CBotTypResult GivRetType();
// void SetBotCall(CBotFunction* &pFunc);
void SetBotCall(CBotProgram* p);
CBotProgram* GivBotCall();
CBotTypResult CompileCall(CBotToken* &p, CBotVar** ppVars, long& nIdent);
BOOL CheckCall(CBotToken* &pToken, CBotDefParam* pParam);
BOOL NextToken(CBotToken* &p);
};
extern BOOL SaveVar(FILE* pf, CBotVar* pVar);
/////////////////////////////////////////////////////////////////////
// classes d<>finissant une instruction
class CBotInstr
{
private:
static
CBotStringArray
m_labelLvl;
protected:
CBotToken m_token; // conserve le token
CBotString name; // debug
CBotInstr* m_next; // instructions cha<68>n<EFBFBD>es
CBotInstr* m_next2b; // seconde liste pour d<>finition en cha<68>ne
CBotInstr* m_next3; // troisi<73>me liste pour les indices et champs
CBotInstr* m_next3b; // n<>cessaire pour la d<>claration des tableaux
/*
par exemple, le programme suivant
int x[]; x[1] = 4;
int y[x[1]][10], z;
va g<>n<EFBFBD>r<EFBFBD>
CBotInstrArray
m_next3b-> CBotEmpty
m_next->
CBotExpression ....
m_next->
CBotInstrArray
m_next3b-> CBotExpression ('x') ( m_next3-> CBotIndexExpr ('1') )
m_next3b-> CBotExpression ('10')
m_next2-> 'z'
m_next->...
*/
static
int m_LoopLvl;
friend class CBotClassInst;
friend class CBotInt;
friend class CBotListArray;
public:
CBotInstr();
virtual
~CBotInstr();
DllExport//debug
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
static
CBotInstr* CompileArray(CBotToken* &p, CBotCStack* pStack, CBotTypResult type, BOOL first = TRUE);
virtual
BOOL Execute(CBotStack* &pj);
virtual
BOOL Execute(CBotStack* &pj, CBotVar* pVar);
virtual
void RestoreState(CBotStack* &pj, BOOL bMain);
virtual
BOOL ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);
virtual
BOOL ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend);
virtual
void RestoreStateVar(CBotStack* &pile, BOOL bMain);
virtual
BOOL CompCase(CBotStack* &pj, int val);
void SetToken(CBotToken* p);
void SetToken(CBotString* name, int start=0, int end=0);
int GivTokenType();
CBotToken* GivToken();
void AddNext(CBotInstr* n);
CBotInstr* GivNext();
void AddNext3(CBotInstr* n);
CBotInstr* GivNext3();
void AddNext3b(CBotInstr* n);
CBotInstr* GivNext3b();
static
void IncLvl(CBotString& label);
static
void IncLvl();
static
void DecLvl();
static
BOOL ChkLvl(CBotString& label, int type);
BOOL IsOfClass(CBotString name);
};
class CBotWhile : public CBotInstr
{
private:
CBotInstr* m_Condition; // la condition
CBotInstr* m_Block; // les instructions
CBotString m_label; // une <20>tiquette s'il y a
public:
CBotWhile();
~CBotWhile();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotRepeat : public CBotInstr
{
private:
CBotInstr* m_NbIter; // le nombre d'it<69>ration
CBotInstr* m_Block; // les instructions
CBotString m_label; // une <20>tiquette s'il y a
public:
CBotRepeat();
~CBotRepeat();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotDo : public CBotInstr
{
private:
CBotInstr* m_Block; // les instructions
CBotInstr* m_Condition; // la condition
CBotString m_label; // une <20>tiquette s'il y a
public:
CBotDo();
~CBotDo();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotFor : public CBotInstr
{
private:
CBotInstr* m_Init; // intruction initiale
CBotInstr* m_Test; // la condition de test
CBotInstr* m_Incr; // instruction pour l'incr<63>ment
CBotInstr* m_Block; // les instructions
CBotString m_label; // une <20>tiquette s'il y a
public:
CBotFor();
~CBotFor();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotBreak : public CBotInstr
{
private:
CBotString m_label; // une <20>tiquette s'il y a
public:
CBotBreak();
~CBotBreak();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotReturn : public CBotInstr
{
private:
CBotInstr* m_Instr; // le param<61>tre <20> retourner
public:
CBotReturn();
~CBotReturn();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotSwitch : public CBotInstr
{
private:
CBotInstr* m_Value; // value <20> chercher
CBotInstr* m_Block; // les instructions
public:
CBotSwitch();
~CBotSwitch();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotCase : public CBotInstr
{
private:
CBotInstr* m_Value; // valeur <20> comparer
public:
CBotCase();
~CBotCase();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
BOOL CompCase(CBotStack* &pj, int val);
};
class CBotCatch : public CBotInstr
{
private:
CBotInstr* m_Block; // les instructions
CBotInstr* m_Cond; // la condition
CBotCatch* m_next; // le catch suivant
friend class CBotTry;
public:
CBotCatch();
~CBotCatch();
static
CBotCatch* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL TestCatch(CBotStack* &pj, int val);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
void RestoreCondState(CBotStack* &pj, BOOL bMain);
};
class CBotTry : public CBotInstr
{
private:
CBotInstr* m_Block; // les instructions
CBotCatch* m_ListCatch; // les catches
CBotInstr* m_FinalInst; // instruction finale
public:
CBotTry();
~CBotTry();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotThrow : public CBotInstr
{
private:
CBotInstr* m_Value; // la valeur <20> envoyer
public:
CBotThrow();
~CBotThrow();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotStartDebugDD : public CBotInstr
{
private:
public:
CBotStartDebugDD();
~CBotStartDebugDD();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
};
class CBotIf : public CBotInstr
{
private:
CBotInstr* m_Condition; // la condition
CBotInstr* m_Block; // les instructions
CBotInstr* m_BlockElse; // les instructions
public:
CBotIf();
~CBotIf();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// d<>finition d'un nombre entier
class CBotInt : public CBotInstr
{
private:
CBotInstr* m_var; // la variable <20> initialiser
CBotInstr* m_expr; // la valeur <20> mettre, s'il y a
/// CBotInstr* m_next; // plusieurs d<>finitions encha<68>n<EFBFBD>es
public:
CBotInt();
~CBotInt();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont = FALSE, BOOL noskip = FALSE);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// d<>finition d'un tableau
class CBotInstArray : public CBotInstr
{
private:
CBotInstr* m_var; // la variable <20> initialiser
CBotInstr* m_listass; // liste d'assignations pour le tableau
CBotTypResult
m_typevar; // type d'<27>l<EFBFBD>ments
// CBotString m_ClassName;
public:
CBotInstArray();
~CBotInstArray();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResult type);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// d<>finition d'une liste d'assignation pour un tableau
// int [ ] a [ ] = ( ( 1, 2, 3 ) , ( 3, 2, 1 ) ) ;
class CBotListArray : public CBotInstr
{
private:
CBotInstr* m_expr; // expression pour un <20>l<EFBFBD>ment
// les autres sont cha<68>n<EFBFBD>s avec CBotInstr::m_next3;
public:
CBotListArray();
~CBotListArray();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, CBotTypResult type);
BOOL Execute(CBotStack* &pj, CBotVar* pVar);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotEmpty : public CBotInstr
{
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// d<>finition d'un bool<6F>en
class CBotBoolean : public CBotInstr
{
private:
CBotInstr* m_var; // la variable <20> initialiser
CBotInstr* m_expr; // la valeur <20> mettre, s'il y a
public:
CBotBoolean();
~CBotBoolean();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont = FALSE, BOOL noskip=FALSE);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// d<>finition d'un nombre r<>el
class CBotFloat : public CBotInstr
{
private:
CBotInstr* m_var; // la variable <20> initialiser
CBotInstr* m_expr; // la valeur <20> mettre, s'il y a
public:
CBotFloat();
~CBotFloat();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont = FALSE, BOOL noskip=FALSE);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// d<>finition d'un el<65>ment string
class CBotIString : public CBotInstr
{
private:
CBotInstr* m_var; // la variable <20> initialiser
CBotInstr* m_expr; // la valeur <20> mettre, s'il y a
public:
CBotIString();
~CBotIString();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, BOOL cont = FALSE, BOOL noskip=FALSE);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// d<>finition d'un el<65>ment dans une classe quelconque
class CBotClassInst : public CBotInstr
{
private:
CBotInstr* m_var; // la variable <20> initialiser
CBotClass* m_pClass; // r<>f<EFBFBD>rence <20> la classe
CBotInstr* m_Parameters; // les param<61>tres <20> <20>valuer pour le constructeur
CBotInstr* m_expr; // la valeur <20> mettre, s'il y a
BOOL m_hasParams; // il y a des param<61>tres ?
long m_nMethodeIdent;
public:
CBotClassInst();
~CBotClassInst();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, CBotClass* pClass = NULL);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotCondition : public CBotInstr
{
private:
public:
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
};
// left op<6F>rande
// n'accepte que les expressions pouvant <20>tre <20> gauche d'une assignation
class CBotLeftExpr : public CBotInstr
{
private:
long m_nIdent;
public:
CBotLeftExpr();
~CBotLeftExpr();
static
CBotLeftExpr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pStack, CBotStack* array);
BOOL ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);
BOOL ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep);
void RestoreStateVar(CBotStack* &pile, BOOL bMain);
};
// gestion des champs d'une instance
class CBotFieldExpr : public CBotInstr
{
private:
friend class CBotExpression;
int m_nIdent;
public:
CBotFieldExpr();
~CBotFieldExpr();
void SetUniqNum(int num);
// static
// CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);
BOOL ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend);
void RestoreStateVar(CBotStack* &pj, BOOL bMain);
};
// gestion des index dans les tableaux
class CBotIndexExpr : public CBotInstr
{
private:
CBotInstr* m_expr; // expression pour le calcul de l'index
friend class CBotLeftExpr;
friend class CBotExprVar;
public:
CBotIndexExpr();
~CBotIndexExpr();
// static
// CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL ExecuteVar(CBotVar* &pVar, CBotCStack* &pile);
BOOL ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep, BOOL bExtend);
void RestoreStateVar(CBotStack* &pj, BOOL bMain);
};
// une expression du genre
// x = a;
// x * y + 3;
class CBotExpression : public CBotInstr
{
private:
CBotLeftExpr* m_leftop; // <20>l<EFBFBD>ment de gauche
CBotInstr* m_rightop; // <20>l<EFBFBD>ment de droite
public:
CBotExpression();
~CBotExpression();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pStack);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotListExpression : public CBotInstr
{
private:
CBotInstr* m_Expr; // la 1<>re expression <20> <20>valuer
public:
CBotListExpression();
~CBotListExpression();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pStack);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotLogicExpr : public CBotInstr
{
private:
CBotInstr* m_condition; // test <20> <20>valuer
CBotInstr* m_op1; // <20>l<EFBFBD>ment de gauche
CBotInstr* m_op2; // <20>l<EFBFBD>ment de droite
friend class CBotTwoOpExpr;
public:
CBotLogicExpr();
~CBotLogicExpr();
// static
// CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pStack);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotBoolExpr : public CBotInstr
{
private:
public:
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
};
// une expression <20>ventuellement entre parenth<74>ses ( ... )
// il n'y a jamais d'instance de cette classe
// l'objet retourn<72> <20>tant le contenu de la parenth<74>se
class CBotParExpr : public CBotInstr
{
private:
public:
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
};
// expression unaire
class CBotExprUnaire : public CBotInstr
{
private:
CBotInstr* m_Expr; // l'expression <20> <20>valuer
public:
CBotExprUnaire();
~CBotExprUnaire();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pStack);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// toutes les op<6F>rations <20> 2 op<6F>randes
class CBotTwoOpExpr : public CBotInstr
{
private:
CBotInstr* m_leftop; // <20>l<EFBFBD>ment de gauche
CBotInstr* m_rightop; // <20>l<EFBFBD>ment de droite
public:
CBotTwoOpExpr();
~CBotTwoOpExpr();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, int* pOperations = NULL);
BOOL Execute(CBotStack* &pStack);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// un bloc d'instructions { .... }
class CBotBlock : public CBotInstr
{
private:
public:
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal = TRUE);
static
CBotInstr* CompileBlkOrInst(CBotToken* &p, CBotCStack* pStack, BOOL bLocal = FALSE);
};
// le contenu d'un bloc d'instructions ... ; ... ; ... ; ... ;
class CBotListInstr : public CBotInstr
{
private:
CBotInstr* m_Instr; // les instructions <20> faire
public:
CBotListInstr();
~CBotListInstr();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, BOOL bLocal = TRUE);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotInstrCall : public CBotInstr
{
private:
CBotInstr* m_Parameters; // les param<61>tres <20> <20>valuer
// int m_typeRes; // type du r<>sultat
// CBotString m_RetClassName; // class du r<>sultat
CBotTypResult
m_typRes; // type complet du r<>sultat
long m_nFuncIdent; // id de la fonction
public:
CBotInstrCall();
~CBotInstrCall();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// un appel d'une m<>thode
class CBotInstrMethode : public CBotInstr
{
private:
CBotInstr* m_Parameters; // les param<61>tres <20> <20>valuer
// int m_typeRes; // type du r<>sultat
// CBotString m_RetClassName; // class du r<>sultat
CBotTypResult
m_typRes; // type complet du r<>sultat
CBotString m_NomMethod; // nom de la m<>thode
long m_MethodeIdent; // identificateur de la m<>thode
// long m_nThisIdent; // identificateur pour "this"
CBotString m_ClassName; // nom de la classe
public:
CBotInstrMethode();
~CBotInstrMethode();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, CBotVar* pVar);
BOOL Execute(CBotStack* &pj);
BOOL ExecuteVar(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, BOOL bStep, BOOL bExtend);
void RestoreStateVar(CBotStack* &pj, BOOL bMain);
};
// expression donnant un nom de variable
class CBotExprVar : public CBotInstr
{
private:
long m_nIdent;
friend class CBotPostIncExpr;
friend class CBotPreIncExpr;
public:
CBotExprVar();
~CBotExprVar();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack, int privat=PR_PROTECT);
static
CBotInstr* CompileMethode(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
BOOL ExecuteVar(CBotVar* &pVar, CBotStack* &pile, CBotToken* prevToken, BOOL bStep);
BOOL Execute2Var(CBotVar* &pVar, CBotStack* &pj, CBotToken* prevToken, BOOL bStep);
void RestoreStateVar(CBotStack* &pj, BOOL bMain);
};
class CBotPostIncExpr : public CBotInstr
{
private:
CBotInstr* m_Instr;
friend class CBotParExpr;
public:
CBotPostIncExpr();
~CBotPostIncExpr();
// static
// CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotPreIncExpr : public CBotInstr
{
private:
CBotInstr* m_Instr;
friend class CBotParExpr;
public:
CBotPreIncExpr();
~CBotPreIncExpr();
// static
// CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotLeftExprVar : public CBotInstr
{
private:
public:
CBotTypResult
m_typevar; // type de variable d<>clar<61>e
long m_nIdent; // identificateur unique pour cette variable
public:
CBotLeftExprVar();
~CBotLeftExprVar();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotExprBool : public CBotInstr
{
private:
public:
CBotExprBool();
~CBotExprBool();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotExprNull : public CBotInstr
{
private:
public:
CBotExprNull();
~CBotExprNull();
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotExprNan : public CBotInstr
{
private:
public:
CBotExprNan();
~CBotExprNan();
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
class CBotNew : public CBotInstr
{
private:
CBotInstr* m_Parameters; // les param<61>tres <20> <20>valuer
long m_nMethodeIdent;
// long m_nThisIdent;
CBotToken m_vartoken;
public:
CBotNew();
~CBotNew();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// expression repr<70>sentant un nombre
class CBotExprNum : public CBotInstr
{
private:
int m_numtype; // et le type de nombre
long m_valint; // valeur pour un int
float m_valfloat; // valeur pour un float
public:
CBotExprNum();
~CBotExprNum();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
// expression repr<70>sentant une chaine de caract<63>res
class CBotExprAlpha : public CBotInstr
{
private:
public:
CBotExprAlpha();
~CBotExprAlpha();
static
CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
};
#define MAX(a,b) ((a>b) ? a : b)
// classe pour la gestion des nombres entier (int)
class CBotVarInt : public CBotVar
{
private:
int m_val; // la valeur
CBotString m_defnum; // le nom si donn<6E> par DefineNum
friend class CBotVar;
public:
CBotVarInt( const CBotToken* name );
// ~CBotVarInt();
void SetValInt(int val, const char* s = NULL);
void SetValFloat(float val);
int GivValInt();
float GivValFloat();
CBotString GivValString();
void Copy(CBotVar* pSrc, BOOL bName=TRUE);
void Add(CBotVar* left, CBotVar* right); // addition
void Sub(CBotVar* left, CBotVar* right); // soustraction
void Mul(CBotVar* left, CBotVar* right); // multiplication
int Div(CBotVar* left, CBotVar* right); // division
int Modulo(CBotVar* left, CBotVar* right); // reste de division
void Power(CBotVar* left, CBotVar* right); // puissance
BOOL Lo(CBotVar* left, CBotVar* right);
BOOL Hi(CBotVar* left, CBotVar* right);
BOOL Ls(CBotVar* left, CBotVar* right);
BOOL Hs(CBotVar* left, CBotVar* right);
BOOL Eq(CBotVar* left, CBotVar* right);
BOOL Ne(CBotVar* left, CBotVar* right);
void XOr(CBotVar* left, CBotVar* right);
void Or(CBotVar* left, CBotVar* right);
void And(CBotVar* left, CBotVar* right);
void SL(CBotVar* left, CBotVar* right);
void SR(CBotVar* left, CBotVar* right);
void ASR(CBotVar* left, CBotVar* right);
void Neg();
void Not();
void Inc();
void Dec();
BOOL Save0State(FILE* pf);
BOOL Save1State(FILE* pf);
};
// classe pour la gestion des nombres r<>els (float)
class CBotVarFloat : CBotVar
{
private:
float m_val; // la valeur
public:
CBotVarFloat( const CBotToken* name );
// ~CBotVarFloat();
void SetValInt(int val, const char* s = NULL);
void SetValFloat(float val);
int GivValInt();
float GivValFloat();
CBotString GivValString();
void Copy(CBotVar* pSrc, BOOL bName=TRUE);
void Add(CBotVar* left, CBotVar* right); // addition
void Sub(CBotVar* left, CBotVar* right); // soustraction
void Mul(CBotVar* left, CBotVar* right); // multiplication
int Div(CBotVar* left, CBotVar* right); // division
int Modulo(CBotVar* left, CBotVar* right); // reste de division
void Power(CBotVar* left, CBotVar* right); // puissance
BOOL Lo(CBotVar* left, CBotVar* right);
BOOL Hi(CBotVar* left, CBotVar* right);
BOOL Ls(CBotVar* left, CBotVar* right);
BOOL Hs(CBotVar* left, CBotVar* right);
BOOL Eq(CBotVar* left, CBotVar* right);
BOOL Ne(CBotVar* left, CBotVar* right);
void Neg();
void Inc();
void Dec();
BOOL Save1State(FILE* pf);
};
// classe pour la gestion des cha<68>nes (String)
class CBotVarString : CBotVar
{
private:
CBotString m_val; // la valeur
public:
CBotVarString( const CBotToken* name );
// ~CBotVarString();
void SetValString(const char* p);
CBotString GivValString();
void Copy(CBotVar* pSrc, BOOL bName=TRUE);
void Add(CBotVar* left, CBotVar* right); // addition
BOOL Lo(CBotVar* left, CBotVar* right);
BOOL Hi(CBotVar* left, CBotVar* right);
BOOL Ls(CBotVar* left, CBotVar* right);
BOOL Hs(CBotVar* left, CBotVar* right);
BOOL Eq(CBotVar* left, CBotVar* right);
BOOL Ne(CBotVar* left, CBotVar* right);
BOOL Save1State(FILE* pf);
};
// classe pour la gestion des boolean
class CBotVarBoolean : CBotVar
{
private:
BOOL m_val; // la valeur
public:
CBotVarBoolean( const CBotToken* name );
// ~CBotVarBoolean();
void SetValInt(int val, const char* s = NULL);
void SetValFloat(float val);
int GivValInt();
float GivValFloat();
CBotString GivValString();
void Copy(CBotVar* pSrc, BOOL bName=TRUE);
void And(CBotVar* left, CBotVar* right);
void Or(CBotVar* left, CBotVar* right);
void XOr(CBotVar* left, CBotVar* right);
void Not();
BOOL Eq(CBotVar* left, CBotVar* right);
BOOL Ne(CBotVar* left, CBotVar* right);
BOOL Save1State(FILE* pf);
};
// classe pour la gestion des instances de classe
class CBotVarClass : public CBotVar
{
private:
static
CBotVarClass* m_ExClass; // liste des instances existantes <20> un moment donn<6E>
CBotVarClass* m_ExNext; // pour cette liste g<>n<EFBFBD>rale
CBotVarClass* m_ExPrev; // pour cette liste g<>n<EFBFBD>rale
private:
CBotClass* m_pClass; // la d<>finition de la classe
CBotVarClass* m_pParent; // l'instance dans la classe parent
CBotVar* m_pVar; // contenu
friend class CBotVar; // mon papa est un copain
friend class CBotVarPointer; // et le pointeur aussi
int m_CptUse; // compteur d'utilisation
long m_ItemIdent; // identificateur (unique) de l'instance
BOOL m_bConstructor; // set si un constructeur a <20>t<EFBFBD> appel<65>
public:
CBotVarClass( const CBotToken* name, CBotTypResult& type );
// CBotVarClass( const CBotToken* name, CBotTypResult& type, int &nIdent );
~CBotVarClass();
// void InitCBotVarClass( const CBotToken* name, CBotTypResult& type, int &nIdent );
void Copy(CBotVar* pSrc, BOOL bName=TRUE);
void SetClass(CBotClass* pClass); //, int &nIdent);
CBotClass* GivClass();
CBotVar* GivItem(const char* name); // rend un <20>l<EFBFBD>ment d'une classe selon son nom (*)
CBotVar* GivItemRef(int nIdent);
CBotVar* GivItem(int n, BOOL bExtend);
CBotVar* GivItemList();
CBotString GivValString();
BOOL Save1State(FILE* pf);
void Maj(void* pUser, BOOL bContinue);
void IncrementUse(); // une r<>f<EFBFBD>rence en plus
void DecrementUse(); // une r<>f<EFBFBD>rence en moins
CBotVarClass*
GivPointer();
void SetItemList(CBotVar* pVar);
void SetIdent(long n);
static
CBotVarClass*
CBotVarClass::Find(long id);
// CBotVar* GivMyThis();
BOOL Eq(CBotVar* left, CBotVar* right);
BOOL Ne(CBotVar* left, CBotVar* right);
void ConstructorSet();
};
// classe pour la gestion des pointeurs <20> une instances de classe
class CBotVarPointer : public CBotVar
{
private:
CBotVarClass*
m_pVarClass; // contenu
CBotClass* m_pClass; // la classe pr<70>vue pour ce pointeur
friend class CBotVar; // mon papa est un copain
public:
CBotVarPointer( const CBotToken* name, CBotTypResult& type );
~CBotVarPointer();
void Copy(CBotVar* pSrc, BOOL bName=TRUE);
void SetClass(CBotClass* pClass);
CBotClass* GivClass();
CBotVar* GivItem(const char* name); // rend un <20>l<EFBFBD>ment d'une classe selon son nom (*)
CBotVar* GivItemRef(int nIdent);
CBotVar* GivItemList();
CBotString GivValString();
void SetPointer(CBotVar* p);
CBotVarClass*
GivPointer();
void SetIdent(long n); // associe un num<75>ro d'identification (unique)
long GivIdent(); // donne le num<75>ro d'identification associ<63>
void ConstructorSet();
BOOL Save1State(FILE* pf);
void Maj(void* pUser, BOOL bContinue);
BOOL Eq(CBotVar* left, CBotVar* right);
BOOL Ne(CBotVar* left, CBotVar* right);
};
// classe pour les tableaux
#define MAXARRAYSIZE 9999
class CBotVarArray : public CBotVar
{
private:
CBotVarClass*
m_pInstance; // instance g<>rant le tableau
friend class CBotVar; // papa est un copain
public:
CBotVarArray( const CBotToken* name, CBotTypResult& type );
~CBotVarArray();
void SetPointer(CBotVar* p);
CBotVarClass*
GivPointer();
void Copy(CBotVar* pSrc, BOOL bName=TRUE);
CBotVar* GivItem(int n, BOOL bGrow=FALSE); // rend un <20>l<EFBFBD>ment selon son index num<75>rique
// agrandi le tableau si n<>cessaire si bExtend
// CBotVar* GivItem(const char* name); // rend un <20>l<EFBFBD>ment selon son index lit<69>ral
CBotVar* GivItemList(); // donne le premier <20>l<EFBFBD>ment de la liste
CBotString GivValString(); // donne le contenu du tableau dans une cha<68>ne
BOOL Save1State(FILE* pf);
};
extern CBotInstr* CompileParams(CBotToken* &p, CBotCStack* pStack, CBotVar** ppVars);
extern BOOL TypeCompatible( CBotTypResult& type1, CBotTypResult& type2, int op = 0 );
extern BOOL TypesCompatibles( CBotTypResult& type1, CBotTypResult& type2 );
extern BOOL WriteWord(FILE* pf, WORD w);
extern BOOL ReadWord(FILE* pf, WORD& w);
extern BOOL ReadLong(FILE* pf, long& w);
extern BOOL WriteFloat(FILE* pf, float w);
extern BOOL WriteLong(FILE* pf, long w);
extern BOOL ReadFloat(FILE* pf, float& w);
extern BOOL WriteString(FILE* pf, CBotString s);
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 );
#ifdef _DEBUG
extern void DEBUG( const char* text, int val, CBotStack* pile );
#endif
///////////////////////////////////////////
// classe pour les appels de routines (externes)
class CBotCall
{
private:
static
CBotCall* m_ListCalls;
static
void* m_pUser;
long m_nFuncIdent;
private:
CBotString m_name;
BOOL (*m_rExec) (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser) ;
CBotTypResult
(*m_rComp) (CBotVar* &pVar, void* pUser) ;
CBotCall* m_next;
public:
CBotCall(const char* name,
BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser));
~CBotCall();
static
BOOL AddFunction(const char* name,
BOOL rExec (CBotVar* pVar, CBotVar* pResult, int& Exception, void* pUser),
CBotTypResult rCompile (CBotVar* &pVar, void* pUser));
static
CBotTypResult
CompileCall(CBotToken* &p, CBotVar** ppVars, CBotCStack* pStack, long& nIdent);
static
BOOL CheckCall(const char* name);
// static
// int DoCall(CBotToken* &p, CBotVar** ppVars, CBotStack* pStack, CBotTypResult& rettype);
static
int DoCall(long& nIdent, CBotToken* token, CBotVar** ppVars, CBotStack* pStack, CBotTypResult& rettype);
#if STACKRUN
BOOL Run(CBotStack* pStack);
static
BOOL RestoreCall(long& nIdent, CBotToken* token, CBotVar** ppVar, CBotStack* pStack);
#endif
CBotString GivName();
CBotCall* Next();
static void SetPUser(void* pUser);
static void Free();
};
// classe g<>rant les m<>thodes d<>clar<61>es par AddFunction sur une classe
class CBotCallMethode
{
private:
CBotString m_name;
BOOL (*m_rExec) (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception);
CBotTypResult
(*m_rComp) (CBotVar* pThis, CBotVar* &pVar);
CBotCallMethode* m_next;
friend class CBotClass;
long m_nFuncIdent;
public:
CBotCallMethode(const char* name,
BOOL rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception),
CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar));
~CBotCallMethode();
CBotTypResult
CompileCall(const char* name, CBotVar* pThis,
CBotVar** ppVars, CBotCStack* pStack,
long& nIdent);
int DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotVar* &pResult, CBotStack* pStack, CBotToken* pFunc);
CBotString GivName();
CBotCallMethode* Next();
void AddNext(CBotCallMethode* p);
};
// une liste de param<61>tres
class CBotDefParam
{
private:
CBotToken m_token; // nom du param<61>tre
CBotString m_typename; // nom du type
CBotTypResult m_type; // type de param<61>tre
CBotDefParam* m_next; // param<61>tre suivant
long m_nIdent;
public:
CBotDefParam();
~CBotDefParam();
static
CBotDefParam* Compile(CBotToken* &p, CBotCStack* pStack);
BOOL Execute(CBotVar** ppVars, CBotStack* &pj);
void RestoreState(CBotStack* &pj, BOOL bMain);
void AddNext(CBotDefParam* p);
int GivType();
CBotTypResult GivTypResult();
CBotDefParam* GivNext();
CBotString GivParamString();
};
// une d<>claration de fonction
class CBotFunction : CBotInstr
{
private:
// gestion d'une liste (static) de fonctions publiques
static
CBotFunction* m_listPublic;
CBotFunction* m_nextpublic;
CBotFunction* m_prevpublic;
friend class CBotCStack;
// long m_nThisIdent;
long m_nFuncIdent;
BOOL m_bSynchro; // m<>thode synchronis<69>e ?
private:
CBotDefParam* m_Param; // liste des param<61>tres
CBotInstr* m_Block; // le bloc d'instructions
CBotFunction* m_next;
CBotToken m_retToken; // si retourne un CBotTypClass
CBotTypResult m_retTyp; // type complet du r<>sultat
BOOL m_bPublic; // fonction publique
BOOL m_bExtern; // fonction extern
CBotString m_MasterClass; // nom de la classe qu'on d<>rive
CBotProgram* m_pProg;
friend class CBotProgram;
friend class CBotClass;
CBotToken m_extern; // pour la position du mot "extern"
CBotToken m_openpar;
CBotToken m_closepar;
CBotToken m_openblk;
CBotToken m_closeblk;
public:
CBotFunction::CBotFunction();
CBotFunction::~CBotFunction();
static
CBotFunction* Compile(CBotToken* &p, CBotCStack* pStack, CBotFunction* pFunc, BOOL bLocal = TRUE);
static
CBotFunction* Compile1(CBotToken* &p, CBotCStack* pStack, CBotClass* pClass);
BOOL Execute(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance = NULL);
void RestoreState(CBotVar** ppVars, CBotStack* &pj, CBotVar* pInstance = NULL);
void AddNext(CBotFunction* p);
CBotTypResult CompileCall(const char* name, CBotVar** ppVars, long& nIdent);
CBotFunction* FindLocalOrPublic(long& nIdent, const char* name, CBotVar** ppVars, CBotTypResult& TypeOrError, BOOL bPublic = TRUE);
int DoCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken);
void RestoreCall(long& nIdent, const char* name, CBotVar** ppVars, CBotStack* pStack);
int DoCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotToken* pToken, CBotClass* pClass);
void RestoreCall(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppVars, CBotStack* pStack, CBotClass* pClass);
BOOL CheckParam(CBotDefParam* pParam);
static
void AddPublic(CBotFunction* pfunc);
CBotString GivName();
CBotString GivParams();
BOOL IsPublic();
BOOL IsExtern();
CBotFunction* Next();
BOOL GetPosition(int& start, int& stop, CBotGet modestart, CBotGet modestop);
};
Reference in New Issue View Git Blame Copy Permalink