squirrel.hpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD 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, version 2.
 * OpenTTD 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 OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef SQUIRREL_HPP
#define SQUIRREL_HPP
 
#include <squirrel.h>
#include "../core/convertible_through_base.hpp"
 
enum class ScriptType : uint8_t {
  AI, 
  GS, 
};
 
struct ScriptAllocator;
 
class Squirrel {
  friend class ScriptAllocatorScope;
  friend class ScriptInstance;
 
private:
  typedef void (SQPrintFunc)(bool error_msg, const std::string &message);
 
  HSQUIRRELVM vm;          
  void *global_pointer;    
  SQPrintFunc *print_func; 
  bool crashed;            
  int overdrawn_ops;       
  const char *APIName;     
  std::unique_ptr<ScriptAllocator> allocator; 
 
  static SQInteger _RunError(HSQUIRRELVM vm);
 
  const char *GetAPIName() { return this->APIName; }
 
  void Initialize();
  void Uninitialize();
 
protected:
  static void CompileError(HSQUIRRELVM vm, const SQChar *desc, const SQChar *source, SQInteger line, SQInteger column);
 
  static void RunError(HSQUIRRELVM vm, const SQChar *error);
 
  static void PrintFunc(HSQUIRRELVM vm, const std::string &s);
 
  static void ErrorPrintFunc(HSQUIRRELVM vm, const std::string &s);
 
public:
  Squirrel(const char *APIName);
  ~Squirrel();
 
  HSQUIRRELVM GetVM() { return this->vm; }
 
  bool LoadScript(const std::string &script);
  bool LoadScript(HSQUIRRELVM vm, const std::string &script, bool in_root = true);
 
  SQRESULT LoadFile(HSQUIRRELVM vm, const std::string &filename, SQBool printerror);
 
  void AddMethod(const char *method_name, SQFUNCTION proc, uint nparam = 0, const char *params = nullptr, void *userdata = nullptr, int size = 0);
 
  void AddConst(const char *var_name, int value);
 
  void AddConst(const char *var_name, uint value) { this->AddConst(var_name, (int)value); }
 
  void AddConst(const char *var_name, const ConvertibleThroughBase auto &value) { this->AddConst(var_name, static_cast<int>(value.base())); }
 
  void AddConst(const char *var_name, bool value);
 
  void AddClassBegin(const char *class_name);
 
  void AddClassBegin(const char *class_name, const char *parent_class);
 
  void AddClassEnd();
 
  bool Resume(int suspend = -1);
 
  void ResumeError();
 
  void CollectGarbage();
 
  void InsertResult(bool result);
  void InsertResult(int result);
  void InsertResult(uint result) { this->InsertResult((int)result); }
  void InsertResult(ConvertibleThroughBase auto result) { this->InsertResult(static_cast<int>(result.base())); }
 
  bool CallMethod(HSQOBJECT instance, const char *method_name, HSQOBJECT *ret, int suspend);
  bool CallMethod(HSQOBJECT instance, const char *method_name, int suspend) { return this->CallMethod(instance, method_name, nullptr, suspend); }
  bool CallStringMethod(HSQOBJECT instance, const char *method_name, std::string *res, int suspend);
  bool CallIntegerMethod(HSQOBJECT instance, const char *method_name, int *res, int suspend);
  bool CallBoolMethod(HSQOBJECT instance, const char *method_name, bool *res, int suspend);
 
  bool MethodExists(HSQOBJECT instance, const char *method_name);
 
  static bool CreateClassInstanceVM(HSQUIRRELVM vm, const std::string &class_name, void *real_instance, HSQOBJECT *instance, SQRELEASEHOOK release_hook, bool prepend_API_name = false);
 
  bool CreateClassInstance(const std::string &class_name, void *real_instance, HSQOBJECT *instance);
 
  static SQUserPointer GetRealInstance(HSQUIRRELVM vm, int index, const char *tag);
 
  static bool GetInstance(HSQUIRRELVM vm, HSQOBJECT *ptr, int pos = 1) { sq_getclass(vm, pos); sq_getstackobj(vm, pos, ptr); sq_pop(vm, 1); return true; }
 
  static const char *ObjectToString(HSQOBJECT *ptr) { return sq_objtostring(ptr); }
 
  static int ObjectToInteger(HSQOBJECT *ptr) { return sq_objtointeger(ptr); }
 
  static bool ObjectToBool(HSQOBJECT *ptr) { return sq_objtobool(ptr) == 1; }
 
  void SetGlobalPointer(void *ptr) { this->global_pointer = ptr; }
 
  static void *GetGlobalPointer(HSQUIRRELVM vm) { return ((Squirrel *)sq_getforeignptr(vm))->global_pointer; }
 
  void SetPrintFunction(SQPrintFunc *func) { this->print_func = func; }
 
  void ThrowError(const std::string_view error) { sq_throwerror(this->vm, error); }
 
  void ReleaseObject(HSQOBJECT *ptr) { sq_release(this->vm, ptr); }
 
  static void DecreaseOps(HSQUIRRELVM vm, int amount);
 
  bool IsSuspended();
 
  bool HasScriptCrashed();
 
  void CrashOccurred();
 
  bool CanSuspend();
 
  SQInteger GetOpsTillSuspend();
 
  void Reset();
 
  size_t GetAllocatedMemory() const noexcept;
};
 
 
extern ScriptAllocator *_squirrel_allocator;
 
class ScriptAllocatorScope {
  ScriptAllocator *old_allocator;
 
public:
  ScriptAllocatorScope(const Squirrel *engine)
  {
    this->old_allocator = _squirrel_allocator;
    /* This may get called with a nullptr engine, in case of a crashed script */
    _squirrel_allocator = engine != nullptr ? engine->allocator.get() : nullptr;
  }
 
  ~ScriptAllocatorScope()
  {
    _squirrel_allocator = this->old_allocator;
  }
};
 
#endif /* SQUIRREL_HPP */