inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp/numeric_operations.h

@@ -0,0 +1,529 @@
+/* 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 "value.h"
+
+/// Define operation for numeric types.
+/// use generalized types numeric and integral to keep redundancy minimal.
+/// define a cast to support operations like int + float, bool + uint etc.
+
+namespace ink::runtime::internal
+{
+
+/// list of numeric value types
+/// produces a SFINAE error if type is not part of list
+template<value_type ty>
+using is_numeric_t = typename enable_if<
+    ty == value_type::boolean || ty == value_type::int32 || ty == value_type::uint32
+        || ty == value_type::float32,
+    void>::type;
+
+template<value_type ty>
+using is_signed_numeric_t =
+    typename enable_if<ty == value_type::int32 || ty == value_type::float32, void>::type;
+
+/// list of internal value types
+/// produces a SFINAE error if type is not part of list
+template<value_type ty>
+using is_integral_t = typename enable_if<
+    ty == value_type::boolean || ty == value_type::int32 || ty == value_type::uint32, void>::type;
+
+namespace casting
+{
+	/// define valid casts
+
+	/// result of operation with int and float is float.
+	template<>
+	struct cast<value_type::int32, value_type::float32> {
+		static constexpr value_type value = value_type::float32;
+	};
+
+	template<>
+	struct cast<value_type::uint32, value_type::float32> {
+		static constexpr value_type value = value_type::float32;
+	};
+
+	template<>
+	struct cast<value_type::boolean, value_type::float32> {
+		static constexpr value_type value = value_type::float32;
+	};
+
+	template<>
+	struct cast<value_type::int32, value_type::uint32> {
+		static constexpr value_type value = value_type::int32;
+	};
+
+	/// result of operation with uint and bool is uint
+	template<>
+	struct cast<value_type::boolean, value_type::uint32> {
+		static constexpr value_type value = value_type::uint32;
+	};
+
+	// result of operation with bool and int is int
+	template<>
+	struct cast<value_type::boolean, value_type::int32> {
+		static constexpr value_type value = value_type::int32;
+	};
+
+	/// defined numeric cast
+	/// generic numeric_cast only allow casting to its one type
+	template<value_type to>
+	inline typename value::ret<to>::type numeric_cast(const value& v)
+	{
+		if (to == v.type()) {
+			return v.get<to>();
+		} else {
+			inkFail("invalid numeric_cast! from %i to %i", v.type(), to);
+			return 0;
+		}
+	}
+
+	/// specialisation for uint32
+	template<>
+	inline typename value::ret<value_type::uint32>::type
+	    numeric_cast<value_type::uint32>(const value& v)
+	{
+		switch (v.type()) {
+			case value_type::uint32: return v.get<value_type::uint32>();
+			/// bool value can cast to uint32
+			case value_type::boolean: return static_cast<uint32_t>(v.get<value_type::boolean>());
+			default: inkFail("invalid cast to uint!"); return 0;
+		}
+	}
+
+	template<>
+	inline typename value::ret<value_type::int32>::type numeric_cast<value_type::int32>(const value& v
+	)
+	{
+		switch (v.type()) {
+			case value_type::int32: return v.get<value_type::int32>();
+			case value_type::uint32: return static_cast<int32_t>(v.get<value_type::uint32>());
+			case value_type::boolean: return static_cast<int32_t>(v.get<value_type::boolean>());
+			default: inkFail("invalid cast to int!"); return 0;
+		}
+	}
+
+	/// specialisation for float32
+	template<>
+	inline float numeric_cast<value_type::float32>(const value& v)
+	{
+		switch (v.type()) {
+			case value_type::float32: return v.get<value_type::float32>();
+			// int value can cast to float
+			case value_type::int32: return static_cast<float>(v.get<value_type::int32>());
+			case value_type::uint32: return static_cast<float>(v.get<value_type::uint32>());
+			default: inkFail("invalid numeric_cast!"); return 0;
+		}
+	}
+
+	/// specialisation for boolean
+	template<>
+	inline bool numeric_cast<value_type::boolean>(const value& v)
+	{
+		switch (v.type()) {
+			case value_type::boolean: return v.get<value_type::boolean>();
+			case value_type::int32: return v.get<value_type::int32>() != 0;
+			case value_type::uint32: return v.get<value_type::uint32>() != 0;
+			case value_type::float32: return v.get<value_type::float32>() != 0;
+			default: inkFail("invalid numeric_cast to boolean from: %i", v.type()); return false;
+		}
+	}
+} // namespace casting
+
+template<>
+class operation<Command::FLOOR, value_type::float32, void> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+	void operator()(basic_eval_stack& stack, value* vals);
+};
+
+template<>
+class operation<Command::CEILING, value_type::float32, void> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+	void operator()(basic_eval_stack& stack, value* vals);
+};
+
+template<value_type ty>
+class operation<Command::INT_CAST, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::int32>(static_cast<int32_t>(vals->get<ty>())));
+	}
+};
+
+template<>
+class operation<Command::IS_EQUAL, value_type::divert, void> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(
+		    vals[0].get<value_type::divert>() == vals[1].get<value_type::divert>()
+		));
+	}
+};
+
+template<>
+class operation<Command::NOT_EQUAL, value_type::divert, void> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(
+		    vals[0].get<value_type::divert>() != vals[1].get<value_type::divert>()
+		));
+	}
+};
+
+template<value_type ty>
+class operation<Command::FLOOR, ty, is_integral_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		// for integral types floor(i) == i
+		stack.push(vals[0]);
+	}
+};
+
+template<value_type ty>
+class operation<Command::CEILING, ty, is_integral_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		// for integral types ceil(i) == i
+		stack.push(vals[0]);
+	}
+};
+
+template<value_type ty>
+class operation<Command::ADD, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(
+		    value{}.set<ty>(casting::numeric_cast<ty>(vals[0]) + casting::numeric_cast<ty>(vals[1]))
+		);
+	}
+};
+
+template<value_type ty>
+class operation<Command::SUBTRACT, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(
+		    value{}.set<ty>(casting::numeric_cast<ty>(vals[0]) - casting::numeric_cast<ty>(vals[1]))
+		);
+	}
+};
+
+template<>
+class operation<Command::SUBTRACT, value_type::boolean, void> : public operation_base<void>
+{
+	operation<Command::SUBTRACT, value_type::int32> op_int;
+
+public:
+	template<typename T>
+	operation(const T& t)
+	    : operation_base{t}
+	    , op_int{t}
+	{
+	}
+
+	void operator()(basic_eval_stack& stack, value* vals) { op_int(stack, vals); }
+};
+
+template<value_type ty>
+class operation<Command::DIVIDE, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(
+		    value{}.set<ty>(casting::numeric_cast<ty>(vals[0]) / casting::numeric_cast<ty>(vals[1]))
+		);
+	}
+};
+
+template<>
+class operation<Command::DIVIDE, value_type::boolean, void> : public operation_base<void>
+{
+	operation<Command::DIVIDE, value_type::int32> op_int;
+
+public:
+	template<typename T>
+	operation(const T& t)
+	    : operation_base{t}
+	    , op_int{t}
+	{
+	}
+
+	void operator()(basic_eval_stack& stack, value* vals) { op_int(stack, vals); }
+};
+
+template<value_type ty>
+class operation<Command::MULTIPLY, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(
+		    value{}.set<ty>(casting::numeric_cast<ty>(vals[0]) * casting::numeric_cast<ty>(vals[1]))
+		);
+	}
+};
+
+template<value_type ty>
+class operation<Command::MOD, ty, is_integral_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(
+		    value{}.set<ty>(casting::numeric_cast<ty>(vals[0]) % casting::numeric_cast<ty>(vals[1]))
+		);
+	}
+};
+
+template<>
+class operation<Command::MOD, value_type::boolean, void> : public operation_base<void>
+{
+	operation<Command::MOD, value_type::int32> op_int;
+
+public:
+	template<typename T>
+	operation(const T& t)
+	    : operation_base{t}
+	    , op_int{t}
+	{
+	}
+
+	void operator()(basic_eval_stack& stack, value* vals) { op_int(stack, vals); }
+};
+
+template<value_type ty>
+class operation<Command::IS_EQUAL, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(
+		    casting::numeric_cast<ty>(vals[0]) == casting::numeric_cast<ty>(vals[1])
+		));
+	}
+};
+
+template<value_type ty>
+class operation<Command::GREATER_THAN, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(
+		    casting::numeric_cast<ty>(vals[0]) > casting::numeric_cast<ty>(vals[1])
+		));
+	}
+};
+
+template<value_type ty>
+class operation<Command::LESS_THAN, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(
+		    casting::numeric_cast<ty>(vals[0]) < casting::numeric_cast<ty>(vals[1])
+		));
+	}
+};
+
+template<value_type ty>
+class operation<Command::GREATER_THAN_EQUALS, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(
+		    casting::numeric_cast<ty>(vals[0]) >= casting::numeric_cast<ty>(vals[1])
+		));
+	}
+};
+
+template<value_type ty>
+class operation<Command::LESS_THAN_EQUALS, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(
+		    casting::numeric_cast<ty>(vals[0]) <= casting::numeric_cast<ty>(vals[1])
+		));
+	}
+};
+
+template<value_type ty>
+class operation<Command::NOT_EQUAL, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(
+		    casting::numeric_cast<ty>(vals[0]) != casting::numeric_cast<ty>(vals[1])
+		));
+	}
+};
+
+template<value_type ty>
+class operation<Command::AND, ty, is_integral_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(
+		    casting::numeric_cast<value_type::boolean>(vals[0])
+		    && casting::numeric_cast<value_type::boolean>(vals[1])
+		));
+	}
+};
+
+template<value_type ty>
+class operation<Command::OR, ty, is_integral_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(
+		    casting::numeric_cast<value_type::boolean>(vals[0])
+		    || casting::numeric_cast<value_type::boolean>(vals[1])
+		));
+	}
+};
+
+template<value_type ty>
+class operation<Command::MIN, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		typename value::ret<ty>::type n[2]
+		    = {casting::numeric_cast<ty>(vals[0]), casting::numeric_cast<ty>(vals[1])};
+		stack.push(value{}.set<ty>(n[0] < n[1] ? n[0] : n[1]));
+	}
+};
+
+template<value_type ty>
+class operation<Command::MAX, ty, is_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		typename value::ret<ty>::type n[2]
+		    = {casting::numeric_cast<ty>(vals[0]), casting::numeric_cast<ty>(vals[1])};
+		stack.push(value{}.set<ty>(n[0] > n[1] ? n[0] : n[1]));
+	}
+};
+
+template<value_type ty>
+class operation<Command::NOT, ty, is_integral_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(! vals[0].get<ty>()));
+	}
+};
+
+template<value_type ty>
+class operation<Command::NEGATE, ty, is_signed_numeric_t<ty>> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<ty>(-vals[0].get<ty>()));
+	}
+};
+
+template<>
+class operation<Command::NEGATE, value_type::boolean, void> : public operation_base<void>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		stack.push(value{}.set<value_type::boolean>(! vals[0].get<value_type::boolean>()));
+	}
+};
+
+template<>
+class operation<Command::RANDOM, value_type::int32, void> : public operation_base<prng>
+{
+public:
+	using operation_base::operation_base;
+
+	void operator()(basic_eval_stack& stack, value* vals)
+	{
+		int min = casting::numeric_cast<value_type::int32>(vals[0]);
+		int max = casting::numeric_cast<value_type::int32>(vals[1]);
+		stack.push(value{}.set<value_type::int32>(static_cast<int32_t>(_prng.rand(max - min + 1) + min))
+		);
+	}
+};
+} // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/operation_bases.h

@@ -0,0 +1,164 @@
+/* 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
+
+/// defines data storage for operations.
+/// provide constructor and handle the data member.
+/// the data member therefore are protected accessible
+
+#include "system.h"
+#include "./tuple.hpp"
+#include "random.h"
+
+namespace ink::runtime {
+	class runner_interface;
+}
+namespace ink::runtime::internal {
+	class string_table;
+	class list_table;
+	class story_impl;
+	class globals_impl;
+
+	/// base class for operations to acquire data and provide flags and
+	/// constructor
+	template<typename ...>
+	class operation_base {
+	public:
+		static constexpr bool enabled = false;
+		template<typename T>
+		operation_base(const T&) { static_assert(always_false<T>::value, "use undefined base!"); }
+	};
+
+	template<>
+	class operation_base<void> {
+	public:
+		static constexpr bool enabled = true;
+		template<typename T>
+		operation_base(const T&) {}
+	};
+
+	// base class for operations which needs a string_table
+	template<>
+	class operation_base<string_table> {
+	public:
+		static constexpr bool enabled = true;
+		template<typename T>
+		operation_base(const T& t) : _string_table{*get<string_table*,T>(t)} {
+			static_assert(has_type<string_table*,T>::value, "Executioner "
+					"constructor needs a string table to instantiate "
+					"some operations!");
+		}
+
+	protected:
+		string_table& _string_table;
+	};
+
+	// base class for operations which needs a list_table
+	template<>
+	class operation_base<list_table> {
+	public:
+		static constexpr bool enabled = true;
+		template<typename T>
+		operation_base(const T& t) : _list_table{*get<list_table*,T>(t)} {
+			static_assert(has_type<list_table*,T>::value, "Executioner "
+					"constructor needs a list table to instantiate "
+					"some operations!");
+		}
+
+	protected:
+		list_table& _list_table;
+	};
+
+	// base class for operations which needs a list_table
+	template<>
+	class operation_base<prng> {
+	public:
+		static constexpr bool enabled = true;
+		template<typename T>
+		operation_base(const T& t) : _prng{*get<prng*,T>(t)} {
+			static_assert(has_type<prng*,T>::value, "Executioner "
+					"constructor needs a list table to instantiate "
+					"some operations!");
+		}
+
+	protected:
+		prng& _prng;
+	};
+
+
+	template<>
+	class operation_base<list_table, prng> {
+	public:
+		static constexpr bool enabled = true;
+		template<typename T>
+		operation_base(const T& t)
+		: _list_table{*get<list_table*,T>(t)}, _prng{*get<prng*,T>(t)}
+		{
+			static_assert(has_type<list_table*,T>::value, "Executioner "
+					"constructor needs a list table to instantiate "
+					"some operations!");
+			static_assert(has_type<prng*,T>::value, "Executioner "
+					"constructor needs a RNG to instantiate "
+					"some operations!");
+		}
+
+	protected:
+		list_table& _list_table;
+		prng& _prng;
+	};
+
+	template<>
+	class operation_base<const story_impl, globals_impl> {
+		template<typename T>
+		static const story_impl& get_story(const T& t) {
+			if constexpr (has_type<const story_impl*,T>::value) {
+				return *get<const story_impl*,T>(t);
+			} else {
+				static_assert(has_type<story_impl*,T>::value, "Executioner "
+						"constructor needs a story_impl to instantiate "
+						"container related operations!");
+				return *get<story_impl*,T>(t);
+			}
+		}
+	public:
+		static constexpr bool enabled = true;
+		template<typename T>
+		operation_base(const T& t)
+		: _story{get_story(t)}, _visit_counts{*get<globals_impl*,T>(t)}
+		{
+			static_assert(has_type<globals_impl*,T>::value, "Executioner "
+					"constructor needs access to globals to instantiate "
+					"container related operations!");
+		}
+
+	protected:
+		const story_impl& _story;
+		globals_impl& _visit_counts;
+	};
+
+	template<>
+	class operation_base<const runner_interface> {
+		template<typename T>
+		static const runner_interface& get_const(const T& t) {
+			if constexpr (has_type<const runner_interface*,T>::value) {
+				return *get<const runner_interface*,T>(t);
+			} else {
+				static_assert(has_type<runner_interface*,T>::value,
+						"Executioner constructor needs a runner to instantiate.");
+				return *get<runner_interface*,T>(t);
+			}
+		}
+	public:
+		static constexpr bool enabled = true;
+		template<typename T>
+		operation_base(const T& t)
+		: _runner{get_const(t)}
+		{ }
+	protected:
+		const runner_interface& _runner;
+	};
+}