inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp_compiler/json_compiler.cpp

@@ -0,0 +1,411 @@
+/* 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 "json_compiler.h"
+
+#include "command.h"
+#include "list_data.h"
+#include "system.h"
+#include "version.h"
+
+#include <string_view>
+
+namespace ink::compiler::internal
+{
+using nlohmann::json;
+using std::vector;
+
+typedef std::tuple<json, std::string> defer_entry;
+
+json_compiler::json_compiler()
+    : _emitter(nullptr)
+    , _next_container_index(0)
+{
+}
+
+void json_compiler::compile(
+    const nlohmann::json& input, emitter* output, compilation_results* results
+)
+{
+	// Get the runtime version
+	_ink_version = input["inkVersion"];
+
+	// Start the output
+	set_results(results);
+	_emitter = output;
+
+	// Initialize emitter
+	_emitter->start(_ink_version, results);
+
+	if (auto itr = input.find("listDefs"); itr != input.end()) {
+		compile_lists_definition(*itr);
+		_emitter->set_list_meta(_list_meta);
+	}
+	// Compile the root container
+	compile_container(input["root"], 0);
+
+	// finalize
+	_emitter->finish(_next_container_index);
+
+	// Clear
+	_emitter              = nullptr;
+	_next_container_index = 0;
+	clear_results();
+}
+
+struct container_meta {
+	std::string         name;
+	container_t         indexToReturn        = ~0;
+	bool                recordInContainerMap = false;
+	vector<defer_entry> deferred;
+	CommandFlag         cmd_flags = CommandFlag::NO_FLAGS;
+};
+
+void json_compiler::handle_container_metadata(const json& meta, container_meta& data)
+{
+	if (meta.is_object()) {
+		for (auto& meta_iter : meta.items()) {
+			// Name
+			if (meta_iter.key() == "#n") {
+				data.name = meta_iter.value().get<std::string>();
+			}
+			// Flags
+			else if (meta_iter.key() == "#f") {
+				int flags = meta_iter.value().get<int>();
+
+				bool visits = false, turns = false, onlyFirst = false;
+
+				if ((flags & 0x1) > 0) // Should record visit counts
+				{
+					visits = true;
+				}
+				if ((flags & 0x2) > 0) // Should record turn counts
+				{
+					turns = true;
+				}
+				if ((flags & 0x4) > 0) // Only count when you enter the first subelement
+				{
+					onlyFirst = true;
+				}
+
+				if (visits || turns) {
+					container_t myIndex = _next_container_index++;
+
+					// Make appropriate flags
+					data.cmd_flags = CommandFlag::NO_FLAGS;
+					if (visits)
+						data.cmd_flags |= CommandFlag::CONTAINER_MARKER_TRACK_VISITS;
+					if (turns)
+						data.cmd_flags |= CommandFlag::CONTAINER_MARKER_TRACK_TURNS;
+					if (onlyFirst)
+						data.cmd_flags |= CommandFlag::CONTAINER_MARKER_ONLY_FIRST;
+
+
+					data.indexToReturn = myIndex;
+
+					// if (!onlyFirst) // ????
+					{
+						data.recordInContainerMap = true;
+					}
+				}
+			}
+			// Child container
+			else {
+				// Add to deferred compilation list
+				data.deferred.push_back(std::make_tuple(meta_iter.value(), meta_iter.key()));
+			}
+		}
+	}
+}
+
+void json_compiler::compile_container(
+    const nlohmann::json& container, int index_in_parent, const std::string& name_override
+)
+{
+	// Grab metadata from the last object in this container
+	container_meta meta;
+	handle_container_metadata(*container.rbegin(), meta);
+
+	// tell the emitter we're beginning a new container
+	uint32_t position = _emitter->start_container(
+	    index_in_parent, name_override.empty() ? meta.name : name_override
+	);
+	// Write command out at this position
+	if (meta.cmd_flags != CommandFlag::NO_FLAGS) {
+		_emitter->write(Command::START_CONTAINER_MARKER, meta.indexToReturn, meta.cmd_flags);
+	}
+	if (meta.recordInContainerMap) {
+		_emitter->add_start_to_container_map(position, meta.indexToReturn);
+	}
+
+	// Now, we want to iterate children of this container, save the last
+	//  The last is the settings object handled above
+	int  index = -1;
+	auto end   = container.end() - 1;
+	for (auto iter = container.begin(); iter != end; ++iter) {
+		// Increment index
+		index++;
+
+		// Arrays are child containers. Recurse.
+		if (iter->is_array())
+			compile_container(*iter, index);
+
+		// Strings are either commands, nops, or raw strings
+		else if (iter->is_string()) {
+			// Get the string
+			std::string string = iter->get<std::string>();
+
+			if (string[0] == '^')
+				_emitter->write_string(Command::STR, CommandFlag::NO_FLAGS, string);
+			else if (string == "nop")
+				_emitter->handle_nop(index);
+			else
+				compile_command(string);
+		}
+
+		// Numbers (floats and integers)
+		else if (iter->is_number()) {
+			if (iter->is_number_float()) {
+				float value = iter->get<float>();
+				_emitter->write(Command::FLOAT, value);
+			} else {
+				int value = iter->get<int>();
+				_emitter->write(Command::INT, value);
+			}
+		}
+
+		// Booleans
+		else if (iter->is_boolean()) {
+			int value = iter->get<bool>() ? 1 : 0;
+			_emitter->write(Command::BOOL, value);
+		}
+
+		// Complex commands
+		else if (iter->is_object()) {
+			compile_complex_command(*iter);
+		}
+
+		else {
+			throw ink_exception("Failed to container member!");
+		}
+	}
+
+	if (meta.deferred.size() > 0) {
+		std::vector<size_t> divert_positions;
+
+		// Write empty divert to be patched later
+		uint32_t divert_position = _emitter->fallthrough_divert();
+		divert_positions.push_back(divert_position);
+
+		// (2) Write deffered containers
+		for (auto& t : meta.deferred) {
+			using std::get;
+
+			// Add to named child list
+			compile_container(get<0>(t), -1, get<1>(t));
+
+			// Need a divert here
+			uint32_t pos = _emitter->fallthrough_divert();
+			divert_positions.push_back(pos);
+		}
+
+		// (3) Set divert positions
+		for (size_t offset : divert_positions)
+			_emitter->patch_fallthroughs(offset);
+	}
+
+	// End container
+	uint32_t end_position = _emitter->end_container();
+
+	// Write end container marker, End pointer should point to End command (form symetry with START
+	// command)
+	if (meta.indexToReturn != ~0)
+		_emitter->write(Command::END_CONTAINER_MARKER, meta.indexToReturn, meta.cmd_flags);
+
+	// Record end position in map
+	if (meta.recordInContainerMap)
+		_emitter->add_end_to_container_map(end_position, meta.indexToReturn);
+}
+
+void json_compiler::compile_command(const std::string& command)
+{
+	// Find command
+	for (int i = 0; i < ( int ) Command::NUM_COMMANDS; i++) {
+		if (CommandStrings[i] != nullptr && command == CommandStrings[i]) {
+			_emitter->write_raw(( Command ) i, CommandFlag::NO_FLAGS, nullptr, 0);
+			return;
+		}
+	}
+
+	// Missing command warning
+	err() << "Unknown command '" << command << "'. Skipping." << std::flush;
+}
+
+void json_compiler::compile_complex_command(const nlohmann::json& command)
+{
+	std::string val;
+
+	// Divert
+	if (get(command, "->", val)) {
+		// Check if this is a conditional divert
+		bool        isConditional = false;
+		CommandFlag flag          = CommandFlag::NO_FLAGS;
+		if (get(command, "c", isConditional) && isConditional)
+			flag = CommandFlag::DIVERT_HAS_CONDITION;
+
+		// Switch on whether this is a variable divert or a path divert
+		bool isVariableDivert = false;
+		if (get(command, "var", isVariableDivert) && isVariableDivert)
+			_emitter->write_variable(Command::DIVERT_TO_VARIABLE, flag, val);
+		else
+			_emitter->write_path(Command::DIVERT, flag, val);
+	}
+
+	// Divert to a value
+	else if (get(command, "^->", val)) {
+		// Write path in a divert_val command
+		_emitter->write_path(Command::DIVERT_VAL, CommandFlag::NO_FLAGS, val);
+	}
+
+	// Tunnel
+	else if (get(command, "->t->", val)) {
+		bool is_var;
+		if (get(command, "var", is_var) && is_var) {
+			_emitter->write_variable(Command::TUNNEL, CommandFlag::TUNNEL_TO_VARIABLE, val);
+		} else {
+			_emitter->write_path(Command::TUNNEL, CommandFlag::NO_FLAGS, val);
+		}
+	}
+
+	// Declare temporary variable
+	else if (get(command, "temp=", val)) {
+		bool is_redef = false;
+		get(command, "re", is_redef);
+		_emitter->write_variable(
+		    Command::DEFINE_TEMP,
+		    is_redef ? CommandFlag::ASSIGNMENT_IS_REDEFINE : CommandFlag::NO_FLAGS, val
+		);
+	}
+
+	// Set variable
+	else if (get(command, "VAR=", val)) {
+		// check if it's a redefinition
+		bool is_redef = false;
+		get(command, "re", is_redef);
+
+		// Set variable
+		_emitter->write_variable(
+		    Command::SET_VARIABLE,
+		    is_redef ? CommandFlag::ASSIGNMENT_IS_REDEFINE : CommandFlag::NO_FLAGS, val
+		);
+	}
+
+	// create pointer value
+	else if (get(command, "^var", val)) {
+		int ci;
+		if (! get(command, "ci", ci)) {
+			throw ink_exception("failed to parse ci for pointer!");
+		}
+		inkAssert(ci < 255, "only support until 255 stack hight for refernces");
+		_emitter->write_variable(Command::VALUE_POINTER, static_cast<CommandFlag>(ci + 1), val);
+	}
+
+	// Push variable
+	else if (get(command, "VAR?", val)) {
+		_emitter->write_variable(Command::PUSH_VARIABLE_VALUE, CommandFlag::NO_FLAGS, val);
+	}
+
+	// Choice
+	else if (get(command, "*", val)) {
+		// Get flags
+		int flags = 0;
+		get(command, "flg", flags);
+
+		// Write choice path
+		_emitter->write_path(Command::CHOICE, ( CommandFlag ) flags, val);
+	}
+
+	// Read count
+	else if (get(command, "CNT?", val)) {
+		// TODO: Why is this true again?
+		_emitter->write_path(Command::READ_COUNT, CommandFlag::NO_FLAGS, val, true);
+	}
+
+	// Internal function call
+	else if (get(command, "f()", val)) {
+		bool is_var; // function address is stored in jump
+		if (get(command, "var", is_var) && is_var) {
+			_emitter->write_variable(Command::FUNCTION, CommandFlag::FUNCTION_TO_VARIABLE, val);
+		} else {
+			_emitter->write_path(Command::FUNCTION, CommandFlag::NO_FLAGS, val);
+		}
+	}
+
+	// External function call
+	else if (get(command, "x()", val)) {
+		// Get argument count
+		int numArgs = 0;
+		get(command, "exArgs", numArgs);
+
+		// Encode argument count into command flag and write out the hash of the function name
+		_emitter->write(
+		    Command::CALL_EXTERNAL, hash_string(val.c_str()), static_cast<CommandFlag>(numArgs)
+		);
+		_emitter->write_path(Command::FUNCTION, CommandFlag::FALLBACK_FUNCTION, val);
+	}
+
+	// list initialisation
+	else if (has(command, "list")) {
+		std::vector<list_flag> entries;
+		auto&                  list = command["list"];
+
+		if (list.size()) {
+			for (const auto& [key, value] : list.items()) {
+				entries.push_back(
+				    {_list_meta.get_lid(key.substr(0, key.find('.'))),
+				     static_cast<decltype(list_flag::flag)>(value.get<int>())}
+				);
+			}
+		} else {
+			if (has(command, "origins")) {
+				for (const auto& origin_list : command["origins"]) {
+					// list id < -1 -> origin flag
+					entries.push_back(
+					    {static_cast<int16_t>(-2 - _list_meta.get_lid(origin_list.get<std::string>())), -1}
+					);
+				}
+			} else {
+				entries.push_back(empty_flag);
+			}
+		}
+
+		_emitter->write_list(Command::LIST, CommandFlag::NO_FLAGS, entries);
+	}
+
+	else if (get(command, "#", val)) {
+		if (_ink_version > 20) {
+			ink_exception("with inkVerison 21 the tag system chages, and the '#: <tag>' is deprecated now"
+			);
+		}
+		_emitter->write_string(Command::TAG, CommandFlag::NO_FLAGS, val);
+	}
+
+	else {
+		throw ink_exception("failed to parse complex command!");
+	}
+}
+
+void json_compiler::compile_lists_definition(const nlohmann::json& list_defs)
+{
+	for (auto& [list_name, flags] : list_defs.items()) {
+		_list_meta.new_list(list_name);
+		for (auto& [flag_name, value] : flags.items()) {
+			_list_meta.new_flag(flag_name, value.get<int>());
+		}
+	}
+	_list_meta.sort();
+}
+} // namespace ink::compiler::internal

data/ext/inkcpp_rb/inkcpp/inkcpp_compiler/json_compiler.h

@@ -0,0 +1,62 @@
+/* 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 "json.hpp"
+#include "system.h"
+#include "compilation_results.h"
+#include "emitter.h"
+#include "reporter.h"
+#include "list_data.h"
+
+#include <vector>
+
+namespace ink::compiler::internal
+{
+	struct container_meta;
+
+	// Compiles ink json and outputs using a given emitter
+	class json_compiler : public reporter
+	{
+	public:
+		// create new compiler
+		json_compiler();
+
+		// compile from json using an emitter
+		void compile(const nlohmann::json& input, emitter* output, compilation_results* results = nullptr);
+
+	private: // == Compiler methods ==
+		void handle_container_metadata(const nlohmann::json& meta, container_meta& data);
+		void compile_container(const nlohmann::json& container, int index_in_parent, const std::string& name_override = "");
+		void compile_command(const std::string& command);
+		void compile_complex_command(const nlohmann::json& command);
+		void compile_lists_definition(const nlohmann::json& list_defs);
+
+	private: // == JSON Helpers ==
+		inline bool has(const nlohmann::json& json, const std::string& key)
+		{
+			return json.find(key) != json.end();
+		}
+
+		template<typename T>
+		bool get(const nlohmann::json& json, const std::string& key, T& value)
+		{
+			auto iter = json.find(key);
+			if (iter == json.end())
+				return false;
+
+			value = iter->get<T>();
+			return true;
+		}
+
+	private: // == Private members ==
+		emitter* _emitter;
+		container_t _next_container_index;
+
+		list_data _list_meta;
+		int _ink_version;
+	};
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_compiler/list_data.cpp

@@ -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.
+ */
+#include "list_data.h"
+
+#include <algorithm>
+#include <limits>
+
+namespace ink::compiler::internal
+{
+void list_data::new_list(const std::string& list_name)
+{
+	_lists.insert({list_name, static_cast<int>(_list_end.size())});
+	_list_name.emplace_back(list_name);
+	int current_back = _list_end.empty() ? 0 : _list_end.back();
+	_list_end.push_back(current_back);
+}
+
+void list_data::new_flag(const std::string& flag_name, int value)
+{
+	inkAssert(
+	    value <= std::numeric_limits<decltype(list_flag::flag)>::max()
+	        && value >= std::numeric_limits<decltype(list_flag::flag)>::min(),
+	    "Value outside of current supported scope"
+	);
+	_list_end.back() += 1;
+	_flags.emplace_back(
+	    &flag_name,
+	    list_flag{
+	        .list_id = static_cast<decltype(list_flag::list_id)>(_list_name.size() - 1),
+	        .flag    = static_cast<decltype(list_flag::flag)>(value)}
+	);
+}
+
+void list_data::sort()
+{
+	size_t begin = 0;
+	for (size_t i = 0; i < _list_end.size(); ++i) {
+		std::sort(_flags.begin() + begin, _flags.begin() + _list_end[i]);
+		begin = _list_end[i];
+	}
+}
+
+} // namespace ink::compiler::internal

data/ext/inkcpp_rb/inkcpp/inkcpp_compiler/list_data.h

@@ -0,0 +1,70 @@
+/* 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 <vector>
+#include <string>
+#include <map>
+#include <string_view>
+
+namespace ink::compiler::internal
+{
+class list_data
+{
+	using flag_t = decltype(list_flag::flag);
+	using lid_t  = decltype(list_flag::list_id);
+
+public:
+	// add new list and set it to current
+	void new_list(const std::string& list_name);
+
+	// add flag to current list
+	void new_flag(const std::string& flag_name, int value);
+
+	// sort flags per list
+	void sort();
+
+	lid_t get_lid(const std::string_view& list_name)
+	{
+		auto itr = _lists.find(list_name);
+		return static_cast<lid_t>(itr->second);
+	}
+
+	bool empty() const { return _lists.empty(); }
+
+	struct named_list_flag {
+		named_list_flag(const std::string* name, list_flag flag)
+		    : name{name}
+		    , flag{flag}
+		{
+		}
+
+		const std::string* name;
+		list_flag          flag;
+
+		bool operator<(const named_list_flag& oth) const
+		{
+			inkAssert(
+			    flag.list_id == oth.flag.list_id, "Compare flags from different lists is not supported"
+			);
+			return flag.flag < oth.flag.flag;
+		}
+	};
+
+	const std::vector<named_list_flag>& get_flags() const { return _flags; }
+
+	const std::vector<std::string_view>& get_list_names() const { return _list_name; }
+
+private:
+	std::map<std::string, int, std::less<>> _lists;
+	std::vector<std::string_view>           _list_name;
+	std::vector<int>                        _list_end;
+	std::vector<named_list_flag>            _flags;
+};
+} // namespace ink::compiler::internal

data/ext/inkcpp_rb/inkcpp/inkcpp_compiler/reporter.cpp

@@ -0,0 +1,107 @@
+/* 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 "reporter.h"
+#include "compilation_results.h"
+#include "system.h"
+
+#include <iostream>
+#include <sstream>
+
+namespace ink::compiler::internal
+{
+	reporter::reporter()
+		: _results(nullptr), _stream(&_buffer)
+	{
+	}
+
+	void reporter::set_results(compilation_results* results)
+	{
+		_results = results;
+	}
+
+	void reporter::clear_results()
+	{
+		_results = nullptr;
+	}
+
+	std::ostream& reporter::warn()
+	{
+		// setp warning buffer
+		if (_results != nullptr)
+		{
+			_buffer.start(&_results->warnings);
+		}
+
+		return _stream;
+	}
+
+	std::ostream& reporter::err()
+	{
+		// setp error buffer
+		if (_results != nullptr)
+		{
+			_buffer.start(&_results->errors);
+		}
+
+		return _stream;
+	}
+
+	std::ostream& reporter::crit()
+	{
+		// setp error buffer
+		if (_results != nullptr)
+		{
+			_buffer.start(&_results->errors);
+			_buffer.throw_on_sync(true);
+		}
+
+		return _stream;
+	}
+
+	void error_strbuf::start(error_list* list)
+	{
+		// store list
+		_list = list;
+
+		// Make sure our buffer is empty
+#ifdef WIN32
+		_Tidy();
+#endif
+	}
+
+	void error_strbuf::throw_on_sync(bool t)
+	{
+		_throw = t;
+	}
+
+	int error_strbuf::sync()
+	{
+		// TODO: Assert?
+		if (_list == nullptr)
+			return -1;
+
+		// Add string to list
+		std::string val = str();
+		_list->push_back(val);
+
+		// Clear our state
+		_list = nullptr;
+#ifdef WIN32
+		_Tidy();
+#endif
+
+		// Should we throw?
+		if (_throw)
+		{
+			_throw = false;
+			throw ink::ink_exception(("CRITICAL ERROR: " + val).c_str());
+		}
+
+		// Return success
+		return 0;
+	}
+}