inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp/stack.h

@@ -0,0 +1,243 @@
+/* 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"
+#include "collections/restorable.h"
+#include "array.h"
+#include "snapshot_impl.h"
+
+namespace ink
+{
+namespace runtime
+{
+	namespace internal
+	{
+		class string_table;
+
+		struct entry {
+			hash_t name = 0;
+			value  data;
+		};
+
+		enum class frame_type : uint32_t {
+			function,
+			tunnel,
+			thread
+		};
+
+		class basic_stack : protected restorable<entry>
+		{
+		protected:
+			basic_stack(entry* data, size_t size);
+
+			// base class
+			using base = restorable<entry>;
+
+		public:
+			virtual ~basic_stack() = default;
+
+			// Sets existing value, or creates a new one at this callstack entry
+			void set(hash_t name, const value& val);
+
+			// Gets an existing value, or nullptr
+			const value* get(hash_t name) const;
+			value*       get(hash_t name);
+			value*       get_from_frame(int ci, hash_t name);
+
+			// pushes a new frame onto the stack
+			// @param eval if evaluation mode was active
+			template<frame_type>
+			void push_frame(offset_t return_to, bool eval);
+
+			// Pops a frame (and all temporary variables) from the callstack.
+			offset_t pop_frame(frame_type* type, bool& eval);
+
+			// Returns true if there are any frames on the stack
+			bool has_frame(frame_type* type = nullptr) const;
+
+			// Clears the entire stack
+			void clear();
+
+			// Garbage collection
+			void mark_used(string_table&, list_table&) const;
+
+			// == Threading ==
+
+			// Forks a new thread from the current callstack and returns that thread's unique id
+			thread_t fork_thread();
+
+			// Mark a thread as "done". It's callstack is still preserved until collapse_to_thread is
+			// called.
+			void complete_thread(thread_t thread);
+
+			// Collapses the callstack to the state of a single thread
+			void collapse_to_thread(thread_t thread);
+
+			// == Save/Restore ==
+			void save();
+			void restore();
+			void forget();
+
+			// replace all pointer in current frame with values from _stack
+			void fetch_values(basic_stack& _stack);
+			// push all values to other _stack
+			void push_values(basic_stack& _stack);
+
+			// snapshot interface
+			size_t               snap(unsigned char* data, const snapper&) const;
+			const unsigned char* snap_load(const unsigned char* data, const loader&);
+
+		private:
+			entry&       add(hash_t name, const value& val);
+			const entry* pop();
+
+			entry* do_thread_jump_pop(const iterator& jump);
+
+			// thread ids
+			thread_t _next_thread        = 0;
+			thread_t _backup_next_thread = 0;
+
+			static const hash_t NulledHashId = ~0;
+		};
+
+		template<>
+		void basic_stack::push_frame<frame_type::function>(offset_t return_to, bool eval);
+		template<>
+		void basic_stack::push_frame<frame_type::tunnel>(offset_t return_to, bool eval);
+		template<>
+		void basic_stack::push_frame<frame_type::thread>(offset_t return_to, bool eval);
+
+		/**
+		 * @brief stack for call history and temporary variables
+		 * @tparam N initial capacity of stack
+		 * @tparam Dynamic weather or not expand if stack is full
+		 */
+		template<size_t N, bool Dynamic = false>
+		class stack : public basic_stack
+		{
+		public:
+			stack()
+			    : basic_stack(&_stack[0], N)
+			{
+			}
+
+		private:
+			// stack
+			entry _stack[N];
+		};
+
+		template<size_t N>
+		class stack<N, true> : public basic_stack
+		{
+		public:
+			stack()
+			    : basic_stack(nullptr, 0)
+			{
+			}
+
+		protected:
+			virtual void overflow(entry*& buffer, size_t& size) override
+			{
+				if (! buffer) {
+					buffer = _stack.data();
+					size   = _stack.capacity();
+				} else {
+					_stack.extend();
+					buffer = _stack.data();
+					size   = _stack.capacity();
+				}
+			}
+
+		private:
+			managed_array<entry, true, N> _stack;
+		};
+
+		class basic_eval_stack : protected restorable<value>
+		{
+		protected:
+			basic_eval_stack(value* data, size_t size);
+
+			using base = restorable<value>;
+
+		public:
+			virtual ~basic_eval_stack() = default;
+
+			// Push value onto the stack
+			void push(const value&);
+
+			// Pop a value off the stack
+			value pop();
+
+			// Gets the top value without popping
+			const value& top() const;
+
+			// Gets the top non null value without popping
+			const value& top_value() const;
+
+			// Check if the stack is empty
+			bool is_empty() const;
+
+			// Clear stack
+			void clear();
+
+			/** Mark used strings and lists for garbage collection */
+			void mark_used(string_table&, list_table&) const;
+
+			// == Save/Restore ==
+			void save();
+			void restore();
+			void forget();
+
+			// snapshot interface
+			size_t snap(unsigned char* data, const snapper& snapper) const
+			{
+				return base::snap(data, snapper);
+			}
+
+			const unsigned char* snap_load(const unsigned char* data, const loader& loader)
+			{
+				return base::snap_load(data, loader);
+			}
+		};
+
+		template<size_t N, bool dynamic = false>
+		class eval_stack : public basic_eval_stack
+		{
+		public:
+			eval_stack()
+			    : basic_eval_stack(_stack, N)
+			{
+			}
+
+		private:
+			value _stack[N];
+		};
+
+		template<size_t N>
+		class eval_stack<N, true> : public basic_eval_stack
+		{
+		public:
+			eval_stack()
+			    : basic_eval_stack(nullptr, 0)
+			{
+			}
+
+		protected:
+			virtual void overflow(value*& buffer, size_t& size) override
+			{
+				_stack.extend();
+				buffer = _stack.data();
+				size   = _stack.capacity();
+			}
+
+		private:
+			managed_array<value, true, N> _stack;
+		};
+	} // namespace internal
+} // namespace runtime
+} // namespace ink

data/ext/inkcpp_rb/inkcpp/inkcpp/story_impl.cpp

@@ -0,0 +1,361 @@
+/* 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 "story_impl.h"
+#include "platform.h"
+#include "runner_impl.h"
+#include "globals_impl.h"
+#include "snapshot.h"
+#include "snapshot_impl.h"
+#include "snapshot_interface.h"
+#include "version.h"
+
+namespace ink::runtime
+{
+#ifdef INK_ENABLE_STL
+story* story::from_file(const char* filename) { return new internal::story_impl(filename); }
+#endif
+
+story* story::from_binary(unsigned char* data, size_t length, bool freeOnDestroy)
+{
+	return new internal::story_impl(data, length, freeOnDestroy);
+}
+} // namespace ink::runtime
+
+namespace ink::runtime::internal
+{
+
+#ifdef INK_ENABLE_STL
+unsigned char* read_file_into_memory(const char* filename, size_t* read)
+{
+	using namespace std;
+
+	ifstream ifs(filename, ios::binary | ios::ate);
+
+	if (! ifs.is_open()) {
+		throw ink_exception("Failed to open file: " + std::string(filename));
+	}
+
+	ifstream::pos_type pos    = ifs.tellg();
+	size_t             length = ( size_t ) pos;
+	unsigned char*     data   = new unsigned char[length];
+	ifs.seekg(0, ios::beg);
+	ifs.read(( char* ) data, length);
+	ifs.close();
+
+	*read = ( size_t ) length;
+	return data;
+}
+
+story_impl::story_impl(const char* filename)
+    : _file(nullptr)
+    , _length(0)
+    , _string_table(nullptr)
+    , _instruction_data(nullptr)
+    , _managed(true)
+{
+	// Load file into memory
+	_file = read_file_into_memory(filename, &_length);
+
+	// Find all the right data sections
+	setup_pointers();
+
+	// create story block
+	_block             = new internal::ref_block();
+	_block->references = 1;
+}
+#endif
+
+story_impl::story_impl(unsigned char* binary, size_t len, bool manage /*= true*/)
+    : _file(binary)
+    , _length(len)
+    , _managed(manage)
+{
+	// Setup data section pointers
+	setup_pointers();
+
+	// create story block
+	_block             = new internal::ref_block();
+	_block->references = 1;
+}
+
+story_impl::~story_impl()
+{
+	// delete file memory if we're responsible for it
+	if (_file != nullptr && _managed)
+		delete[] _file;
+
+	// clear pointers
+	_file             = nullptr;
+	_instruction_data = nullptr;
+	_string_table     = nullptr;
+
+	// clear out our reference block
+	_block->valid = false;
+	internal::ref_block::remove_reference(_block);
+	_block = nullptr;
+}
+
+const char* story_impl::string(uint32_t index) const { return _string_table + index; }
+
+bool story_impl::iterate_containers(
+    const uint32_t*& iterator, container_t& index, ip_t& offset, bool reverse
+) const
+{
+	if (iterator == nullptr) {
+		// Empty check
+		if (_container_list_size == 0) {
+			return false;
+		}
+
+		// Start
+		iterator = reverse ? _container_list + (_container_list_size - 1) * 2 : _container_list;
+	} else {
+		// Range check
+		inkAssert(
+		    iterator >= _container_list && iterator <= _container_list + _container_list_size * 2,
+		    "Container fail"
+		);
+
+		// Advance
+		iterator += reverse ? -2 : 2;
+
+		// End?
+		if (iterator >= _container_list + _container_list_size * 2 || iterator < _container_list) {
+			iterator = nullptr;
+			index    = 0;
+			offset   = nullptr;
+			return false;
+		}
+	}
+
+	// Get metadata
+	index  = *(iterator + 1);
+	offset = *iterator + instructions();
+	return true;
+}
+
+bool story_impl::get_container_id(ip_t offset, container_t& container_id) const
+{
+	const uint32_t* iter        = nullptr;
+	ip_t            iter_offset = nullptr;
+	while (iterate_containers(iter, container_id, iter_offset)) {
+		if (iter_offset == offset)
+			return true;
+	}
+
+	return false;
+}
+
+CommandFlag story_impl::container_flag(ip_t offset) const
+{
+	inkAssert(
+	    (static_cast<Command>(offset[0]) == Command::START_CONTAINER_MARKER
+	     || static_cast<Command>(offset[0]) == Command::END_CONTAINER_MARKER),
+	    "Tried to fetch container flag from non container command!"
+	);
+	return static_cast<CommandFlag>(offset[1]);
+}
+
+CommandFlag story_impl::container_flag(container_t id) const
+{
+	const uint32_t* iter = nullptr;
+	ip_t            offset;
+	container_t     c_id;
+	while (iterate_containers(iter, c_id, offset)) {
+		if (c_id == id) {
+			inkAssert(
+			    static_cast<Command>(offset[0]) == Command::START_CONTAINER_MARKER,
+			    "Container list pointer is invalid!"
+			);
+			return static_cast<CommandFlag>(offset[1]);
+		}
+	}
+	inkFail("Container not found -> can't fetch flag");
+	return CommandFlag::NO_FLAGS;
+}
+
+ip_t story_impl::find_offset_for(hash_t path) const
+{
+	hash_t* iter = _container_hash_start;
+
+	while (iter != _container_hash_end) {
+		if (*iter == path) {
+			return instructions() + *( offset_t* ) (iter + 1);
+		}
+
+		iter += 2;
+	}
+
+	return nullptr;
+}
+
+globals story_impl::new_globals()
+{
+	// create the new globals store
+	return globals(new globals_impl(this), _block);
+}
+
+globals story_impl::new_globals_from_snapshot(const snapshot& data)
+{
+	const snapshot_impl& snapshot = reinterpret_cast<const snapshot_impl&>(data);
+	auto*                globs    = new globals_impl(this);
+	auto                 end      = globs->snap_load(
+	                         snapshot.get_globals_snap(),
+	                         snapshot_interface::loader{
+          snapshot.strings(),
+          _string_table,
+      }
+	                     );
+	inkAssert(end == snapshot.get_runner_snap(0), "not all data were used for global reconstruction");
+	return globals(globs, _block);
+}
+
+runner story_impl::new_runner(globals store)
+{
+	if (store == nullptr)
+		store = new_globals();
+	return runner(new runner_impl(this, store), _block);
+}
+
+runner story_impl::new_runner_from_snapshot(const snapshot& data, globals store, unsigned idx)
+{
+	const snapshot_impl& snapshot = reinterpret_cast<const snapshot_impl&>(data);
+	if (store == nullptr)
+		store = new_globals_from_snapshot(snapshot);
+	auto* run    = new runner_impl(this, store);
+	auto  loader = snapshot_interface::loader{
+      snapshot.strings(),
+      _string_table,
+  };
+	// snapshot id is inverso of creation time, but creation time is the more intouitve numbering to
+	// use
+	idx      = (data.num_runners() - idx - 1);
+	auto end = run->snap_load(snapshot.get_runner_snap(idx), loader);
+	inkAssert(
+	    (idx + 1 < snapshot.num_runners() && end == snapshot.get_runner_snap(idx + 1))
+	        || end == snapshot.get_data() + snapshot.get_data_len(),
+	    "not all data were used for runner reconstruction"
+	);
+	return runner(run, _block);
+}
+
+void story_impl::setup_pointers()
+{
+	using header = ink::internal::header;
+	_header      = header::parse_header(reinterpret_cast<char*>(_file));
+
+	// String table is after the header
+	_string_table = ( char* ) _file + header::Size;
+
+	// Pass over strings
+	const char* ptr = _string_table;
+	if (*ptr == 0) // SPECIAL: No strings
+	{
+		ptr++;
+	} else
+		while (true) {
+			// Read until null terminator
+			while (*ptr != 0)
+				ptr++;
+
+			// Check next character
+			ptr++;
+
+			// Second null. Strings are done.
+			if (*ptr == 0) {
+				ptr++;
+				break;
+			}
+		}
+
+	// check if lists are defined
+	_list_meta = ptr;
+	if (list_flag flag = _header.read_list_flag(ptr); flag != null_flag) {
+		// skip list definitions
+		auto list_id = flag.list_id;
+		while (*ptr != 0) {
+			++ptr;
+		}
+		++ptr; // skip list name
+		do {
+			if (flag.list_id != list_id) {
+				list_id = flag.list_id;
+				while (*ptr != 0) {
+					++ptr;
+				}
+				++ptr; // skip list name
+			}
+			while (*ptr != 0) {
+				++ptr;
+			}
+			++ptr; // skip flag name
+		} while ((flag = _header.read_list_flag(ptr)) != null_flag);
+
+		_lists = reinterpret_cast<const list_flag*>(ptr);
+		// skip predefined lists
+		while (_header.read_list_flag(ptr) != null_flag) {
+			while (_header.read_list_flag(ptr) != null_flag)
+				;
+		}
+	} else {
+		_list_meta = nullptr;
+		_lists     = nullptr;
+	}
+	inkAssert(
+	    _header.ink_bin_version_number == ink::InkBinVersion,
+	    "invalid InkBinVerison! currently: %i you used %i", ink::InkBinVersion,
+	    _header.ink_bin_version_number
+	);
+	inkAssert(
+	    _header.endien == header::endian_types::same, "different endien support not yet implemented"
+	);
+
+
+	_num_containers = *( uint32_t* ) (ptr);
+	ptr += sizeof(uint32_t);
+
+	// Pass over the container data
+	_container_list_size = 0;
+	_container_list      = ( uint32_t* ) (ptr);
+	while (true) {
+		uint32_t val = *( uint32_t* ) ptr;
+		if (val == ~0) {
+			ptr += sizeof(uint32_t);
+			break;
+		} else {
+			ptr += sizeof(uint32_t) * 2;
+			_container_list_size++;
+		}
+	}
+
+	// Next is the container hash map
+	_container_hash_start = ( hash_t* ) (ptr);
+	while (true) {
+		uint32_t val = *( uint32_t* ) ptr;
+		if (val == ~0) {
+			_container_hash_end = ( hash_t* ) (ptr);
+			ptr += sizeof(uint32_t);
+			break;
+		}
+
+		ptr += sizeof(uint32_t) * 2;
+	}
+
+	// After strings comes instruction data
+	_instruction_data = ( ip_t ) ptr;
+
+	// Debugging info
+	/*{
+	  const uint32_t* iter = nullptr;
+	  container_t index; ip_t offset;
+	  while (this->iterate_containers(iter, index, offset))
+	  {
+	    std::clog << "Container #" << index << ": " << (int)offset << std::endl;
+	  }
+	}*/
+}
+} // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/story_impl.h

@@ -0,0 +1,92 @@
+/* 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>
+#include <config.h>
+#include "command.h"
+#include "types.h"
+#include "story.h"
+#include "header.h"
+#include "list_table.h"
+
+namespace ink::runtime::internal
+{
+	// Ink story. Constant once constructed. Can be shared safely between multiple runner instances
+	class story_impl : public story
+	{
+	public:
+
+#ifdef INK_ENABLE_STL
+		story_impl(const char* filename);
+#endif
+		// Create story from allocated binary data in memory. If manage is true, this class will delete
+		//  the pointers on destruction
+		story_impl(unsigned char* binary, size_t len, bool manage = true);
+		virtual ~story_impl();
+
+		const char* string(uint32_t index) const;
+		inline const ip_t instructions() const { return _instruction_data; }
+		inline const ip_t end() const { return _file + _length; }
+
+		inline uint32_t num_containers() const { return _num_containers; }
+
+		const list_flag* lists() const { return _lists; }
+		const char* list_meta() const {
+			return _list_meta;
+		}
+
+		bool iterate_containers(const uint32_t*& iterator, container_t& index, ip_t& offset, bool reverse = false) const;
+		bool get_container_id(ip_t offset, container_t& container_id) const;
+		/// Get container flag from container offset (either start or end)
+		CommandFlag container_flag(ip_t offset) const;
+		CommandFlag container_flag(container_t id) const;
+
+		ip_t find_offset_for(hash_t path) const;
+
+		// Creates a new global store for use with runners executing this story
+		virtual globals new_globals() override;
+		virtual globals new_globals_from_snapshot(const snapshot&) override;
+		virtual runner new_runner(globals store = nullptr) override;
+		virtual runner new_runner_from_snapshot(const snapshot&, globals store = nullptr, unsigned idx = 0) override;
+
+		const ink::internal::header& get_header() const { return _header; }
+	private:
+		void setup_pointers();
+
+	private:
+		// file information
+		unsigned char* _file;
+		size_t _length;
+
+		ink::internal::header  _header;
+
+		// string table
+		const char* _string_table;
+
+		const char* _list_meta;
+		const list_flag* _lists;
+
+		// container info
+		uint32_t* _container_list;
+		uint32_t _container_list_size;
+		uint32_t _num_containers;
+
+		// container hashes
+		hash_t* _container_hash_start;
+		hash_t* _container_hash_end;
+
+		// instruction info
+		ip_t _instruction_data;
+
+		// story block used to creat various weak pointers
+		ref_block* _block;
+
+		// whether we need to delete our binary data after we destruct
+		bool _managed;
+	};
+}