inkcpp_rb 0.1.0

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

@@ -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.
+ */
+#pragma once
+
+#include "system.h"
+#include <string>
+#include <vector>
+#include <ostream>
+
+namespace ink
+{
+	namespace compiler
+	{
+		namespace internal
+		{
+			// Simple stream for writing data to an expanding binary stream in memory
+			class binary_stream
+			{
+			public:
+				binary_stream();
+				~binary_stream();
+
+				// Writes an arbitrary type
+				template<typename T>
+				size_t write(const T& value)
+				{
+					return write((const byte_t*)&value, sizeof(T));
+				}
+
+				// Write a string plus a null terminator
+
+				// Writes data to the end of the stream
+				size_t write(const byte_t* data, size_t len);
+
+				// Writes the data in the buffer into another stream
+				void write_to(std::ostream& out) const;
+
+				// Gets the current position in memory of the write head
+				size_t pos() const;
+
+				template<typename T>
+				void set(size_t offset, const T& value)
+				{
+					set(offset, (const byte_t*)&value, sizeof(T));
+				}
+
+				// Writes data into an old position
+				void set(size_t offset, const byte_t* data, size_t len);
+
+				// reset to 0
+				void reset();
+
+				// read a byte from stream
+				byte_t get(size_t offset) const;
+
+			private:
+				// Size of a data slab. Whenever
+				//  a slab runs out of data,
+				//  a new slab is allocated.
+				const size_t DATA_SIZE = 256;
+
+				// Prior slabs
+				std::vector<byte_t*> _slabs;
+
+				// Current slab being written to
+				byte_t* _currentSlab = nullptr;
+
+				// Write head
+				byte_t* _ptr = nullptr;
+			};
+			template<>
+			size_t binary_stream::write(const std::string& value);
+		}
+	}
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_compiler/command.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 "command.h"
+
+namespace ink
+{
+	// Command strings used by compiler
+	const char* CommandStrings[] = {
+			"inkcpp_STR",
+			"inkcpp_INT",
+			"inkcpp_BOOL",
+			"inkcpp_FLOAT",
+			"inkcpp_VALUE_POINTER",
+			"inkcpp_DIVERT_VAL",
+			"inkcpp_LIST",
+			"\n",
+			"<>",
+			"void",
+			"inkcpp_TAG",
+			"inkcpp_DIVERT",
+			"inkcpp_DIVERT_TO_VARIABLE",
+			"inkcpp_TUNNEL",
+			"inkcpp_FUNCTION",
+			"done",
+			"end",
+			"->->",
+			"~ret",
+
+			"inkcpp_DEFINE_TEMP",
+			"inkcpp_SET_VARIABLE",
+
+			"ev",
+			"/ev",
+			"out",
+			"pop",
+			"du",
+			"inkcpp_PUSH_VARIABLE_VALUE",
+			"visit",
+			"turn",
+			"inkcpp_READ_COUNT",
+			"seq",
+			"srnd",
+
+			"str",
+			"/str",
+			"#",
+			"/#",
+
+			"inkcpp_CHOICE",
+			"thread",
+
+			"range",
+
+			"+",
+			"-",
+			"/",
+			"*",
+			"%",
+			"rnd",
+			"==",
+			">",
+			"<",
+			">=",
+			"<=",
+			"!=",
+			"&&",
+			"||",
+			"MIN",
+			"MAX",
+			"?",
+			"!?",
+			"L^",
+			"listInt",
+
+			"!",
+			"~",
+			"LIST_COUNT",
+			"LIST_MIN",
+			"LIST_MAX",
+			"readc",
+			"turns",
+			"lrnd",
+			"FLOOR",
+			"CEILING",
+			"INT",
+			"LIST_ALL",
+			"LIST_INVERT",
+			"LIST_VALUE",
+			"choiceCnt",
+
+			"START_CONTAINER",
+			"END_CONTAINER",
+
+			"CALL_EXTERNAL"
+	};
+
+	template<unsigned A, unsigned B>
+	struct equal {
+		static_assert(A == B, "Not equal!");
+	};
+	equal<sizeof(CommandStrings) / sizeof(const char*), (int)(Command::NUM_COMMANDS)> dum;
+	static_assert(sizeof(CommandStrings) / sizeof(const char*) == (int)Command::NUM_COMMANDS, "CommandStrings list muss match Command enumeration");
+}

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

@@ -0,0 +1,96 @@
+/* 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 "compiler.h"
+
+#include "json_compiler.h"
+#include "binary_emitter.h"
+
+#include <fstream>
+
+namespace ink::compiler
+{
+	void run(const nlohmann::json& src, std::ostream& out, compilation_results* results)
+	{
+		using namespace internal;
+		
+		// Create compiler and emitter
+		json_compiler compiler;
+		binary_emitter emitter;
+
+		// Compile into emitter
+		compiler.compile(src, &emitter, results);
+
+		// write emitter's results into the stream
+		emitter.output(out);
+	}
+
+	void run(const char* filenameIn, const char* filenameOut, compilation_results* results)
+	{
+		// Load JSON
+		nlohmann::json j;
+		std::ifstream fin(filenameIn);
+		fin >> j;
+
+		// Open output stream
+		std::ofstream fout(filenameOut, std::ios::binary | std::ios::out);
+
+		// Run compiler
+		ink::compiler::run(j, fout, results);
+
+		// Close file
+		fout.close();
+	}
+
+	void run(const char* filenameIn, std::ostream& out, compilation_results* results)
+	{
+		// Load JSON
+		nlohmann::json j;
+		std::ifstream fin(filenameIn);
+		fin >> j;
+
+		// Run compiler
+		ink::compiler::run(j, out, results);
+	}
+
+	void run(const nlohmann::json& j, const char* filenameOut, compilation_results* results)
+	{
+		// Open output stream
+		std::ofstream fout(filenameOut, std::ios::binary | std::ios::out);
+
+		// Run compiler
+		ink::compiler::run(j, fout, results);
+
+		// Close file
+		fout.close();
+	}
+
+	void run(std::istream& in, std::ostream& out, compilation_results* results)
+	{
+		// Load JSON
+		nlohmann::json j;
+		in >> j;
+
+		// Run compiler
+		ink::compiler::run(j, out, results);
+	}
+
+	void run(std::istream& in, const char* filenameOut, compilation_results* results)
+	{
+		// Load JSON
+		nlohmann::json j;
+		in >> j;
+
+		// Open output stream
+		std::ofstream fout(filenameOut, std::ios::binary | std::ios::out);
+
+		// Run compiler
+		ink::compiler::run(j, fout, results);
+
+		// Close file
+		fout.close();
+	}
+  } // namespace ink::compiler

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

@@ -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.
+ */
+#include "emitter.h"
+
+namespace ink::compiler::internal
+{
+	void emitter::start(int ink_version, compilation_results* results)
+	{
+		// store
+		_ink_version = ink_version;
+		set_results(results);
+
+		// reset
+		_container_map.clear();
+		_max_container_index = 0;
+
+		// initialize
+		initialize();
+	}
+
+	void emitter::finish(container_t max_container_index)
+	{
+		// store max index
+		_max_container_index = max_container_index;
+
+		// finalize
+		finalize();
+	}
+
+	void emitter::add_start_to_container_map(uint32_t offset, container_t index)
+	{
+		if (_container_map.rbegin() != _container_map.rend())
+		{
+			if (_container_map.rbegin()->first > offset)
+			{
+				warn() << "Container map written out of order. Wrote container at offset "
+					<< offset << " after container with offset " << _container_map.rbegin()->first << std::flush;
+			}
+		}
+
+		_container_map.push_back(std::make_pair(offset, index));
+		setContainerIndex(index);
+	}
+
+	void emitter::add_end_to_container_map(uint32_t offset, container_t index)
+	{
+		if (_container_map.rbegin() != _container_map.rend())
+		{
+			if (_container_map.rbegin()->first > offset)
+			{
+				warn() << "Container map written out of order. Wrote container at offset "
+					<< offset << " after container with offset " << _container_map.rbegin()->first << std::flush;
+			}
+		}
+
+		_container_map.push_back(std::make_pair(offset, index));
+	}
+}

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

@@ -0,0 +1,104 @@
+/* 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 "command.h"
+#include "system.h"
+#include "reporter.h"
+#include <string>
+#include <vector>
+
+namespace ink::compiler::internal
+{
+	class list_data;
+
+	// Abstract base class for emitters which write ink commands to a file
+	class emitter : public reporter
+	{
+	public:
+		virtual ~emitter() { }
+
+		// starts up the emitter (and calls initialize)
+		void start(int ink_version, compilation_results* results = nullptr);
+
+		// tells the emitter compilation is done (and calls finalize)
+		void finish(container_t max_container_index);
+
+		// start a container
+		virtual uint32_t start_container(int index_in_parent, const std::string& name) = 0;
+
+		// ends a container
+		virtual uint32_t end_container() = 0;
+
+		// checks if _root contains a container named name to check
+		// if name is in valid internal function name
+		// @return number of arguments functions takes (arity)
+		// @retval -1 if the function was not found
+		virtual int function_container_arguments(const std::string& name) = 0;
+
+		// Writes a command with an optional payload
+		virtual void write_raw(Command command, CommandFlag flag = CommandFlag::NO_FLAGS, const char* payload = nullptr, ink::size_t payload_size = 0) = 0;
+
+		// Writes a command with a path as the payload
+		virtual void write_path(Command command, CommandFlag flag, const std::string& path, bool useCountIndex = false) = 0;
+
+		// Writes a command with a variable as the payload
+		virtual void write_variable(Command command, CommandFlag flag, const std::string& name) = 0;
+
+		// Writes a command with a string payload
+		virtual void write_string(Command command, CommandFlag flag, const std::string& string) = 0;
+
+		// write a command with a list payload
+		virtual void write_list(Command commmand, CommandFlag flag, const std::vector<list_flag>& list) = 0;
+
+		// Callback for nop commands
+		virtual void handle_nop(int index_in_parent) = 0;
+
+		// adds a fallthrough divert
+		virtual uint32_t fallthrough_divert() = 0;
+
+		// Patches a fallthrough divert at the given position to divert to the current position
+		virtual void patch_fallthroughs(uint32_t position) = 0;
+
+		// Adds a container start marker to the container map
+		void add_start_to_container_map(uint32_t offset, container_t index);
+
+		// Adds a container end marker to the container map
+		void add_end_to_container_map(uint32_t offset, container_t index);
+
+		// add list definitions
+		virtual void set_list_meta(const list_data& lists_defs) = 0;
+
+		// Helpers
+		template<typename T>
+		void write(Command command, const T& param, CommandFlag flag = CommandFlag::NO_FLAGS)
+		{
+			static_assert(sizeof(T) == 4, "Parameters must be 4 bytes long");
+			write_raw(command, flag, (const char*)(&param), sizeof(T));
+		}
+
+	protected:
+		// Initialize (clear state, get ready for a new file)
+		virtual void initialize() = 0;
+
+		// Finalize (do any post processing necessary)
+		virtual void finalize() = 0;
+
+		// Set container index for visit tracking
+		virtual void setContainerIndex(container_t index) = 0;
+
+	protected:
+		typedef std::vector<std::pair<uint32_t, container_t>> container_map;
+
+		// container map
+		container_map _container_map;
+		container_t _max_container_index;
+
+		// ink version
+		int _ink_version;
+	};
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_compiler/include/compilation_results.h

@@ -0,0 +1,22 @@
+/* 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 <vector>
+#include <string>
+
+namespace ink::compiler
+{
+/** list of errors/warnings */
+typedef std::vector<std::string> error_list;
+
+/** stores results from the compilation process */
+struct compilation_results {
+	error_list warnings; ///< list of all warnings generated
+	error_list errors;   ///< list of all errors generated
+};
+} // namespace ink::compiler

data/ext/inkcpp_rb/inkcpp/inkcpp_compiler/include/compiler.h

@@ -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.
+ */
+#pragma once
+
+#include "config.h"
+#ifdef INK_EXPOSE_JSON
+#	ifdef INK_ENABLE_UNREAL
+#		error Exposing JSON is not supported currently in UE
+#	endif
+#	include "../json.hpp"
+#endif
+#include "compilation_results.h"
+#include <iostream>
+
+namespace ink
+{
+/** collection of functions to compile a story.json to story.bin */
+namespace compiler
+{
+	/** file -> file */
+	void run(const char* filenameIn, const char* filenameOut, compilation_results* results = nullptr);
+
+	/** file -> stream */
+	void run(const char* filenameIn, std::ostream& out, compilation_results* results = nullptr);
+
+#ifdef INK_EXPOSE_JSON
+	/** JSON -> file */
+	void run(const nlohmann::json&, const char* filenameOut, compilation_results* results = nullptr);
+
+	/** JSON -> stream */
+	void run(const nlohmann::json&, std::ostream& out, compilation_results* results = nullptr);
+#endif
+
+	/** stream -> stream */
+	void run(std::istream& in, std::ostream& out, compilation_results* results = nullptr);
+
+	/** stream -> file */
+	void run(std::istream& in, const char* filenameOut, compilation_results* results = nullptr);
+} // namespace compiler
+} // namespace ink