inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp/include/functional.h

@@ -0,0 +1,327 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+
+#include "config.h"
+#include "list.h"
+#include "traits.h"
+#include "system.h"
+#include "types.h"
+
+#ifdef INK_ENABLE_UNREAL
+#	include "../InkVar.h"
+#endif
+
+namespace ink::runtime::internal
+{
+class basic_eval_stack;
+class string_table;
+class list_table;
+
+class callback_base
+{
+public:
+	virtual void call(ink::runtime::value, ink::optional<ink::runtime::value>) = 0;
+};
+
+template<typename F>
+class callback final : public callback_base
+{
+	using traits = function_traits<F>;
+	static_assert(traits::arity < 3);
+
+	template<ink::runtime::value::Type Ty>
+	void call_functor(ink::runtime::value new_val, ink::optional<ink::runtime::value> old_val)
+	{
+		if constexpr (traits::arity == 2) {
+			if (old_val.has_value()) {
+				functor(
+				    new_val.get<Ty>(),
+				    typename traits::template argument<1>::type{old_val.value().get<Ty>()}
+				);
+			} else {
+				functor(new_val.get<Ty>(), ink::nullopt);
+			}
+		} else {
+			functor(new_val.get<Ty>());
+		}
+	}
+
+public:
+	callback(const callback&)            = delete;
+	callback(callback&&)                 = delete;
+	callback& operator=(const callback&) = delete;
+	callback& operator=(callback&&)      = delete;
+
+	callback(F functor)
+	    : functor(functor)
+	{
+	}
+
+	virtual void call(ink::runtime::value new_val, ink::optional<ink::runtime::value> old_val)
+	{
+		using value     = ink::runtime::value;
+		auto check_type = [&new_val, &old_val](value::Type type) {
+			inkAssert(
+			    new_val.type == type, "Missmatch type for variable observer: expected %i, got %i",
+			    static_cast<int>(type), static_cast<int>(new_val.type)
+			);
+			if constexpr (traits::arity == 2) {
+				// inkAssert(!old_val.has_value() || old_val.value().type == type,
+				// 	"Missmatch type for variable observers old value: expected optional<%i> got
+				// optional<%i>", static_cast<int>(type), static_cast<int>(old_val.value().type));
+			}
+		};
+		if constexpr (traits::arity > 0) {
+			using arg_t = typename remove_cvref<typename traits::template argument<0>::type>::type;
+			if constexpr (is_same<arg_t, value>::value) {
+				if constexpr (traits::arity == 2) {
+					functor(new_val, old_val);
+				} else {
+					functor(new_val);
+				}
+			} else if constexpr (is_same<arg_t, bool>::value) {
+				check_type(value::Type::Bool);
+				call_functor<value::Type::Bool>(new_val, old_val);
+			} else if constexpr (is_same<arg_t, uint32_t>::value) {
+				check_type(value::Type::Uint32);
+				call_functor<value::Type::Uint32>(new_val, old_val);
+			} else if constexpr (is_same<arg_t, int32_t>::value) {
+				check_type(value::Type::Int32);
+				call_functor<value::Type::Int32>(new_val, old_val);
+			} else if constexpr (is_same<arg_t, const char*>::value) {
+				check_type(value::Type::String);
+				call_functor<value::Type::String>(new_val, old_val);
+			} else if constexpr (is_same<arg_t, float>::value) {
+				check_type(value::Type::Float);
+				call_functor<value::Type::Float>(new_val, old_val);
+			} else if constexpr (is_same<arg_t, list_interface*>::value) {
+				check_type(value::Type::List);
+				call_functor<value::Type::List>(new_val, old_val);
+			} else {
+				static_assert(
+				    always_false<arg_t>::value, "Unsupported value for variable observer callback!"
+				);
+			}
+		} else {
+			functor();
+		}
+	}
+
+private:
+	F functor;
+};
+
+// base function container with virtual callback methods
+class function_base
+{
+public:
+	function_base(bool lookaheadSafe)
+	    : _lookaheadSafe(lookaheadSafe)
+	{
+	}
+
+	virtual ~function_base() {}
+
+	// calls the underlying function object taking parameters from a stack
+	// TODO: remove ?
+#ifdef INK_ENABLE_UNREAL
+	virtual void
+	    call(basic_eval_stack* stack, size_t length, string_table& strings, list_table& lists)
+	    = 0;
+#else
+	virtual void
+	    call(basic_eval_stack* stack, size_t length, string_table& strings, list_table& lists)
+	    = 0;
+#endif
+
+	bool lookaheadSafe() const { return _lookaheadSafe; }
+
+protected:
+	bool _lookaheadSafe;
+	// used to hide basic_eval_stack and value definitions
+	template<typename T>
+	static T pop(basic_eval_stack* stack, list_table& lists);
+
+	// used to hide basic_eval_stack and value definitions
+	template<typename T>
+	static void push(basic_eval_stack* stack, const T& value);
+
+	static void push_void(basic_eval_stack* stack);
+
+	// string special push
+	static void push_string(basic_eval_stack* stack, const char* dynamic_string);
+
+	// used to hide string_table definitions
+	static char* allocate(string_table& strings, ink::size_t len);
+};
+
+// Stores a Callable function object and forwards calls to it
+template<typename F>
+class function : public function_base
+{
+public:
+	function(F functor, bool lookaheadSafe)
+	    : function_base(lookaheadSafe)
+	    , functor(functor)
+	{
+	}
+
+	// calls the underlying function using arguments on the stack
+	virtual void call(
+	    basic_eval_stack* stack, size_t length, string_table& strings, list_table& lists
+	) override
+	{
+		call(stack, length, strings, lists, GenSeq<traits::arity>());
+	}
+
+private:
+	// Callable functor object
+	F functor;
+
+	// function traits
+	using traits = function_traits<F>;
+
+	// argument types
+	template<int index>
+	using arg_type = typename function_traits<F>::template argument<index>::type;
+
+	// pops an argument from the stack using the function-type
+	template<int index>
+	arg_type<index> pop_arg(basic_eval_stack* stack, list_table& lists)
+	{
+		// todo - type assert?
+		return pop<arg_type<index>>(stack, lists);
+	}
+
+	static constexpr bool is_array_call()
+	{
+		if constexpr (traits::arity == 2) {
+			return is_same<
+			    const ink::runtime::value*, typename traits::template argument<1>::type>::value;
+		}
+		return false;
+	}
+
+	template<size_t... Is>
+	void
+	    call(basic_eval_stack* stack, size_t length, string_table& strings, list_table& lists, seq<Is...>)
+	{
+		inkAssert(
+		    is_array_call() || sizeof...(Is) == length,
+		    "Attempting to call functor with too few/many arguments"
+		);
+		static_assert(sizeof...(Is) == traits::arity);
+		if_t<is_array_call(), value[config::maxArrayCallArity], char> vals;
+		if constexpr (is_array_call()) {
+			inkAssert(
+			    length <= config::maxArrayCallArity,
+			    "AIttampt to call array call with more arguments then supportet, please change in "
+			    "config"
+			);
+			for (size_t i = 0; i < length; ++i) {
+				vals[i] = pop<ink::runtime::value>(stack, lists);
+			}
+		}
+		// void functions
+		if constexpr (is_same<void, typename traits::return_type>::value) {
+			// Just evaluevaluatelate
+			if constexpr (is_array_call()) {
+				functor(length, vals);
+			} else {
+				functor(pop_arg<Is>(stack, lists)...);
+			}
+
+			// Ink expects us to push something
+			push_void(stack);
+		} else {
+			typename traits::return_type res;
+			if constexpr (is_array_call()) {
+				res = functor(length, vals);
+			} else {
+				res = functor(pop_arg<Is>(stack, lists)...);
+			}
+			if constexpr (is_string<typename traits::return_type>::value) {
+				// SPECIAL: The result of the functor is a string type
+				//  in order to store it in the inkcpp interpreter we
+				//  need to store it in our allocated string table
+				// Get string length
+				size_t len = string_handler<typename traits::return_type>::length(res);
+
+				// Get source and allocate buffer
+				char* buffer = allocate(strings, len + 1);
+				string_handler<typename traits::return_type>::src_copy(res, buffer);
+
+				// push string result
+				push_string(stack, buffer);
+			} else if constexpr (is_same<value, remove_cvref<typename traits::return_type>>::value) {
+				if (res.type() == ink::runtime::value::Type::String) {
+					auto   src    = res.template get<ink::runtime::value::Type::String>();
+					size_t len    = string_handler<decltype(src)>::length(src);
+					char*  buffer = allocate(strings, len + 1);
+					string_handler<decltype(src)>::src_copy(src, buffer);
+					push_string(stack, buffer);
+				} else {
+					push(stack, res);
+				}
+			} else {
+				// Evaluate and push the result onto the stack
+				push(stack, res);
+			}
+		}
+	}
+};
+
+#ifdef INK_ENABLE_UNREAL
+template<typename D>
+class function_array_delegate : public function_base
+{
+public:
+	function_array_delegate(const D& del, bool lookaheadSafe)
+	    : function_base(lookaheadSafe)
+	    , invocableDelegate(del)
+	{
+	}
+
+	// calls the underlying delegate using arguments on the stack
+	virtual void call(
+	    basic_eval_stack* stack, size_t length, string_table& strings, list_table& lists
+	) override
+	{
+		constexpr bool RET_VOID
+		    = is_same<typename function_traits<decltype(&D::Execute)>::return_type, void>::value;
+		// Create variable array
+		TArray<FInkVar> variables;
+		for (size_t i = 0; i < length; i++) {
+			variables.Add(pop<FInkVar>(stack, lists));
+		}
+		if constexpr (RET_VOID) {
+			invocableDelegate.Execute(variables);
+			push(stack, 0);
+		} else {
+
+			auto                ret    = invocableDelegate.Execute(variables);
+			ink::runtime::value result = ret.to_value();
+			if (result.type == ink::runtime::value::Type::String) {
+				const char* src    = result.get<ink::runtime::value::Type::String>();
+				size_t      len    = string_handler<const char*>::length(src);
+				char*       buffer = allocate(strings, len + 1);
+				char*       ptr    = buffer;
+				while (*src != '\0')
+					*(ptr++) = *(src++);
+				*ptr            = 0;
+				result          = ink::runtime::value(buffer);
+			}
+			push(stack, result);
+		}
+	}
+
+private:
+	D invocableDelegate;
+};
+#endif
+} // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/include/globals.h

@@ -0,0 +1,196 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+
+#include "types.h"
+#include "functional.h"
+
+namespace ink::runtime
+{
+class snapshot;
+
+/**
+ * Represents a global store to be shared amongst ink runners.
+ * Stores global variable values, visit counts, turn counts, etc.
+ */
+class globals_interface
+{
+public:
+	/**
+	 * @brief Access global variable of Ink runner.
+	 * @param name name of variable, as defined in InkScript
+	 * @tparam T c++ type of variable
+	 * @return nullopt if variable won't exist or type won't match
+	 */
+	template<typename T>
+	optional<T> get(const char* name) const
+	{
+		static_assert(internal::always_false<T>::value, "Requested Type is not supported");
+	}
+
+	/**
+	 * @brief Write new value in global store.
+	 * @param name name of variable, as defined in InkScript
+	 * @param val
+	 * @tparam T c++ type of variable
+	 * @retval true on success
+	 */
+	template<typename T>
+	bool set(const char* name, const T& val)
+	{
+		static_assert(internal::always_false<T>::value, "Requested Type is not supported");
+		return false;
+	}
+
+	/**
+	 * @brief Observers global variable.
+	 *
+	 * Calls callback with `value` or with casted value if it is one of
+	 * values variants. The callback will also be called with the current value
+	 * when the observe is bind.
+	 * @param name of variable to observe
+	 * @param callback functor with:
+	 * * 0 arguments
+	 * * 1 argument: `new_value`
+	 * * 2 arguments: `new_value`, `ink::optional<old_value>`: first time call will not contain a
+	 * old_value
+	 */
+	template<typename F>
+	void observe(const char* name, F callback)
+	{
+		internal_observe(hash_string(name), new internal::callback(callback));
+	}
+
+	/** create a snapshot of the current runtime state.
+	 * (inclusive all runners assoziated with this globals)
+	 */
+	virtual snapshot* create_snapshot() const = 0;
+
+	virtual ~globals_interface() = default;
+
+protected:
+	/** @private */
+	virtual optional<value> get_var(hash_t name) const                                       = 0;
+	/** @private */
+	virtual bool            set_var(hash_t name, const value& val)                           = 0;
+	/** @private */
+	virtual void            internal_observe(hash_t name, internal::callback_base* callback) = 0;
+};
+
+/** @name Instanciations */
+///@{
+/** getter and setter instanciations for supported types */
+template<>
+inline optional<value> globals_interface::get<value>(const char* name) const
+{
+	return get_var(hash_string(name));
+}
+
+template<>
+inline bool globals_interface::set<value>(const char* name, const value& val)
+{
+	return set_var(hash_string(name), val);
+}
+
+template<>
+inline optional<bool> globals_interface::get<bool>(const char* name) const
+{
+	auto var = get_var(hash_string(name));
+	if (var && var->type == value::Type::Bool) {
+		return {var->get<value::Type::Bool>()};
+	}
+	return nullopt;
+}
+
+template<>
+inline bool globals_interface::set<bool>(const char* name, const bool& val)
+{
+	return set_var(hash_string(name), value(val));
+}
+
+template<>
+inline optional<uint32_t> globals_interface::get<uint32_t>(const char* name) const
+{
+	auto var = get_var(hash_string(name));
+	if (var && var->type == value::Type::Uint32) {
+		return {var->get<value::Type::Uint32>()};
+	}
+	return nullopt;
+}
+
+template<>
+inline bool globals_interface::set<uint32_t>(const char* name, const uint32_t& val)
+{
+	return set_var(hash_string(name), value(val));
+}
+
+template<>
+inline optional<int32_t> globals_interface::get<int32_t>(const char* name) const
+{
+	auto var = get_var(hash_string(name));
+	if (var && var->type == value::Type::Int32) {
+		return {var->get<value::Type::Int32>()};
+	}
+	return nullopt;
+}
+
+template<>
+inline bool globals_interface::set<int32_t>(const char* name, const int32_t& val)
+{
+	return set_var(hash_string(name), value(val));
+}
+
+template<>
+inline optional<float> globals_interface::get<float>(const char* name) const
+{
+	auto var = get_var(hash_string(name));
+	if (var && var->type == value::Type::Float) {
+		return {var->get<value::Type::Float>()};
+	}
+	return nullopt;
+}
+
+template<>
+inline bool globals_interface::set<float>(const char* name, const float& val)
+{
+	return set_var(hash_string(name), value(val));
+}
+
+template<>
+inline optional<const char*> globals_interface::get<const char*>(const char* name) const
+{
+	auto var = get_var(hash_string(name));
+	if (var && var->type == value::Type::String) {
+		return {var->get<value::Type::String>()};
+	}
+	return nullopt;
+}
+
+template<>
+inline bool globals_interface::set<const char*>(const char* name, const char* const& val)
+{
+	return set_var(hash_string(name), value(val));
+}
+
+template<>
+inline optional<list> globals_interface::get<list>(const char* name) const
+{
+	auto var = get_var(hash_string(name));
+	if (var && var->type == value::Type::List) {
+		return {var->get<value::Type::List>()};
+	}
+	return nullopt;
+}
+
+template<>
+inline bool globals_interface::set<list>(const char* name, const list& val)
+{
+	return set_var(hash_string(name), value(val));
+}
+
+///@}
+} // namespace ink::runtime

data/ext/inkcpp_rb/inkcpp/inkcpp/include/list.h

@@ -0,0 +1,187 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+
+#include "system.h"
+
+#ifdef INK_ENABLE_STL
+#	include <ostream>
+#endif
+
+#ifdef INK_BUILD_CLIB
+struct InkListIter;
+struct HInkList;
+int ink_list_flags(const HInkList*, InkListIter*);
+int ink_list_flags_from(const HInkList*, const char*, InkListIter*);
+int ink_list_iter_next(InkListIter*);
+#endif
+
+namespace ink::runtime
+{
+namespace internal
+{
+	class list_table;
+} // namespace internal
+
+/** Interface for accessing a Ink list.
+ *
+ * Every function which takes a flag name can also be feed with
+ * a full flag name in the format `listName.flagName`
+ * @code
+ * using namespace ink::runtime;
+ * list l = globals.get<list>("list_var");
+ * l.add("flagName");
+ * l.add("listName.FlagName")
+ * globals.set("list_var", l);
+ * @endcode
+ */
+class list_interface
+{
+public:
+	list_interface()
+	    : _list_table{nullptr}
+	    , _list{-1}
+	{
+	}
+
+	/** iterater for flags in a list
+	 * @todo implement `operator->`
+	 */
+	class iterator
+	{
+		const char*           _flag_name;
+		const char*           _list_name;
+		const list_interface& _list;
+		int                   _i;
+		bool                  _one_list_iterator; ///< iterates only though values of one list
+		friend list_interface;
+#ifdef INK_BUILD_CLIB
+		friend int ::ink_list_flags(const HInkList*, InkListIter*);
+		friend int ::ink_list_flags_from(const HInkList*, const char*, InkListIter*);
+		friend int ::ink_list_iter_next(InkListIter* self);
+#endif
+
+	protected:
+		/** @private */
+		iterator(
+		    const char* flag_name, const list_interface& list, size_t i, bool one_list_only = false
+		)
+		    : _flag_name(flag_name)
+		    , _list(list)
+		    , _i(i)
+		    , _one_list_iterator(one_list_only)
+		{
+		}
+
+	public:
+		/** contains flag data */
+		struct Flag {
+			const char* flag_name; ///< name of the flag
+			const char* list_name; ///< name of the list
+#ifdef INK_ENABLE_STL
+			/** serelization operator
+			 * @param os
+			 * @param flag
+			 */
+			friend std::ostream& operator<<(std::ostream& os, const Flag& flag)
+			{
+				os << flag.list_name << "(" << flag.flag_name << ")";
+				return os;
+			}
+#endif
+		};
+
+		/** access value the iterator is pointing to */
+		Flag operator*() const { return Flag{ _flag_name, _list_name }; };
+
+		/** continue iterator to next value */
+		iterator& operator++()
+		{
+			_list.next(_flag_name, _list_name, _i, _one_list_iterator);
+			return *this;
+		}
+
+		/** checks if iterator points not to the same element
+		 * @param itr other iterator
+		 */
+		bool operator!=(const iterator& itr) const { return itr._i != _i; }
+
+		/** checks if iterator points to the same element
+		 * @param itr other iterator
+		 */
+		bool operator==(const iterator& itr) const { return itr._i == _i; }
+	};
+
+	/** checks if a flag is contained in the list */
+	virtual bool contains(const char* flag) const
+	{
+		inkAssert(false, "Not implemented function from interfaces is called!");
+		return false;
+	};
+
+	/** add a flag to list */
+	virtual void add(const char* flag)
+	{
+		inkAssert(false, "Not implemented function from interface is called!");
+	};
+
+	/** removes a flag from list */
+	virtual void remove(const char* flag)
+	{
+		inkAssert(false, "Not implemented function from interface is called!");
+	};
+
+	/** begin iterator for contained flags in list */
+	virtual iterator begin() const
+	{
+		inkAssert(false, "Not implemented function from interface is called!");
+		return new_iterator(nullptr, -1);
+	};
+
+	/** returns a iterator over elements of the given list */
+	virtual iterator begin(const char* list_name) const
+	{
+		inkAssert(false, "Not implemented function from interface is called!");
+		return new_iterator(nullptr, -1);
+	}
+
+	/** end iterator for contained flags in list */
+	virtual iterator end() const
+	{
+		inkAssert(false, "Not implemented function from interface is called!");
+		return new_iterator(nullptr, -1);
+	};
+
+private:
+	friend iterator;
+
+	virtual void
+	    next(const char*& flag_name, const char*& list_name, int& i, bool _one_list_iterator) const
+	{
+		inkAssert(false, "Not implemented funciton from interface is called!");
+	};
+
+protected:
+	/** @private */
+	iterator new_iterator(const char* flag_name, int i, bool one_list_only = false) const
+	{
+		return iterator(flag_name, *this, i, one_list_only);
+	}
+
+	/** @private */
+	list_interface(internal::list_table& table, int list)
+	    : _list_table{&table}
+	    , _list{list}
+	{
+	}
+
+	/** @private */
+	internal::list_table* _list_table;
+	/** @private */
+	int                   _list;
+};
+} // namespace ink::runtime