inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp/list_impl.cpp

@@ -0,0 +1,79 @@
+/* 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 "list_impl.h"
+#include "list.h"
+#include "list_table.h"
+
+namespace ink::runtime::internal
+{
+bool list_impl::contains(const char* flag_name) const
+{
+	auto flag = _list_table->toFlag(flag_name);
+	inkAssert(flag.has_value(), "No flag with name found! " FORMAT_STRING_STR "'", flag_name);
+	return _list_table->has(list_table::list{_list}, *flag);
+}
+
+void list_impl::add(const char* flag_name)
+{
+	auto flag = _list_table->toFlag(flag_name);
+	inkAssert(flag.has_value(), "No flag with name found to add! '" FORMAT_STRING_STR "'", flag_name);
+	_list = _list_table->add(list_table::list{_list}, *flag).lid;
+}
+
+void list_impl::remove(const char* flag_name)
+{
+	auto flag = _list_table->toFlag(flag_name);
+	inkAssert(
+	    flag.has_value(), "No flag with name found to remove! '" FORMAT_STRING_STR "'", flag_name
+	);
+	_list = _list_table->sub(list_table::list{_list}, *flag).lid;
+}
+
+void list_impl::next(const char*& flag_name, const char*& list_name, int& i, bool one_list_only)
+    const
+{
+	if (i == -1) {
+		return;
+	}
+
+	list_flag flag{.list_id = static_cast<int16_t>(i >> 16), .flag = static_cast<int16_t>(i & 0xFF)};
+	if (flag_name != nullptr) {
+		++flag.flag;
+	}
+	if (flag.flag >= _list_table->_list_end[flag.list_id]) {
+next_list:
+		if (one_list_only) {
+			i = -1;
+			return;
+		}
+		flag.flag = 0;
+		do {
+			++flag.list_id;
+			if (static_cast<size_t>(flag.list_id) >= _list_table->_list_end.size()) {
+				i = -1;
+				return;
+			}
+		} while (! _list_table->hasList(_list_table->getPtr(_list), flag.list_id));
+	}
+	while (! _list_table->has(list_table::list{_list}, flag)) {
+		++flag.flag;
+		if (flag.flag >= _list_table->_list_end[flag.list_id] - _list_table->listBegin(flag.list_id)) {
+			goto next_list;
+		}
+	}
+	flag_name = _list_table->_flag_names[_list_table->toFid(flag)];
+	list_name = _list_table->_list_names[flag.list_id];
+
+	i = (flag.list_id << 16) | flag.flag;
+}
+
+list_interface::iterator list_impl::begin(const char* list_name) const
+{
+	size_t list_id = _list_table->get_list_id(list_name).list_id;
+	return ++new_iterator(nullptr, list_id << 16, true);
+}
+} // namespace ink::runtime::internal

data/ext/inkcpp_rb/inkcpp/inkcpp/list_impl.h

@@ -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.
+ */
+#pragma once
+
+#include "list.h"
+
+namespace ink::runtime::internal {
+  class list_table;
+  class value;
+  class list_impl final : public list_interface {
+  public:
+    list_impl(list_table& table, int lid) : list_interface(table, lid) {}
+    int get_lid() const { return _list; }
+    
+    bool contains(const char* flag_name) const override;
+    void add(const char* flag_name) override; 
+    void remove(const char* flag_name) override;
+
+    list_interface::iterator begin() const override {
+      return ++new_iterator(nullptr, 0);
+    }
+
+    list_interface::iterator begin(const char* list_name) const override;
+    list_interface::iterator end() const override {
+      return new_iterator(nullptr, -1);
+    }
+
+  private:
+    friend ink::runtime::internal::value;
+    
+    /// @todo wrong iteration order, first lists then flags
+	  void next(const char*& flag_name, const char*& list_name, int& i, bool one_list_only)
+	      const override;
+  };
+}

data/ext/inkcpp_rb/inkcpp/inkcpp/list_operations.cpp

@@ -0,0 +1,276 @@
+/* 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.
+ */
+/// implements operations on lists
+
+#include "stack.h"
+#include "value.h"
+#include "operations.h"
+#include "list_table.h"
+
+#define call4_Wrap(OP, RET, FUN) call4_Wrap_diff(OP, RET, RET, RET, RET, FUN)
+#define call4_Wrap_diff(OP, RET0, RET1, RET2, RET3, FUN)           \
+	void operation<Command::OP, value_type::list, void>::operator()( \
+	    basic_eval_stack& stack, value* vals                         \
+	)                                                                \
+	{                                                                \
+		call4(RET0, RET1, RET2, RET3, FUN);                            \
+	}
+
+#define call4(RET0, RET1, RET2, RET3, FUN)                                                       \
+	if (vals[0].type() == value_type::list_flag) {                                                 \
+		if (vals[1].type() == value_type::list) {                                                    \
+			stack.push(value{}.set<value_type::RET0>(                                                  \
+			    _list_table.FUN(vals[0].get<value_type::list_flag>(), vals[1].get<value_type::list>()) \
+			));                                                                                        \
+		} else {                                                                                     \
+			inkAssert(                                                                                 \
+			    vals[1].type() == value_type::list_flag,                                               \
+			    "list operation was called but second argument is not a list or list_flag"             \
+			);                                                                                         \
+			stack.push(value{}.set<value_type::RET1>(_list_table.FUN(                                  \
+			    vals[0].get<value_type::list_flag>(), vals[1].get<value_type::list_flag>()             \
+			)));                                                                                       \
+		}                                                                                            \
+	} else {                                                                                       \
+		inkAssert(                                                                                   \
+		    vals[0].type() == value_type::list,                                                      \
+		    "list operation was called but first argument is not a list or a list_flag!"             \
+		);                                                                                           \
+		if (vals[1].type() == value_type::list) {                                                    \
+			stack.push(value{}.set<value_type::RET2>(                                                  \
+			    _list_table.FUN(vals[0].get<value_type::list>(), vals[1].get<value_type::list>())      \
+			));                                                                                        \
+		} else {                                                                                     \
+			inkAssert(                                                                                 \
+			    vals[1].type() == value_type::list_flag,                                               \
+			    "list operation was called but second argument ist not a list or list_flag!"           \
+			);                                                                                         \
+			stack.push(value{}.set<value_type::RET3>(                                                  \
+			    _list_table.FUN(vals[0].get<value_type::list>(), vals[1].get<value_type::list_flag>()) \
+			));                                                                                        \
+		}                                                                                            \
+	}
+
+#define call2(OP, RET0, RET1, FUN)                                                                 \
+	void operation<Command::OP, value_type::list, void>::operator()(                                 \
+	    basic_eval_stack& stack, value* vals                                                         \
+	)                                                                                                \
+	{                                                                                                \
+		stack.push(value{}.set<value_type::RET0>(_list_table.FUN(vals[0].get<value_type::list>())));   \
+	}                                                                                                \
+	void operation<Command::OP, value_type::list_flag, void>::operator()(                            \
+	    basic_eval_stack& stack, value* vals                                                         \
+	)                                                                                                \
+	{                                                                                                \
+		stack.push(value{}.set<value_type::RET1>(_list_table.FUN(vals[0].get<value_type::list_flag>()) \
+		));                                                                                            \
+	}
+
+namespace ink::runtime::internal
+{
+void operation<Command::ADD, value_type::list, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	if (vals[1].type() == value_type::int32 || vals[1].type() == value_type::uint32) {
+		int i = vals[1].type() == value_type::int32
+		          ? vals[1].get<value_type::int32>()
+		          : static_cast<int>(vals[1].get<value_type::uint32>());
+		inkAssert(
+		    vals[0].type() == value_type::list,
+		    "try to use list add function but value is not of type list"
+		);
+		stack.push(value{}.set<value_type::list>(_list_table.add(vals[0].get<value_type::list>(), i)));
+	} else {
+		call4(list, list, list, list, add);
+	}
+}
+
+void operation<Command::ADD, value_type::list_flag, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	inkAssert(
+	    vals[0].type() == value_type::list_flag,
+	    "try to use add function with list_flag results but first argument is not a list_flag!"
+	);
+	inkAssert(
+	    vals[1].type() == value_type::int32 || vals[1].type() == value_type::uint32,
+	    "try modify a list flag with a non intiger type!"
+	);
+	int i = vals[1].type() == value_type::int32 ? vals[1].get<value_type::int32>()
+	                                            : static_cast<int>(vals[1].get<value_type::uint32>());
+	stack.push(
+	    value{}.set<value_type::list_flag>(_list_table.add(vals[0].get<value_type::list_flag>(), i))
+	);
+}
+
+void operation<Command::SUBTRACT, value_type::list, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	if (vals[1].type() == value_type::int32 || vals[1].type() == value_type::uint32) {
+		int i = vals[1].type() == value_type::int32 ? vals[1].get<value_type::int32>()
+		                                            : vals[1].get<value_type::uint32>();
+		inkAssert(
+		    vals[0].type() == value_type::list,
+		    "A in list resulting subtraction needs at leas one list as argument!"
+		);
+		stack.push(value{}.set<value_type::list>(_list_table.sub(vals[0].get<value_type::list>(), i)));
+	} else {
+		call4(list_flag, list_flag, list, list, sub);
+	}
+}
+
+void operation<Command::SUBTRACT, value_type::list_flag, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	inkAssert(
+	    vals[0].type() == value_type::list_flag,
+	    "subtraction resulting in list_flag needs a list_flag as first arguments!"
+	);
+	inkAssert(
+	    vals[1].type() == value_type::int32 || vals[1].type() == value_type::uint32,
+	    "Try to subtract non integer value from list_flag."
+	);
+	int i = vals[1].type() == value_type::int32 ? vals[1].get<value_type::int32>()
+	                                            : vals[1].get<value_type::uint32>();
+	stack.push(
+	    value{}.set<value_type::list_flag>(_list_table.sub(vals[0].get<value_type::list_flag>(), i))
+	);
+}
+
+void operation<Command::INTERSECTION, value_type::list, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	call4(list_flag, list_flag, list, list_flag, intersect);
+}
+
+call2(NOT, boolean, boolean, not_bool);
+call2(LIST_COUNT, int32, int32, count);
+call2(LIST_MIN, list_flag, list_flag, min);
+call2(LIST_MAX, list_flag, list_flag, max);
+call2(LIST_ALL, list, list, all);
+call2(LIST_INVERT, list, list, invert);
+
+call4_Wrap(LESS_THAN, boolean, less);
+call4_Wrap(LESS_THAN_EQUALS, boolean, less_equal);
+call4_Wrap(GREATER_THAN, boolean, greater);
+call4_Wrap(GREATER_THAN_EQUALS, boolean, greater_equal);
+call4_Wrap(IS_EQUAL, boolean, equal);
+call4_Wrap(NOT_EQUAL, boolean, not_equal);
+call4_Wrap(HAS, boolean, has);
+call4_Wrap(HASNT, boolean, hasnt);
+
+void operation<Command::lrnd, value_type::list, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	stack.push(
+	    value{}.set<value_type::list_flag>(_list_table.lrnd(vals[0].get<value_type::list>(), _prng))
+	);
+}
+
+void operation<Command::lrnd, value_type::list_flag, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	stack.push(
+	    value{}.set<value_type::list_flag>(_list_table.lrnd(vals[0].get<value_type::list_flag>()))
+	);
+}
+
+void operation<Command::LIST_INT, value_type::string, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	inkAssert(
+	    vals[0].type() == value_type::string,
+	    "list_flag construction needs the list name as string as first argument!"
+	);
+	inkAssert(
+	    vals[1].type() == value_type::int32,
+	    "list_flag construction needs the flag numeric value as second argument!"
+	);
+	list_flag entry = _list_table.get_list_id(vals[0].get<value_type::string>());
+	entry.flag      = vals[1].get<value_type::int32>();
+	entry           = _list_table.external_fvalue_to_internal(entry);
+	stack.push(value{}.set<value_type::list_flag>(entry));
+}
+
+int get_limit(const value& val, const list_table& lists)
+{
+	if (val.type() == value_type::int32) {
+		return val.get<value_type::int32>();
+	} else {
+		inkAssert(val.type() == value_type::list_flag, "flag value must be a integer or a list_flag");
+		return lists.get_flag_value(val.get<value_type::list_flag>());
+	}
+}
+
+void operation<Command::LIST_RANGE, value_type::list, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	inkAssert(vals[0].type() == value_type::list, "Can't get range of non list type!");
+	stack.push(value{}.set<value_type::list>(_list_table.range(
+	    vals[0].get<value_type::list>(), get_limit(vals[1], _list_table),
+	    get_limit(vals[2], _list_table)
+	)));
+}
+
+void convert_bools(value* vals, const list_table& lists, bool* res)
+{
+	for (int i = 0; i < 2; ++i) {
+		switch (vals[i].type()) {
+			case value_type::list: res[i] = lists.to_bool(vals[i].get<value_type::list>()); break;
+			case value_type::list_flag:
+				res[i] = lists.to_bool(vals[i].get<value_type::list_flag>());
+				break;
+			default: res[i] = casting::numeric_cast<value_type::boolean>(vals[i]);
+		}
+	}
+}
+
+void operation<Command::AND, value_type::list, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	bool res[2];
+	convert_bools(vals, _list_table, res);
+	stack.push(value{}.set<value_type::boolean>(res[0] && res[1]));
+}
+
+void operation<Command::AND, value_type::list_flag, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	bool res[2];
+	convert_bools(vals, _list_table, res);
+	stack.push(value{}.set<value_type::boolean>(res[0] && res[1]));
+}
+
+void operation<Command::OR, value_type::list, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	bool res[2];
+	convert_bools(vals, _list_table, res);
+	stack.push(value{}.set<value_type::boolean>(res[0] || res[1]));
+}
+
+void operation<Command::OR, value_type::list_flag, void>::operator()(
+    basic_eval_stack& stack, value* vals
+)
+{
+	bool res[2];
+	convert_bools(vals, _list_table, res);
+	stack.push(value{}.set<value_type::boolean>(res[0] || res[1]));
+}
+} // namespace ink::runtime::internal