/* * This file is part of the Colobot: Gold Edition source code * Copyright (C) 2001-2015, Daniel Roux, EPSITEC SA & TerranovaTeam * http://epsitec.ch; http://colobot.info; http://github.com/colobot * * 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 http://gnu.org/licenses */ #pragma once // Modules inlcude #include "CBotDll.h" #include "CBotProgram.h" #include "CBotDefines.h" // Local include // Global include /*! * \brief The CBotClass class Class to define new classes in the language CBOT * for example to define the class CPoint (x, y). */ class CBotClass { public: //! Mark if is set or not bool m_IsDef; /*! * \brief CBotClass Constructor. Once a class is created, it is known around * CBot intrinsic mode gives a class that is not managed by pointers. * \param name * \param pParent * \param bIntrinsic */ CBotClass( const char* name, CBotClass* pParent, bool bIntrinsic = false ); /*! * \brief CBotClass Destructor. */ ~CBotClass( ); /*! * \brief Create * \param name * \param parent * \param intrinsic * \return */ static CBotClass* Create(const char* name, CBotClass* parent, bool intrinsic = false); /*! * \brief AddFunction This call allows to add as external (**) new method * used by the objects of this class. * \param name * \param rExec * \param rCompile * \return */ bool AddFunction(const char* name, bool rExec (CBotVar* pThis, CBotVar* pVar, CBotVar* pResult, int& Exception, void* user), CBotTypResult rCompile (CBotVar* pThis, CBotVar* &pVar)); /*! * \brief AddUpdateFunc Defines routine to be called to update the elements * of the class. * \param rMaj * \return */ bool AddUpdateFunc( void rMaj ( CBotVar* pThis, void* pUser ) ); // /*! * \brief AddItem Adds an element to the class. * \param name * \param type * \param mPrivate * \return */ bool AddItem(CBotString name, CBotTypResult type, int mPrivate = PR_PUBLIC); /*! * \brief AddItem Adds an item by passing the pointer to an instance of a * variable the object is taken as is, so do not destroyed. * \param pVar * \return */ bool AddItem(CBotVar* pVar); /*! * \brief AddNext * \param pClass */ void AddNext(CBotClass* pClass); /*! * \brief GetName Gives the name of the class. * \return */ CBotString GetName(); /*! * \brief GetParent Gives the parent class (or nullptr). * \return */ CBotClass* GetParent(); /*! * \brief IsChildOf True if a class is derived (Extends) of another. * \param pClass * \return true also if the classes are identical */ bool IsChildOf(CBotClass* pClass); /*! * \brief Find Trouve une classe d'après son nom * \param pToken * \return A class by it's its name. */ static CBotClass* Find(CBotToken* &pToken); /*! * \brief Find * \param name * \return */ static CBotClass* Find(const char* name); /*! * \brief GetVar Return the list of variables. * \return */ CBotVar* GetVar(); /*! * \brief GetItem One of the variables according to its name. * \param name * \return */ CBotVar* GetItem(const char* name); /*! * \brief GetItemRef * \param nIdent * \return */ CBotVar* GetItemRef(int nIdent); /*! * \brief CompileMethode Compiles a method associated with an instance of * class the method can be declared by the user or AddFunction. * \param name * \param pThis * \param ppParams * \param pStack * \param nIdent * \return */ CBotTypResult CompileMethode(const char* name, CBotVar* pThis, CBotVar** ppParams, CBotCStack* pStack, long& nIdent); /*! * \brief ExecuteMethode Executes a method. * \param nIdent * \param name * \param pThis * \param ppParams * \param pResult * \param pStack * \param pToken * \return */ bool ExecuteMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotVar* &pResult, CBotStack* &pStack, CBotToken* pToken); /*! * \brief RestoreMethode Restored the execution stack. * \param nIdent * \param name * \param pThis * \param ppParams * \param pStack */ void RestoreMethode(long& nIdent, const char* name, CBotVar* pThis, CBotVar** ppParams, CBotStack* &pStack); /*! * \brief Compile Compiles a class declared by the user. * \param p * \param pStack * \return */ static CBotClass* Compile(CBotToken* &p, CBotCStack* pStack); /*! * \brief Compile1 * \param p * \param pStack * \return */ static CBotClass* Compile1(CBotToken* &p, CBotCStack* pStack); /*! * \brief CompileDefItem * \param p * \param pStack * \param bSecond * \return */ bool CompileDefItem(CBotToken* &p, CBotCStack* pStack, bool bSecond); /*! * \brief IsIntrinsic * \return */ bool IsIntrinsic(); /*! * \brief Purge */ void Purge(); /*! * \brief Free */ static void Free(); /*! * \brief SaveStaticState * \param pf * \return */ static bool SaveStaticState(FILE* pf); /*! * \brief RestoreStaticState * \param pf * \return */ static bool RestoreStaticState(FILE* pf); /*! * \brief Lock * \param p * \return */ bool Lock(CBotProgram* p); /*! * \brief Unlock */ void Unlock(); /*! * \brief FreeLock * \param p */ static void FreeLock(CBotProgram* p); /*! * \brief CheckCall Test if a procedure name is already defined somewhere. * \param pToken * \param pParam * \return */ bool CheckCall(CBotToken* &pToken, CBotDefParam* pParam); private: //! List of classes existing at a given time. static CBotClass* m_ExClass; //! For this general list. CBotClass* m_ExNext; //! For this general list. CBotClass* m_ExPrev; //! Parent class. CBotClass* m_pParent; //! Name of this class. CBotString m_name; //! Number of variables in the chain. int m_nbVar; //! Content of the class. CBotVar* m_pVar; //! Intrinsic class. bool m_bIntrinsic; //! The string class. CBotClass* m_next; //! List of methods defined in external. CBotCallMethode* m_pCalls; //! Compiled list of methods. CBotFunction* m_pMethod; void (*m_rMaj) ( CBotVar* pThis, void* pUser ); friend class CBotVarClass; //! For Lock / UnLock. int m_cptLock; //! Lock for reentrancy. int m_cptOne; //! Processes waiting for sync. CBotProgram* m_ProgInLock[5]; };