inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp/globals_impl.cpp

@@ -0,0 +1,289 @@
+/* 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.
+ */
+#include "globals_impl.h"
+#include "story_impl.h"
+#include "runner_impl.h"
+#include "snapshot_impl.h"
+#include "system.h"
+#include "types.h"
+
+namespace ink::runtime::internal
+{
+globals_impl::globals_impl(const story_impl* story)
+    : _num_containers(story->num_containers())
+    , _turn_cnt{0}
+    , _visit_counts()
+    , _visit_counts_backup()
+    , _owner(story)
+    , _runners_start(nullptr)
+    , _lists(story->list_meta(), story->get_header())
+    , _globals_initialized(false)
+{
+	_visit_counts.resize(_num_containers);
+	_visit_counts_backup.resize(_num_containers);
+	if (_lists) {
+		// initelize static lists
+		const list_flag* flags = story->lists();
+		while (*flags != null_flag) {
+			list_table::list l = _lists.create_permament();
+			while (*flags != null_flag) {
+				list_flag flag = _lists.external_fvalue_to_internal(*flags);
+				_lists.add_inplace(l, flag);
+				++flags;
+			}
+			++flags;
+		}
+		for (const auto& flag : _lists.named_flags()) {
+			set_variable(
+			    hash_string(flag.name),
+			    value{}.set<value_type::list_flag>(list_flag{flag.flag.list_id, flag.flag.flag})
+			);
+		}
+	}
+}
+
+void globals_impl::visit(uint32_t container_id, bool entering_at_start)
+{
+	if ((! (_owner->container_flag(container_id) & CommandFlag::CONTAINER_MARKER_ONLY_FIRST))
+	    || entering_at_start) {
+		_visit_counts[container_id].visits += 1;
+		_visit_counts[container_id].turns = 0;
+	}
+}
+
+uint32_t globals_impl::visits(uint32_t container_id) const
+{
+	return _visit_counts[container_id].visits;
+}
+
+uint32_t globals_impl::turns() const { return _turn_cnt; }
+
+void globals_impl::turn()
+{
+	++_turn_cnt;
+	for (size_t i = 0; i < _visit_counts.size(); ++i) {
+		if (_visit_counts[i].turns != -1) {
+			_visit_counts[i].turns += 1;
+		}
+	}
+}
+
+uint32_t globals_impl::turns(uint32_t container_id) const
+{
+	return _visit_counts[container_id].turns;
+}
+
+void globals_impl::add_runner(const runner_impl* runner)
+{
+	// cache start of list
+	auto first = _runners_start;
+
+	// create new entry as start, linked to the previous start
+	_runners_start = new runner_entry{runner, first};
+}
+
+void globals_impl::remove_runner(const runner_impl* runner)
+{
+	// iterate linked list
+	runner_entry* prev = nullptr;
+	auto          iter = _runners_start;
+	while (iter != nullptr) {
+		if (iter->object == runner) {
+			// Fixup next pointer
+			if (prev != nullptr)
+				prev->next = iter->next;
+			else
+				_runners_start = iter->next;
+
+			// delete
+			delete iter;
+			return;
+		}
+
+		// move on to next entry
+		prev = iter;
+		iter = iter->next;
+	}
+}
+
+void globals_impl::set_variable(hash_t name, const value& val)
+{
+	ink::optional<value> old_var   = ink::nullopt;
+	value*               p_old_var = get_variable(name);
+	if (p_old_var != nullptr) {
+		old_var = *p_old_var;
+	}
+
+	_variables.set(name, val);
+
+	for (auto& callback : _callbacks) {
+		if (callback.name == name) {
+			if (old_var.has_value()) {
+				callback.operation->call(
+				    val.to_interface_value(lists()), {old_var->to_interface_value(lists())}
+				);
+			} else {
+				callback.operation->call(val.to_interface_value(lists()), ink::nullopt);
+			}
+		}
+	}
+}
+
+const value* globals_impl::get_variable(hash_t name) const { return _variables.get(name); }
+
+value* globals_impl::get_variable(hash_t name) { return _variables.get(name); }
+
+optional<ink::runtime::value> globals_impl::get_var(hash_t name) const
+{
+	auto* var = get_variable(name);
+	if (! var) {
+		return nullopt;
+	}
+	return {var->to_interface_value(_lists)};
+}
+
+bool globals_impl::set_var(hash_t name, const ink::runtime::value& val)
+{
+	auto* var = get_variable(name);
+	if (! var) {
+		return false;
+	}
+	ink::runtime::value old_val = var->to_interface_value(lists());
+
+	bool ret = false;
+	if (val.type == ink::runtime::value::Type::String) {
+		if (! (var->type() == value_type::none || var->type() == value_type::string)) {
+			return false;
+		}
+		size_t size = 0;
+		char*  ptr;
+		for (const char* i = val.get<runtime::value::Type::String>(); *i; ++i) {
+			++size;
+		}
+		char* new_string = strings().create(size + 1);
+		strings().mark_used(new_string);
+		ptr = new_string;
+		for (const char* i = val.get<runtime::value::Type::String>(); *i; ++i) {
+			*ptr++ = *i;
+		}
+		*ptr = 0;
+		*var = value{}.set<value_type::string>(static_cast<const char*>(new_string), true);
+		ret  = true;
+	} else {
+		ret = var->set(val);
+	}
+
+	for (auto& callback : _callbacks) {
+		if (callback.name == name) {
+			callback.operation->call(val, {old_val});
+		}
+	}
+
+	return ret;
+}
+
+void globals_impl::internal_observe(hash_t name, callback_base* callback)
+{
+	_callbacks.push() = Callback{.name = name, .operation = callback};
+	if (_globals_initialized) {
+		value* p_var = _variables.get(name);
+		inkAssert(
+		    p_var != nullptr,
+		    "Global variable to observe does not exists after initiliazation. This variable will "
+		    "therofe not get any value."
+		);
+		callback->call(p_var->to_interface_value(lists()), ink::nullopt);
+	}
+}
+
+void globals_impl::initialize_globals(runner_impl* run)
+{
+	// If no way to move there, then there are no globals.
+	if (! run->move_to(hash_string("global decl"))) {
+		return;
+	}
+
+	// execute one line to startup the globals
+	run->getline_silent();
+	_globals_initialized = true;
+}
+
+void globals_impl::gc()
+{
+	// Mark all strings as unused
+	_strings.clear_usage();
+	_lists.clear_usage();
+
+	// Iterate runners and mark their strings
+	auto iter = _runners_start;
+	while (iter != nullptr) {
+		iter->object->mark_used(_strings, _lists);
+		iter = iter->next;
+	}
+
+	// Mark our own strings
+	_variables.mark_used(_strings, _lists);
+
+	// run garbage collection
+	_strings.gc();
+	_lists.gc();
+}
+
+void globals_impl::save()
+{
+	for (uint32_t i = 0; i < _num_containers; ++i) {
+		_visit_counts_backup[i] = _visit_counts[i];
+	}
+	_variables.save();
+}
+
+void globals_impl::restore()
+{
+	for (uint32_t i = 0; i < _num_containers; ++i) {
+		_visit_counts[i] = _visit_counts_backup[i];
+	}
+	_variables.restore();
+}
+
+void globals_impl::forget() { _variables.forget(); }
+
+snapshot* globals_impl::create_snapshot() const { return new snapshot_impl(*this); }
+
+size_t globals_impl::snap(unsigned char* data, const snapper& snapper) const
+{
+	unsigned char* ptr = data;
+	inkAssert(_num_containers == _visit_counts.size(), "Should be equal!");
+	inkAssert(
+	    _globals_initialized,
+	    "Only support snapshot of globals with runner! or you don't need a snapshot for this state"
+	);
+	ptr = snap_write(ptr, _turn_cnt, data != nullptr);
+	ptr += _visit_counts.snap(data ? ptr : nullptr, snapper);
+	ptr += _visit_counts_backup.snap(data ? ptr : nullptr, snapper);
+	ptr += _strings.snap(data ? ptr : nullptr, snapper);
+	ptr += _lists.snap(data ? ptr : nullptr, snapper);
+	ptr += _variables.snap(data ? ptr : nullptr, snapper);
+	return ptr - data;
+}
+
+const unsigned char* globals_impl::snap_load(const unsigned char* ptr, const loader& loader)
+{
+	_globals_initialized = true;
+	ptr                  = snap_read(ptr, _turn_cnt);
+	ptr                  = _visit_counts.snap_load(ptr, loader);
+	ptr                  = _visit_counts_backup.snap_load(ptr, loader);
+	inkAssert(_visit_counts.size() == _visit_counts_backup.size(), "Data inconsitency");
+	inkAssert(
+	    _num_containers == _visit_counts.size(),
+	    "errer when loading visit counts, story file dont match snapshot!"
+	);
+	ptr = _strings.snap_load(ptr, loader);
+	ptr = _lists.snap_load(ptr, loader);
+	ptr = _variables.snap_load(ptr, loader);
+	return ptr;
+}
+} // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/globals_impl.h

@@ -0,0 +1,149 @@
+/* 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 "system.h"
+#include "array.h"
+#include "globals.h"
+#include "string_table.h"
+#include "list_table.h"
+#include "list_impl.h"
+#include "stack.h"
+#include "snapshot_impl.h"
+#include "functional.h"
+
+namespace ink::runtime::internal
+{
+class story_impl;
+class runner_impl;
+class snapshot_impl;
+
+// Implementation of the global store
+class globals_impl final
+    : public globals_interface
+    , public snapshot_interface
+{
+	friend snapshot_impl;
+
+public:
+	size_t               snap(unsigned char* data, const snapper&) const;
+	const unsigned char* snap_load(const unsigned char* data, const loader&);
+	// Initializes a new global store from the given story
+	globals_impl(const story_impl*);
+
+	virtual ~globals_impl() {}
+
+	snapshot* create_snapshot() const override;
+
+protected:
+	optional<ink::runtime::value> get_var(hash_t name) const override;
+	bool                          set_var(hash_t name, const ink::runtime::value& val) override;
+	void internal_observe(hash_t name, internal::callback_base* callback) override;
+
+public:
+	// Records a visit to a container
+	/// @param start_cmd iff the visit was initiatet through a MARKER_START_CONTAINER
+	void visit(uint32_t container_id, bool entering_at_start);
+
+	// Checks the number of visits to a container
+	uint32_t visits(uint32_t container_id) const;
+	// Number of current turn (number of passed choices)
+	uint32_t turns() const;
+
+	// Returnn number of turns since container was last visited
+	// \retval -1 if container was never visited before
+	uint32_t turns(uint32_t container_id) const;
+
+	// signal that a turn is habbend (eg. a choice is taken)
+	void turn();
+
+	// registers/unregisters a runner as using this globals object
+	void add_runner(const runner_impl*);
+	void remove_runner(const runner_impl*);
+
+	// sets a global variable
+	void set_variable(hash_t name, const value&);
+
+	// gets a global variable
+	const value* get_variable(hash_t name) const;
+	value*       get_variable(hash_t name);
+
+	// checks if globals are initialized
+	bool are_globals_initialized() const { return _globals_initialized; }
+
+	// initializes globals using a runner
+	void initialize_globals(runner_impl*);
+
+	// gets the allocated string table
+	inline string_table& strings() { return _strings; }
+
+	inline const string_table& strings() const { return _strings; }
+
+	// gets list entries
+	list_table& lists() { return _lists; }
+
+	// run garbage collection
+	void gc();
+
+	// == Save/Restore ==
+	void save();
+	void restore();
+	void forget();
+
+private:
+	// Store the number of containers. This is the length of most of our lists
+	const uint32_t _num_containers;
+
+	uint32_t _turn_cnt = 0;
+
+	// Visit count array
+	struct visit_count {
+		uint32_t visits = 0;
+		int32_t  turns  = -1;
+
+		bool operator==(const visit_count& vc) const
+		{
+			return visits == vc.visits && turns == vc.turns;
+		}
+
+		bool operator!=(const visit_count& vc) const { return ! (*this == vc); }
+	};
+
+	managed_array<visit_count, true, 1> _visit_counts;
+	managed_array<visit_count, true, 1> _visit_counts_backup;
+
+	// Pointer back to owner story.
+	const story_impl* const _owner;
+
+	struct runner_entry {
+		const runner_impl* object;
+		runner_entry*      next = nullptr;
+	};
+
+	// Linked list of runners operating under this globals object.
+	//  Used for garbage collection of the global string table.
+	runner_entry* _runners_start;
+
+	// Allocated string table (shared by all runners using this global store)
+	mutable string_table _strings;
+	mutable list_table   _lists;
+
+	// Implemented as a stack (slow lookup) because it has save/restore functionality.
+	// If I could create an avl tree with save/restore, that'd be great but seems super complex.
+	internal::stack < abs(config::limitGlobalVariables), config::limitGlobalVariables<0> _variables;
+
+	struct Callback {
+		hash_t         name;
+		callback_base* operation;
+	};
+
+	managed_array < Callback,
+	    config::limitGlobalVariableObservers<0, abs(config::limitGlobalVariableObservers)> _callbacks;
+	bool _globals_initialized;
+};
+} // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/header.cpp

@@ -0,0 +1,44 @@
+/* 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.
+ */
+#include "header.h"
+#include "version.h"
+
+namespace ink::internal {
+
+	header header::parse_header(const char *data)
+	{
+		header res;
+		const char* ptr = data;
+		res.endien = *reinterpret_cast<const header::endian_types*>(ptr);
+		ptr += sizeof(header::endian_types);
+
+		using v_t = decltype(header::ink_version_number);
+		using vcpp_t = decltype(header::ink_bin_version_number);
+
+		if (res.endien == header::endian_types::same) {
+			res.ink_version_number =
+				*reinterpret_cast<const v_t*>(ptr);
+			ptr += sizeof(v_t);
+			res.ink_bin_version_number =
+				*reinterpret_cast<const vcpp_t*>(ptr);
+
+		} else if (res.endien == header::endian_types::differ) {
+			res.ink_version_number =
+				swap_bytes(*reinterpret_cast<const v_t*>(ptr));
+			ptr += sizeof(v_t);
+			res.ink_bin_version_number =
+				swap_bytes(*reinterpret_cast<const vcpp_t*>(ptr));
+		} else {
+			inkFail("Failed to parse endian encoding!");
+		}
+
+		if (res.ink_bin_version_number != InkBinVersion) {
+			inkFail("InkCpp-version mismatch: file was compiled with different InkCpp-version!");
+		}
+		return res;
+	}
+}

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

@@ -0,0 +1,106 @@
+/* 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
+{
+namespace runtime
+{
+	namespace internal
+	{
+		class basic_stream;
+		class runner_impl;
+		class string_table;
+		class list_table;
+	} // namespace internal
+
+	/**
+	 * An ink choice that is being presented to the user
+	 *
+	 * Contains all the data about a single choice being faced
+	 * by an ink runner. Of primary concern is the index and the
+	 * text.
+	 *
+	 * @see runner
+	 */
+	class choice
+	{
+	public:
+		/**
+		 * Choice index
+		 *
+		 * Pass this to the runner to choose this choice and
+		 * have it follow its branch.
+		 *
+		 * @returns index of the choice. 0 is the first, etc.
+		 */
+		int index() const { return _index; }
+
+		/**
+		 * Choice text
+		 *
+		 * Text to display to the user for choosing this choice.
+		 *
+		 * @returns choice text as a string
+		 */
+		const char* text() const { return _text; }
+
+		/** @private */
+		choice()
+		    : choice(0)
+		{
+		}
+
+		/** @private */
+		choice(int)
+		    : _tags{nullptr}
+		    , _text{nullptr}
+		    , _index{~0}
+		    , _path{~0u}
+		    , _thread{~0u}
+		{
+		}
+
+		/** does this choice has tags? */
+		bool has_tags() const { return _tags != nullptr; }
+
+		/** number of tags assoziated with this choice
+		 * @see @ref ink::runtime::choice::has_tags() "has_tags()"
+		 */
+		size_t num_tags() const
+		{
+			size_t i = 0;
+			if (has_tags())
+				while (_tags[i] != nullptr) {
+					++i;
+				};
+			return i;
+		}
+
+		/** @copydoc ink::runtime::runner_interface::get_tag() */
+		const char* get_tag(size_t index) const { return _tags[index]; }
+
+	private:
+		friend class internal::runner_impl;
+
+		uint32_t path() const { return _path; }
+
+		choice& setup(
+		    internal::basic_stream&, internal::string_table& strings, internal::list_table& lists,
+		    int index, uint32_t path, thread_t thread, const char* const* tags
+		);
+
+	protected:
+		const char* const* _tags;   ///< @private
+		const char*        _text;   ///< @private
+		int                _index;  ///< @private
+		uint32_t           _path;   ///< @private
+		thread_t           _thread; ///< @private
+	};
+} // namespace runtime
+} // namespace ink