diff options
| author | adiblol <adiblol@1tbps.org> | 2012-03-08 19:32:05 +0100 |
|---|---|---|
| committer | adiblol <adiblol@1tbps.org> | 2012-03-08 19:32:05 +0100 |
| commit | a4c804b49ec872b71bd5a0167c3ad45704a3cc30 (patch) | |
| tree | 8c931235247d662ca46a99695beb328fdfc8e8a8 /src/CBot/CBot.h | |
| download | colobot-a4c804b49ec872b71bd5a0167c3ad45704a3cc30.tar.gz colobot-a4c804b49ec872b71bd5a0167c3ad45704a3cc30.tar.bz2 colobot-a4c804b49ec872b71bd5a0167c3ad45704a3cc30.zip | |
Initial commit, Copyright (C) 2001-2008, Daniel ROUX & EPSITEC SA, www.epsitec.ch
Diffstat (limited to 'src/CBot/CBot.h')
| -rw-r--r-- | src/CBot/CBot.h | 1611 |
1 files changed, 1611 insertions, 0 deletions
diff --git a/src/CBot/CBot.h b/src/CBot/CBot.h new file mode 100644 index 0000000..bf95c90 --- /dev/null +++ b/src/CBot/CBot.h @@ -0,0 +1,1611 @@ +////////////////////////////////////////////////////////////////////
+// interpréteur pour le language CBot du jeu COLOBOT
+
+// derniè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écution direct sur une routine suspendue
+#define STACKMEM TRUE // préréserve la mémoire pour la pile d'exécution
+#define MAXSTACK 990 // taille du stack réservé
+
+#define EOX (CBotStack*)-1 // marqueur condition spéciale
+
+/////////////////////////////////////////////////////////////////////
+// résumé des classes utilisées, définies ci-après
+
+class CBotCompExpr; // une expression telle que
+ // () <= ()
+class CBotAddExpr; // une expression telle que
+ // () + ()
+class CBotParExpr; // un élément de base ou entre parenthè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ètres d'une fonction
+class CBotRepeat; // repeat (nb) {...}
+
+
+
+////////////////////////////////////////////////////////////////////////
+// Gestion de la pile d'exécution
+////////////////////////////////////////////////////////////////////////
+
+// en fait, en externe, la seule chose qu'il est possible de faire
+// c'est de cré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érations
+ CBotVar* m_listVar; // les variables déclarées à ce niveau
+
+ BOOL m_bBlock; // fait partie d'un bloc (variables sont locales à ce bloc)
+ BOOL m_bOver; // limites de la pile ?
+// BOOL m_bDontDelete; // spé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é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éro d'erreur retourné
+
+ 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); // étend le stack
+ CBotStack* AddStackEOX(CBotCall* instr = NULL, BOOL bBlock = FALSE); // étend le stack
+ CBotStack* RestoreStack(CBotInstr* instr = NULL);
+ CBotStack* RestoreStackEOX(CBotCall* instr = NULL);
+
+ CBotStack* AddStack2(BOOL bBlock = FALSE); // é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 éventuel
+ BOOL IfContinue(int state, const char* name);
+ // ou de "continue"
+
+ BOOL IsOk();
+
+ BOOL SetState(int n, int lim = -10); // sélectionne un état
+ int GivState(); // dans quel état j'ère ?
+ BOOL IncState(int lim = -10); // passe à l'état suivant
+ BOOL IfStep(); // faire du pas à 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 être déclaré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érations
+
+ BOOL m_bBlock; // fait partie d'un bloc (variables sont locales à ce bloc)
+ CBotVar* m_listVar;
+
+ static
+ CBotProgram* m_prog; // liste des fonctions compilé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éro d'erreur retourné
+
+ 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înées
+ CBotInstr* m_next2b; // seconde liste pour définition en chaîne
+ CBotInstr* m_next3; // troisiè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éré
+ 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 é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ération
+ CBotInstr* m_Block; // les instructions
+ CBotString m_label; // une é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 é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ément
+ CBotInstr* m_Block; // les instructions
+ CBotString m_label; // une é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 é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ètre à 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 à 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 à 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 à 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 à initialiser
+ CBotInstr* m_expr; // la valeur à mettre, s'il y a
+/// CBotInstr* m_next; // plusieurs définitions enchaîné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 à initialiser
+ CBotInstr* m_listass; // liste d'assignations pour le tableau
+ CBotTypResult
+ m_typevar; // type d'élé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 élément
+ // les autres sont chaîné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éen
+
+class CBotBoolean : public CBotInstr
+{
+private:
+ CBotInstr* m_var; // la variable à initialiser
+ CBotInstr* m_expr; // la valeur à 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 à initialiser
+ CBotInstr* m_expr; // la valeur à 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ément string
+
+class CBotIString : public CBotInstr
+{
+private:
+ CBotInstr* m_var; // la variable à initialiser
+ CBotInstr* m_expr; // la valeur à 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ément dans une classe quelconque
+
+class CBotClassInst : public CBotInstr
+{
+private:
+ CBotInstr* m_var; // la variable à initialiser
+ CBotClass* m_pClass; // référence à la classe
+ CBotInstr* m_Parameters; // les paramètres à évaluer pour le constructeur
+ CBotInstr* m_expr; // la valeur à mettre, s'il y a
+ BOOL m_hasParams; // il y a des paramè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érande
+// n'accepte que les expressions pouvant être à 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; // élément de gauche
+ CBotInstr* m_rightop; // élé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 à é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 à évaluer
+ CBotInstr* m_op1; // élément de gauche
+ CBotInstr* m_op2; // élé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 éventuellement entre parenthèses ( ... )
+// il n'y a jamais d'instance de cette classe
+// l'objet retourné étant le contenu de la parenthé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 à évaluer
+public:
+ CBotExprUnaire();
+ ~CBotExprUnaire();
+ static
+ CBotInstr* Compile(CBotToken* &p, CBotCStack* pStack);
+ BOOL Execute(CBotStack* &pStack);
+ void RestoreState(CBotStack* &pj, BOOL bMain);
+};
+
+// toutes les opérations à 2 opérandes
+
+class CBotTwoOpExpr : public CBotInstr
+{
+private:
+ CBotInstr* m_leftop; // élément de gauche
+ CBotInstr* m_rightop; // élé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 à 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ètres à é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ètres à é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é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ètres à é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é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ésentant une chaine de caractè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é 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î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 à un moment donné
+ CBotVarClass* m_ExNext; // pour cette liste générale
+ CBotVarClass* m_ExPrev; // pour cette liste géné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 été appelé
+
+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 élé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érence en plus
+ void DecrementUse(); // une réfé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 à une instances de classe
+class CBotVarPointer : public CBotVar
+{
+private:
+ CBotVarClass*
+ m_pVarClass; // contenu
+ CBotClass* m_pClass; // la classe pré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 élé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éro d'identification (unique)
+ long GivIdent(); // donne le numéro d'identification associé
+ 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 élément selon son index numérique
+ // agrandi le tableau si nécessaire si bExtend
+// CBotVar* GivItem(const char* name); // rend un élément selon son index litéral
+ CBotVar* GivItemList(); // donne le premier élément de la liste
+
+ CBotString GivValString(); // donne le contenu du tableau dans une chaî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é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ètres
+
+class CBotDefParam
+{
+private:
+ CBotToken m_token; // nom du paramètre
+ CBotString m_typename; // nom du type
+ CBotTypResult m_type; // type de paramètre
+ CBotDefParam* m_next; // paramè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ée ?
+
+private:
+ CBotDefParam* m_Param; // liste des paramè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);
+};
+
+
|