inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp/story_ptr.cpp

@@ -0,0 +1,75 @@
+/* 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_ptr.h"
+
+namespace ink::runtime::internal
+{
+	void ref_block::remove_reference(ref_block*& block)
+	{
+		if (block == nullptr)
+			return;
+
+		// If we only have one references left
+		if (block->references <= 1)
+		{
+			// delete the block
+			delete block;
+			block = nullptr;
+			return;
+		}
+
+		// Otherwise, derecement references
+		block->references--;
+	}
+
+	story_ptr_base::story_ptr_base(internal::ref_block* story)
+		: _story_block(story)
+	{
+		_instance_block = new ref_block();
+	}
+
+	story_ptr_base::story_ptr_base(internal::ref_block* story, internal::ref_block* instance)
+		: _story_block(story), _instance_block(instance)
+	{
+	}
+
+	story_ptr_base::story_ptr_base(const story_ptr_base& other)
+		: _story_block(other._story_block)
+		, _instance_block(other._instance_block)
+	{
+	}
+
+	void story_ptr_base::set(const story_ptr_base& other)
+	{
+		_story_block = other._story_block;
+		_instance_block = other._instance_block;
+	}
+
+	void story_ptr_base::add_reference()
+	{
+		// If our block isn't valid, don't bother
+		if (_story_block == nullptr || _instance_block == nullptr || !_story_block->valid || !_instance_block->valid)
+		{
+			_story_block = _instance_block = nullptr;
+			return;
+		}
+
+		_instance_block->references++;
+		_story_block->references++;
+	}
+
+	bool story_ptr_base::remove_reference()
+	{
+		ref_block::remove_reference(_story_block);
+		ref_block::remove_reference(_instance_block);
+
+		bool is_destroyed = _instance_block == nullptr;
+
+		_instance_block = _story_block = nullptr;
+		return is_destroyed;
+	}
+  } // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/string_operations.cpp

@@ -0,0 +1,125 @@
+/* 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.
+ */
+/// implementation for commands on strings
+/// string_cast is a class which convert an value to a string.
+/// if the value is already a string it dose nothing (just serve the pointer),
+/// else it convert the value to a string and store it, in it internal storage.
+
+#include "stack.h"
+#include "value.h"
+#include "string_utils.h"
+#include "operations.h"
+#include "string_table.h"
+
+namespace ink::runtime::internal {
+	namespace casting {
+		/**
+		 * @brief Wrapper to cast values to string.
+		 * string representation is stored inside string_cast.
+		 */
+		class string_cast {
+		public:
+			string_cast(const value& val);
+			const char* get() const { return _str; }
+		private:
+			const value& _val;
+			const char* _str;
+			char _data[512]; //TODO define central
+		};
+
+		// constructor for string_cast class
+		string_cast::string_cast(const value& val) : _val{val}, _str{nullptr} {
+			if (val.type() == value_type::string) {
+				// reference string if value is already a string
+				_str = val.get<value_type::string>();
+			} else {
+				// convert else
+				_str = _data;
+				toStr(_data, 512, val);
+			}
+		}
+	}
+	void operation<Command::ADD, value_type::string, void>::operator()(basic_eval_stack& stack, value* vals) {
+		// convert values to strings
+		casting::string_cast lh(vals[0]);
+		casting::string_cast rh (vals[1]);
+
+		// create new string with needed size
+		char* str = _string_table.create(c_str_len(lh.get()) + c_str_len(rh.get()) + 1);
+
+		// copy to new string
+		char* dst = str;
+		for(const char* src = lh.get(); *src; ++src) { *dst++ = *src; }
+		for(const char* src = rh.get(); *src; ++src) { *dst++ = *src; }
+		*dst = 0;
+
+		stack.push(value{}.set<value_type::string>(str));
+	}
+
+	void operation<Command::IS_EQUAL, value_type::string, void>::operator()(basic_eval_stack& stack, value* vals) {
+		// convert values to string
+		casting::string_cast lh (vals[0]);
+		casting::string_cast rh(vals[1]);
+
+		// compare strings char wise
+		const char* li = lh.get();
+		const char* ri = rh.get();
+		while(*li && *ri && *li == *ri) { ++li; ++ri; }
+
+		stack.push(value{}.set<value_type::boolean>(*li == *ri));
+	}
+
+	void operation<Command::NOT_EQUAL, value_type::string, void>::operator()(basic_eval_stack& stack, value* vals) {
+		// convert values to string
+		casting::string_cast lh (vals[0]);
+		casting::string_cast rh(vals[1]);
+
+		// compare strings char wise
+		const char* li = lh.get();
+		const char* ri = rh.get();
+		while(*li && *ri && *li == *ri){ ++li; ++ri; }
+
+		stack.push(value{}.set<value_type::boolean>(*li != *ri));
+	}
+
+	bool has(const char* lh, const char* rh) {
+		while(isspace(*lh)) { ++lh; }
+		while(isspace(*rh)) { ++rh; }
+		if(!*lh && !*rh) { return true; }
+		for(const char* li = lh; *li; ++li) {
+			const char* ri = rh;
+			bool match = true;
+			int offset = 0;
+			for(int i = 0; ri[i] != 0; ++i) {
+				if(li[i + offset] != ri[i]) {
+					if(isspace(ri[i])) {
+						--offset;
+						continue;
+					}
+					match = false; break;
+				}
+			}
+			if(match) { return true; }
+		}
+		return false;
+	}
+
+	void operation<Command::HAS, value_type::string, void>::operator()(basic_eval_stack& stack, value* vals)
+	{
+		casting::string_cast lh(vals[0]);
+		casting::string_cast rh(vals[1]);
+		stack.push(value{}.set<value_type::boolean>(has(lh.get(), rh.get())));
+	}
+
+	void operation<Command::HASNT, value_type::string, void>::operator()(basic_eval_stack& stack, value* vals)
+	{
+		casting::string_cast lh(vals[0]);
+		casting::string_cast rh(vals[1]);
+		stack.push(value{}.set<value_type::boolean>(!has(lh.get(), rh.get())));
+	}
+
+}

data/ext/inkcpp_rb/inkcpp/inkcpp/string_operations.h

@@ -0,0 +1,67 @@
+/* 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 operations allowed on strings.
+
+namespace ink::runtime::internal {
+
+	namespace casting {
+		// define valid castings
+		// when operate on float and string, the result is a string
+		template<>
+		struct cast<value_type::float32, value_type::string>
+		{ static constexpr value_type value = value_type::string; };
+		template<>
+		struct cast<value_type::int32, value_type::string>
+		{ static constexpr value_type value = value_type::string; };
+		template<>
+		struct cast<value_type::uint32, value_type::string>
+		{ static constexpr value_type value = value_type::string; };
+		template<>
+		struct cast<value_type::string, value_type::newline>
+		{ static constexpr value_type value = value_type::string; };
+	}
+
+	// operation declaration add
+	template<>
+	class operation<Command::ADD, value_type::string, void> : public operation_base<string_table> {
+	public:
+		using operation_base::operation_base;
+		void operator()(basic_eval_stack& stack, value* vals);
+	};
+
+	// operation declaration equality
+	template<>
+	class operation<Command::IS_EQUAL, value_type::string, void> : public operation_base<void> {
+	public:
+		using operation_base::operation_base;
+		void operator()(basic_eval_stack& stack, value* vals);
+	};
+
+	template<>
+	class operation<Command::NOT_EQUAL, value_type::string, void> : public operation_base<void> {
+	public:
+		using operation_base::operation_base;
+		void operator()(basic_eval_stack& stack, value* vals);
+	};
+
+	template<>
+	class operation<Command::HAS, value_type::string, void> : public operation_base<void> {
+	public:
+		using operation_base::operation_base;
+		void operator()(basic_eval_stack& stack, value* vals);
+	};
+
+	template<>
+	class operation<Command::HASNT, value_type::string, void> : public operation_base<void> {
+	public:
+		using operation_base::operation_base;
+		void operator()(basic_eval_stack& stack, value* vals);
+	};
+
+}

data/ext/inkcpp_rb/inkcpp/inkcpp/string_table.cpp

@@ -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.
+ */
+#include "string_table.h"
+
+namespace ink::runtime::internal
+{
+string_table::~string_table()
+{
+	// Delete all allocated strings
+	for (auto iter = _table.begin(); iter != _table.end(); ++iter)
+		delete[] iter.key();
+	_table.clear();
+}
+
+char* string_table::duplicate(const char* str)
+{
+	int len = 0;
+	for (const char* i = str; *i != 0; ++i) {
+		++len;
+	}
+	char* res = create(len + 1);
+	char* out = res;
+	for (const char* i = str; *i != 0; ++i, ++out) {
+		*out = *i;
+	}
+	*out = 0;
+	return res;
+}
+
+char* string_table::create(size_t length)
+{
+	// allocate the string
+	/// @todo use continuous memory
+	char* data = new char[length];
+	if (data == nullptr)
+		return nullptr;
+
+	// Add to the tree
+	bool success = _table.insert(data, true); // TODO: Should it start as used?
+	inkAssert(success, "Duplicate string pointer in the string_table. How is that possible?");
+	if (! success) {
+		delete[] data;
+		return nullptr;
+	}
+
+	// Return allocated string
+	return data;
+}
+
+void string_table::clear_usage()
+{
+	// Clear usages
+	for (auto iter = _table.begin(); iter != _table.end(); ++iter)
+		iter.val() = false;
+}
+
+void string_table::mark_used(const char* string)
+{
+	auto iter = _table.find(string);
+	if (iter == _table.end())
+		return; // assert??
+
+	// set used flag
+	*iter = true;
+}
+
+void string_table::gc()
+{
+	// begin at the start
+	auto iter = _table.begin();
+
+	const char* last = nullptr;
+	while (iter != _table.end()) {
+		// If the string is not used
+		if (! *iter) {
+			// Delete it
+			delete[] iter.key();
+			_table.erase(iter);
+
+			// Re-establish iterator at last position
+			// TODO: BAD. We need inline delete that doesn't invalidate pointers
+			if (last == nullptr)
+				iter = _table.begin();
+			else {
+				iter = _table.find(last);
+				iter++;
+			}
+
+			continue;
+		}
+
+		// Next
+		last = iter.key();
+		iter++;
+	}
+}
+
+size_t string_table::snap(unsigned char* data, const snapper&) const
+{
+	unsigned char* ptr          = data;
+	bool           should_write = data != nullptr;
+	for (size_t i = 0; i < _table.size(); ++i) {
+		for (auto itr = _table.begin(); itr != _table.end(); ++itr) {
+			if (itr.temp_identifier() == i) {
+				size_t length = strlen(itr.key()) + 1;
+				if (length == 1) {
+					ptr = snap_write(ptr, EMPTY_STRING, 2, should_write);
+				} else {
+					ptr = snap_write(ptr, itr.key(), length, should_write);
+				}
+				break;
+			}
+		}
+	}
+	ptr = snap_write(ptr, "\0", 1, should_write);
+	return ptr - data;
+}
+
+const unsigned char* string_table::snap_load(const unsigned char* data, const loader& loader)
+{
+	auto* ptr = data;
+	int   i   = 0;
+	while (*ptr) {
+		size_t len = 0;
+		for (; ptr[len]; ++len)
+			;
+		++len;
+		auto str                   = create(len);
+		loader.string_table.push() = str;
+		ptr                        = snap_read(ptr, str, len);
+		if (len == 2 && str[0] == EMPTY_STRING[0]) {
+			str[0] = 0;
+		}
+		mark_used(str);
+	}
+	return ptr + 1;
+}
+
+size_t string_table::get_id(const char* string) const
+{
+	auto iter = _table.find(string);
+	inkAssert(iter != _table.end(), "Try to fetch not contained string!");
+	return iter.temp_identifier();
+}
+} // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/string_table.h

@@ -0,0 +1,47 @@
+/* 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 "avl_array.h"
+#include "system.h"
+#include "snapshot_impl.h"
+
+namespace ink::runtime::internal
+{
+	// hash tree sorted by string pointers
+	class string_table final : public snapshot_interface
+	{
+	public:
+		virtual ~string_table();
+
+		// Create a dynmaic string of a particular length
+		char* create(size_t length);
+		char* duplicate(const char* str);
+
+		// zeroes all usage values
+		void clear_usage();
+
+		// mark a string as used
+		void mark_used(const char* string);
+
+
+		// snapshot interface implementation
+		size_t snap(unsigned char* data, const snapper&) const;
+		const unsigned char* snap_load(const unsigned char* data, const loader&);
+
+		// get position of string when iterate through data
+		// used to enable storing a string table references
+		size_t get_id(const char* string) const;
+
+		// deletes all unused strings
+		void gc();
+
+	private:
+		avl_array<const char*, bool, ink::size_t, 100> _table;
+	  static constexpr const char*                   EMPTY_STRING = "\x03";
+  };
+}

data/ext/inkcpp_rb/inkcpp/inkcpp/string_utils.h

@@ -0,0 +1,207 @@
+/* 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 "traits.h"
+#include "value.h"
+
+#include <cstdio>
+
+#ifndef EINVAL
+#	define EINVAL -1
+#endif
+
+namespace ink::runtime::internal
+{
+// error behavior from:
+// https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/itoa-s-itow-s?view=msvc-160
+inline int toStr(char* buffer, size_t size, uint32_t value)
+{
+#ifdef WIN32
+	return _itoa_s(value, buffer, size, 10);
+#else
+	if (buffer == nullptr || size < 1) {
+		return EINVAL;
+	}
+	int res = snprintf(buffer, size, "%d", value);
+	if (res > 0 && res < size) {
+		return 0;
+	}
+	return EINVAL;
+#endif
+}
+
+// error behavior from:
+// https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/itoa-s-itow-s?view=msvc-160
+inline int toStr(char* buffer, size_t size, int32_t value)
+{
+#ifdef WIN32
+	return _itoa_s(value, buffer, size, 10);
+#else
+	if (buffer == nullptr || size < 1) {
+		return EINVAL;
+	}
+	int res = snprintf(buffer, size, "%d", value);
+	if (res > 0 && res < size) {
+		return 0;
+	}
+	return EINVAL;
+#endif
+}
+
+// error behavior from:
+// https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/gcvt-s?view=msvc-160
+inline int toStr(char* buffer, size_t size, float value)
+{
+#ifdef WIN32
+	int digits = 7;
+	for (float f = value; f > 1.f; f /= 10.f) {
+		++digits;
+	}
+	int res = _gcvt_s(buffer, size, value, digits); // number of significant digits
+	return res;
+#else
+	if (buffer == nullptr || size < 1) {
+		return EINVAL;
+	}
+	int res = snprintf(buffer, size, "%.7f", value);
+	if (res < 0 || res >= size) {
+		return EINVAL;
+	}
+	// trunc cat zeros B007
+	char* itr = buffer + res - 1;
+	while (*itr == '0') {
+		*itr-- = 0;
+		--res;
+	}
+	if (*itr == '.') {
+		*itr-- = 0;
+		--res;
+	}
+	return 0;
+#endif
+}
+
+inline int toStr(char* buffer, size_t size, const char* c)
+{
+	char*  ptr = buffer;
+	size_t i   = 0;
+	while (*c && i < size) {
+		*ptr++ = *c;
+		++i;
+	}
+	if (i >= size) {
+		return EINVAL;
+	}
+	*ptr = 0;
+	return 0;
+}
+
+inline int toStr(char* buffer, size_t size, const value& v)
+{
+	switch (v.type()) {
+		case value_type::int32: return toStr(buffer, size, v.get<value_type::int32>());
+		case value_type::uint32: return toStr(buffer, size, v.get<value_type::uint32>());
+		case value_type::float32: return toStr(buffer, size, v.get<value_type::float32>());
+		case value_type::newline: return toStr(buffer, size, "\n");
+		default: inkFail("only support toStr for numeric types"); return -1;
+	}
+}
+
+// return a upper bound for the string representation of the number
+inline constexpr size_t decimal_digits(uint32_t number)
+{
+	size_t length = 1;
+	while (number /= 10) {
+		++length;
+	}
+	return length;
+}
+
+inline constexpr size_t decimal_digits(int32_t number)
+{
+	size_t length = number < 0 ? 2 : 1;
+	while (number /= 10) {
+		++length;
+	}
+	return length;
+}
+
+inline constexpr size_t decimal_digits(float number)
+{
+	return decimal_digits(static_cast<int32_t>(number)) + 8;
+}
+
+inline constexpr size_t value_length(const value& v)
+{
+	switch (v.type()) {
+		case value_type::int32: return decimal_digits(v.get<value_type::int32>());
+		case value_type::uint32: return decimal_digits(v.get<value_type::uint32>());
+		case value_type::float32: return decimal_digits(v.get<value_type::float32>());
+		case value_type::string: return c_str_len(v.get<value_type::string>());
+		case value_type::newline: return 1;
+		default: inkFail("Can't determine length of this value type"); return -1;
+	}
+}
+
+inline constexpr bool str_equal(const char* lh, const char* rh)
+{
+	while (*lh && *rh && *lh == *rh) {
+		++lh;
+		++rh;
+	}
+	return *lh == *rh;
+}
+
+inline constexpr bool str_equal_len(const char* lh, const char* rh, size_t len)
+{
+	for (size_t i = 0; i < len; ++i) {
+		if (! (*rh && *lh && *lh == *rh)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+inline constexpr const char* str_find(const char* str, char c)
+{
+	while (*str && *str != c) {
+		++str;
+	}
+	if (*str == c) {
+		return str;
+	}
+	return nullptr;
+}
+
+/** removes leading & tailing spaces as wide spaces
+ * @param begin iterator of string
+ * @param end iterator of string
+ * @return new end iterator
+ */
+template<bool LEADING_SPACES, bool TAILING_SPACES, typename ITR>
+inline constexpr ITR clean_string(ITR begin, ITR end)
+{
+	auto dst = begin;
+	for (auto src = begin; src != end; ++src) {
+		if (dst == begin) {
+			if (LEADING_SPACES && isspace(src[0])) {
+				continue;
+			}
+		} else if (src[-1] == '\n' && isspace(src[0])) {
+			continue;
+		} else if ((isspace(src[0]) && src[0] != '\n') && ((src + 1 == end && TAILING_SPACES) || ((src + 1 != end) && isspace(src[1])))) {
+			continue;
+		} else if (src[0] == '\n' && dst != begin && dst[-1] == '\n') {
+			continue;
+		}
+		*dst++ = *src;
+	}
+	return dst;
+}
+} // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/system.cpp

@@ -0,0 +1,39 @@
+/* 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 "system.h"
+
+#ifndef INK_ENABLE_UNREAL
+
+namespace ink
+{
+#define A 54059 /* a prime */
+#define B 76963 /* another prime */
+#define C 86969 /* yet another prime */
+#define FIRSTH 37 /* also prime */
+
+	hash_t hash_string(const char* string)
+	{
+		hash_t h = FIRSTH;
+		while (*string) {
+			h = (h * A) ^ (string[0] * B);
+			string++;
+		}
+		return h; // or return h % C;
+	}
+
+  namespace internal
+  {
+	  void zero_memory(void* buffer, size_t length)
+	  {
+		  char* buf = static_cast<char*>(buffer);
+		  for (size_t i = 0; i < length; i++)
+			  *(buf++) = 0;
+	  }
+  } // namespace internal
+  } // namespace ink
+
+#endif