inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/shared/private/command.h

@@ -0,0 +1,172 @@
+/* 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
+
+namespace ink
+{
+	// Commands (max 255)
+	enum class Command : unsigned char
+	{
+		// == Value Commands: Push values onto the stack
+		STR,
+		INT,
+		BOOL,
+		FLOAT,
+		VALUE_POINTER,
+		DIVERT_VAL,
+		LIST,
+		NEWLINE,
+		GLUE,
+		VOID,
+		TAG,
+
+		// == Diverts
+		DIVERT,
+		DIVERT_TO_VARIABLE,
+		TUNNEL,
+		FUNCTION,
+
+		// == Terminal commands
+		DONE,
+		END,
+		TUNNEL_RETURN,
+		FUNCTION_RETURN,
+
+		// == Variable definitions
+		DEFINE_TEMP,
+		SET_VARIABLE,
+
+		// == Evaluation stack
+		START_EVAL,
+		END_EVAL,
+		OUTPUT,
+		POP,
+		DUPLICATE,
+		PUSH_VARIABLE_VALUE,
+		VISIT,
+		TURN, /// How many choices where made since start of the story
+		READ_COUNT,
+		SEQUENCE,
+		SEED,
+
+		// == String stack
+		START_STR,
+		END_STR,
+		START_TAG,
+		END_TAG,
+
+		// == Choice commands
+		CHOICE,
+
+		// == Threading
+		THREAD,
+		// == thinary operations
+		LIST_RANGE,
+		OP_BEGIN = LIST_RANGE,
+		TERNARY_OPERATORS_START = LIST_RANGE,
+		TERNARY_OPERATORS_END = LIST_RANGE,
+		// == Binary operators
+		ADD,
+		BINARY_OPERATORS_START = ADD,
+		SUBTRACT,
+		DIVIDE,
+		MULTIPLY,
+		MOD,
+		RANDOM,
+		IS_EQUAL,
+		GREATER_THAN,
+		LESS_THAN,
+		GREATER_THAN_EQUALS,
+		LESS_THAN_EQUALS,
+		NOT_EQUAL,
+		AND,
+		OR,
+		MIN,
+		MAX,
+		HAS,
+		HASNT,
+		INTERSECTION,
+		LIST_INT,
+		BINARY_OPERATORS_END = LIST_INT,
+
+		// == Unary operators
+		UNARY_OPERATORS_START,
+		NOT = UNARY_OPERATORS_START,
+		NEGATE,
+		LIST_COUNT,
+		LIST_MIN,
+		LIST_MAX,
+		READ_COUNT_VAR,
+		TURNS,
+		lrnd,
+		FLOOR,
+		CEILING,
+		INT_CAST,
+		LIST_ALL,
+		LIST_INVERT,
+		LIST_VALUE,
+		UNARY_OPERATORS_END = LIST_VALUE,
+		CHOICE_COUNT,
+		OP_END,
+
+		// == Container tracking
+		START_CONTAINER_MARKER = OP_END,
+		END_CONTAINER_MARKER,
+
+		// == Function calls
+		CALL_EXTERNAL,
+
+		NUM_COMMANDS,
+	};
+
+	// Flags for commands
+	enum class CommandFlag : unsigned char
+	{
+		NO_FLAGS = 0,
+
+		// == Choice Flags ==
+		CHOICE_HAS_CONDITION = 1 << 0,
+		CHOICE_HAS_START_CONTENT = 1 << 1,
+		CHOICE_HAS_CHOICE_ONLY_CONTENT = 1 << 2,
+		CHOICE_IS_INVISIBLE_DEFAULT = 1 << 3,
+		CHOICE_IS_ONCE_ONLY = 1 << 4,
+
+		// == Divert flags
+		DIVERT_HAS_CONDITION = 1 << 0,
+		DIVERT_IS_FALLTHROUGH = 1 << 1, // Divert was auto-generated as a result of falling out of a containers content
+
+		// == Container marker
+		CONTAINER_MARKER_TRACK_VISITS = 1 << 0,
+		CONTAINER_MARKER_TRACK_TURNS = 1 << 1,
+		CONTAINER_MARKER_ONLY_FIRST = 1 << 2,
+
+		// == Variable assignment
+		ASSIGNMENT_IS_REDEFINE = 1 << 0,
+
+		// == Function/Tunnel flags
+		FUNCTION_TO_VARIABLE = 1 << 0,
+		TUNNEL_TO_VARIABLE = 1 << 0,
+		FALLBACK_FUNCTION = 1 << 1,
+		// note a internal function which should only be called if external reference is not working
+	};
+
+	inline bool operator& (CommandFlag lhs, CommandFlag rhs)
+	{
+		return (static_cast<unsigned char>(lhs) & static_cast<unsigned char>(rhs)) > 0;
+	}
+
+	inline CommandFlag& operator|= (CommandFlag& lhs, CommandFlag rhs)
+	{
+		lhs = static_cast<CommandFlag>(static_cast<unsigned char>(lhs) | static_cast<unsigned char>(rhs));
+		return lhs;
+	}
+
+	template<typename PayloadType>
+	constexpr unsigned int CommandSize = sizeof(Command) + sizeof(CommandFlag) + sizeof(PayloadType);
+
+  extern const char* CommandStrings[];
+}

data/ext/inkcpp_rb/inkcpp/shared/private/header.h

@@ -0,0 +1,46 @@
+/* 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"
+
+namespace ink::internal {
+
+		struct header {
+			static header parse_header(const char* data);
+
+			template<typename T>
+			static T swap_bytes(const T& value) {
+				char data[sizeof(T)];
+				for (int i = 0; i < sizeof(T); ++i) {
+					data[i] = reinterpret_cast<const char*>(&value)[sizeof(T)-1-i];
+				}
+				return *reinterpret_cast<const T*>(data);
+			}
+			list_flag read_list_flag(const char*& ptr) const {
+				list_flag result = *reinterpret_cast<const list_flag*>(ptr);
+				ptr += sizeof(list_flag);
+				if (endien == ink::internal::header::endian_types::differ) {
+					result.flag = swap_bytes(result.flag);
+					result.list_id = swap_bytes(result.list_id);
+				}
+				return result;
+			}
+
+			enum class  endian_types: uint16_t {
+				none = 0,
+				same = 0x0001,
+				differ = 0x0100
+			} endien = endian_types::none;
+			uint32_t ink_version_number = 0;
+			uint32_t ink_bin_version_number = 0;
+			static constexpr size_t Size = ///< actual data size of Header,
+										   ///   because padding of struct may
+										   ///   differ between platforms
+				sizeof(uint16_t) + 2 * sizeof(uint32_t);
+		};
+}

data/ext/inkcpp_rb/inkcpp/shared/public/config.h

@@ -0,0 +1,53 @@
+/* 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
+
+#ifdef INKCPP_API
+#	define INK_ENABLE_UNREAL
+#elif INKCPP_BUILD_CLIB
+#	define INK_ENABLE_CSTD
+#else
+#	define INK_ENABLE_STL
+#	define INK_ENABLE_CSTD
+#endif
+
+// Only turn on if you have json.hpp and you want to use it with the compiler
+// #define INK_EXPOSE_JSON
+
+namespace ink::config
+{
+/// set limitations which are required to minimize heap allocations.
+/// if required you can set them to -x then, the system will use dynamic
+/// allocation for this type, with an initial size of x.
+static constexpr int limitGlobalVariables         = -50;
+static constexpr int limitGlobalVariableObservers = -10;
+static constexpr int limitThreadDepth             = -10;
+static constexpr int limitEvalStackDepth          = -20;
+static constexpr int limitContainerDepth          = -20;
+/** number of lists which can be accessed with get_var
+ *  before the story must continue
+ * @attention list vars are only valid until the story continous!
+ */
+static constexpr int limitEditableLists           = -5;
+/// number of simultaneous active tags
+static constexpr int limitActiveTags              = -10;
+// temporary variables and callstack;
+static constexpr int limitRuntimeStack            = -20;
+// references  and callstack
+static constexpr int limitReferenceStack          = -20;
+// max number of elements in one output (a string is one element)
+// no dynamic support now! (FIXME)
+static constexpr int limitOutputSize              = 200;
+// max number of choices per choice
+static constexpr int maxChoices                   = -10;
+// max number of list types, and there total amount of flags
+static constexpr int maxListTypes                 = -20;
+static constexpr int maxFlags                     = -200;
+// number of max initelized lists
+static constexpr int maxLists                     = -50;
+static constexpr int maxArrayCallArity            = 10;
+} // namespace ink::config

data/ext/inkcpp_rb/inkcpp/shared/public/system.h

@@ -0,0 +1,307 @@
+/* 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"
+
+#ifdef INK_ENABLE_UNREAL
+#	include "Misc/AssertionMacros.h"
+#	include "Misc/CString.h"
+#	include "HAL/UnrealMemory.h"
+#	include "Hash/CityHash.h"
+
+#endif
+#ifdef INK_ENABLE_STL
+#	include <exception>
+#	include <stdexcept>
+#	include <optional>
+#	include <cctype>
+#	include <cstdint>
+#	include <cstdio>
+#	include <cstdarg>
+#endif
+
+// Platform specific defines //
+
+#ifdef INK_ENABLE_UNREAL
+#	define inkZeroMemory(buff, len)        FMemory::Memset(buff, 0, len)
+#	define inkAssert(condition, text, ...) checkf(condition, TEXT(text), ##__VA_ARGS__)
+#	define inkFail(text, ...)              checkf(false, TEXT(text), ##__VA_ARGS__)
+#	define FORMAT_STRING_STR               "%hs"
+#else
+#	define inkZeroMemory     ink::internal::zero_memory
+#	define inkAssert         ink::ink_assert
+#	define inkFail(...)      ink::ink_assert(false, __VA_ARGS__)
+#	define FORMAT_STRING_STR "%s"
+#endif
+
+namespace ink
+{
+/** define basic numeric type
+ * @todo use a less missleading name
+ */
+typedef unsigned int uint32_t;
+
+/** Name hash (used for temporary variables) */
+typedef uint32_t hash_t;
+
+/** Invalid hash value */
+const hash_t InvalidHash = 0;
+
+#ifdef INK_ENABLE_UNREAL
+/** Simple hash for serialization of strings */
+inline hash_t hash_string(const char* string)
+{
+	return CityHash32(string, FCStringAnsi::Strlen(string));
+}
+#else
+hash_t hash_string(const char* string);
+#endif
+
+/** Byte type */
+typedef unsigned char byte_t;
+
+/** Used to identify an offset in a data table (like a string in the string table) */
+typedef uint32_t offset_t;
+
+/** Instruction pointer used for addressing within the story instructions */
+typedef const unsigned char* ip_t;
+
+/** Used for the size of arrays */
+typedef unsigned int size_t;
+
+/** Used as the unique identifier for an ink container */
+typedef uint32_t container_t;
+
+/** Used to uniquely identify threads */
+typedef uint32_t thread_t;
+
+/** Used to unique identify a list flag  */
+struct list_flag {
+	int16_t list_id;
+	int16_t flag;
+
+	bool operator==(const list_flag& o) const { return list_id == o.list_id && flag == o.flag; }
+
+	bool operator!=(const list_flag& o) const { return ! (*this == o); }
+};
+
+/** value of an unset list_flag */
+constexpr list_flag null_flag{-1, -1};
+/** value representing an empty list */
+constexpr list_flag empty_flag{-1, 0};
+
+namespace internal
+{
+	/** Checks if a string is only whitespace*/
+	static bool is_whitespace(const char* string, bool includeNewline = true)
+	{
+		// Iterate string
+		while (true) {
+			switch (*(string++)) {
+				case 0: return true;
+				case '\n':
+					if (! includeNewline)
+						return false;
+				case '\t':
+				case ' ': continue;
+				default: return false;
+			}
+		}
+	}
+
+	/** check if character can be only part of a word, when two part of word characters put together
+	 * the will be a space inserted I049
+	 */
+	inline bool is_part_of_word(char character) { return isalpha(character) || isdigit(character); }
+
+	inline constexpr bool is_whitespace(char character, bool includeNewline = true)
+	{
+		switch (character) {
+			case '\n':
+				if (! includeNewline)
+					return false;
+			case '\t': [[fallthrough]];
+			case ' ': return true;
+			default: return false;
+		}
+	}
+
+#ifndef INK_ENABLE_UNREAL
+	/** populate memory with Zero */
+	void zero_memory(void* buffer, size_t length);
+#endif
+} // namespace internal
+
+#ifdef INK_ENABLE_STL
+/** exception type thrown if something goes wrong */
+using ink_exception = std::runtime_error;
+#else
+// Non-STL exception class
+class ink_exception
+{
+public:
+	ink_exception(const char* msg)
+	    : _msg(msg)
+	{
+	}
+
+	inline const char* message() const { return _msg; }
+
+private:
+	const char* _msg;
+};
+#endif
+
+// assert
+#ifndef INK_ENABLE_UNREAL
+template<typename... Args>
+void ink_assert(bool condition, const char* msg = nullptr, Args... args)
+{
+	static const char* EMPTY = "";
+	if (msg == nullptr) {
+		msg = EMPTY;
+	}
+	if (! condition) {
+		if constexpr (sizeof...(args) > 0) {
+			char* message = static_cast<char*>(malloc(snprintf(nullptr, 0, msg, args...) + 1));
+			sprintf(message, msg, args...);
+			throw ink_exception(message);
+		} else {
+			throw ink_exception(msg);
+		}
+	}
+}
+
+template<typename... Args>
+[[noreturn]] inline void ink_assert(const char* msg = nullptr, Args... args)
+{
+	ink_assert(false, msg, args...);
+	exit(EXIT_FAILURE);
+}
+#endif
+
+namespace runtime::internal
+{
+	constexpr unsigned abs(int i) { return i < 0 ? -i : i; }
+
+	template<typename T>
+	struct always_false {
+		static constexpr bool value = false;
+	};
+
+	template<bool Con, typename T1, typename T2>
+	struct if_type {
+		using type = T1;
+	};
+
+	template<typename T1, typename T2>
+	struct if_type<false, T1, T2> {
+		using type = T2;
+	};
+
+	template<bool Con, typename T1, typename T2>
+	using if_t = typename if_type<Con, T1, T2>::type;
+
+	template<bool Enable, typename T = void>
+	struct enable_if {
+	};
+
+	template<typename T>
+	struct enable_if<true, T> {
+		using type = T;
+	};
+
+	template<bool Enable, typename T = void>
+	using enable_if_t = typename enable_if<Enable, T>::type;
+} // namespace runtime::internal
+
+
+#ifdef INK_ENABLE_STL
+/** custom optional implementation for usage if STL is disabled
+ * @tparam T type contaied in optional
+ */
+template<typename T>
+using optional                   = std::optional<T>;
+/** an empty #optional */
+constexpr std::nullopt_t nullopt = std::nullopt;
+#else
+struct nullopt_t {
+};
+
+constexpr nullopt_t nullopt;
+
+template<typename T>
+class optional
+{
+public:
+	optional() {}
+
+	optional(nullopt_t) {}
+
+	optional(T&& val)
+	    : _has_value{true}
+	    , _value{val}
+	{
+	}
+
+	optional(const T& val)
+	    : _has_value{true}
+	    , _value{val}
+	{
+	}
+
+	const T& operator*() const { return _value; }
+
+	T& operator*() { return _value; }
+
+	const T* operator->() const { return &_value; }
+
+	T* operator->() { return &_value; }
+
+	constexpr bool has_value() const { return _has_value; }
+
+	constexpr T& value()
+	{
+		test_value();
+		return _value;
+	}
+
+	constexpr const T& value() const
+	{
+		test_value();
+		return _value;
+	}
+
+	constexpr operator bool() const { return has_value(); }
+
+	template<typename U>
+	constexpr T value_or(U&& u) const
+	{
+		return _has_value ? _value : static_cast<T>(u);
+	}
+
+	template<typename... Args>
+	T& emplace(Args... args)
+	{
+		_value.~T();
+		return *(new (&_value) T(args...));
+	}
+
+private:
+	void test_value() const
+	{
+		if (! _has_value) {
+			inkFail("Can't access empty optional!");
+		}
+	}
+
+	bool _has_value = false;
+	T    _value;
+};
+#endif
+} // namespace ink

data/ext/inkcpp_rb/inkcpp/shared/public/version.h

@@ -0,0 +1,14 @@
+/* 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"
+
+namespace ink {
+constexpr uint32_t InkBinVersion = 1;  ///< Supportet version of ink.bin files
+constexpr uint32_t InkVersion    = 21; ///< Supported version of ink.json files
+};

data/ext/inkcpp_rb/inkcpp/tests/TestAllSequenceTypes.ink

@@ -0,0 +1,59 @@
+/**
+Once: one two
+Stopping: one two two two
+Default: one two two two
+Cycle: one two one two
+Shuffle: two two one one
+Shuffle stopping: two one final final
+Shuffle once: one one
+**/
+
+~ SEED_RANDOM(1)
+
+Once: {f_once()} {f_once()} {f_once()} {f_once()}
+Stopping: {f_stopping()} {f_stopping()} {f_stopping()} {f_stopping()}
+Default: {f_default()} {f_default()} {f_default()} {f_default()}
+Cycle: {f_cycle()} {f_cycle()} {f_cycle()} {f_cycle()}
+Shuffle: {f_shuffle()} {f_shuffle()} {f_shuffle()} {f_shuffle()}
+Shuffle stopping: {f_shuffle_stopping()} {f_shuffle_stopping()} {f_shuffle_stopping()} {f_shuffle_stopping()}
+Shuffle once: {f_shuffle_once()} {f_shuffle_once()} {f_shuffle_once()} {f_shuffle_once()}
+
+== function f_once ==
+{once:
+    - one
+    - two
+}
+
+== function f_stopping ==
+{stopping:
+    - one
+    - two
+}
+
+== function f_default ==
+{one|two}
+
+== function f_cycle ==
+{cycle:
+    - one
+    - two
+}
+
+== function f_shuffle ==
+{shuffle:
+    - one
+    - two
+}
+
+== function f_shuffle_stopping ==
+{stopping shuffle:
+    - one
+    - two
+    - final
+}
+
+== function f_shuffle_once ==
+{shuffle once:
+    - one
+    - two
+}

data/ext/inkcpp_rb/inkcpp/tests/TestArithmetic.ink

@@ -0,0 +1,17 @@
+/**
+36
+2
+3
+2
+2.333333
+8
+8
+**/
+
+{ 2 * 3 + 5 * 6 }
+{8 mod 3}
+{13 % 5}
+{ 7 / 3 }
+{ 7 / 3.0 }
+{ 10 - 2 }
+{ 2 * (5-1) }

data/ext/inkcpp_rb/inkcpp/tests/TestBasicStringLiterals.ink

@@ -0,0 +1,8 @@
+/**
+Hello world 1
+Hello world 2.
+**/
+
+VAR x = "Hello world 1"
+{x}
+Hello {"world"} 2.

data/ext/inkcpp_rb/inkcpp/tests/TestBasicTunnel.ink

@@ -0,0 +1,10 @@
+/**
+Hello world
+**/
+
+-> f ->
+<> world
+
+== f ==
+Hello
+->->