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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#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:
  using SQPrintFunc = void (bool error_msg, std::string_view message);
 
  HSQUIRRELVM vm;          
  void *global_pointer;    
  SQPrintFunc *print_func; 
  bool crashed;            
  int overdrawn_ops;       
  std::string_view api_name; 
  std::unique_ptr<ScriptAllocator> allocator; 

  static SQInteger _RunError(HSQUIRRELVM vm);

  std::string_view GetAPIName() { return this->api_name; }

  void Initialize();
  void Uninitialize();
 
protected:
  static void CompileError(HSQUIRRELVM vm, std::string_view desc, std::string_view source, SQInteger line, SQInteger column);

  static void RunError(HSQUIRRELVM vm, std::string_view error);

  static void PrintFunc(HSQUIRRELVM vm, std::string_view s);

  static void ErrorPrintFunc(HSQUIRRELVM vm, std::string_view s);
 
public:
  Squirrel(std::string_view api_name);
  ~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(std::string_view method_name, SQFUNCTION proc, std::string_view params = {}, void *userdata = nullptr, int size = 0, bool suspendable = false);

  void AddConst(std::string_view var_name, SQInteger value);

  void AddConst(std::string_view var_name, uint value) { this->AddConst(var_name, (SQInteger)value); }

  void AddConst(std::string_view var_name, int value) { this->AddConst(var_name, (SQInteger)value); }

  void AddConst(std::string_view var_name, const ConvertibleThroughBase auto &value) { this->AddConst(var_name, static_cast<SQInteger>(value.base())); }

  void AddConst(std::string_view var_name, bool value);

  void AddClassBegin(std::string_view class_name);

  void AddClassBegin(std::string_view class_name, std::string_view 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, std::string_view method_name, HSQOBJECT *ret, int suspend);

  bool CallMethod(HSQOBJECT instance, std::string_view method_name, int suspend) { return this->CallMethod(instance, method_name, nullptr, suspend); }

  bool CallStringMethod(HSQOBJECT instance, std::string_view method_name, std::string *res, int suspend);

  bool CallIntegerMethod(HSQOBJECT instance, std::string_view method_name, int *res, int suspend);

  bool CallBoolMethod(HSQOBJECT instance, std::string_view method_name, bool *res, int suspend);

  bool MethodExists(HSQOBJECT instance, std::string_view 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, std::string_view tag);

  static void GetInstance(HSQUIRRELVM vm, HSQOBJECT *ptr, int pos = 1) { sq_getclass(vm, pos); sq_getstackobj(vm, pos, ptr); sq_pop(vm, 1); }

  static std::optional<std::string_view> 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(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;

  static void IncreaseAllocatedSize(size_t bytes);

  static void DecreaseAllocatedSize(size_t bytes);
};
 
 
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 */