Platform

inkcpp/array.h

@@ -151,7 +151,7 @@ namespace ink::runtime::internal
 	public:
 		fixed_restorable_array(const T& initial, const T &nullValue) : basic_restorable_array<T>(_buffer, SIZE * 2, nullValue) 
 		{ 
-			clear(initial);
+			basic_restorable_array<T>::clear(initial);
 		}
 
 	private:
@@ -177,4 +177,4 @@ namespace ink::runtime::internal
 	private:
 		T* _buffer;
 	};
-}
+}

inkcpp/functional.cpp

@@ -11,13 +11,13 @@
 namespace ink::runtime::internal
 {
 	template<typename T>
-	static T function_base::pop(basic_eval_stack* stack)
+	T function_base::pop(basic_eval_stack* stack)
 	{
 		return stack->pop().get<T>();
 	}
 
 	template<typename T>
-	static void function_base::push(basic_eval_stack* stack, const T& value)
+	void function_base::push(basic_eval_stack* stack, const T& value)
 	{
 		stack->push(value);
 	}
@@ -93,4 +93,4 @@ namespace ink::runtime::internal
 		}
 	}
 #endif
-}
+}

inkcpp/include/functional.h

@@ -59,7 +59,7 @@ namespace ink::runtime::internal
 
 		// pops an argument from the stack using the function-type
 		template<int index>
-		typename arg_type<index> pop_arg(basic_eval_stack* stack)
+		arg_type<index> pop_arg(basic_eval_stack* stack)
 		{
 			// todo - type assert?
 
@@ -74,7 +74,7 @@ namespace ink::runtime::internal
 			static_assert(sizeof...(Is) == traits::arity);
 
 			// void functions
-			if constexpr (is_same<void, traits::return_type>::value)
+			if constexpr (is_same<void, typename traits::return_type>::value)
 			{
 				// Just evalulate
 				functor(pop_arg<Is>(stack)...);
@@ -83,18 +83,18 @@ namespace ink::runtime::internal
 				// TODO -- Should be a special "void" value
 				push(stack, 0);
 			}
-			else if constexpr (is_string<traits::return_type>::value)
+			else if constexpr (is_string<typename traits::return_type>::value)
 			{
 				// SPECIAL: The result of the functor is a string type
 				//  in order to store it in the inkcpp interpreter we 
 				//  need to store it in our allocated string table
 				auto string_result = functor(pop_arg<Is>(stack)...);
 
 				// Get string length
-				size_t len = string_handler<traits::return_type>::length(string_result);
+				size_t len = string_handler<typename traits::return_type>::length(string_result);
 
 				// Get source and allocate buffer
-				const char* src = string_handler<traits::return_type>::src(string_result);
+				const char* src = string_handler<typename traits::return_type>::src(string_result);
 				char* buffer = allocate(strings, len + 1);
 
 				// Copy
@@ -140,4 +140,4 @@ namespace ink::runtime::internal
 		D invocableDelegate;
 	};
 #endif
-}
+}

inkcpp/include/globals.h

@@ -13,5 +13,6 @@ namespace ink::runtime
 	public:
 		// No public interface yet
 		virtual void dummy() = 0;
+		virtual ~globals_interface() = default;
 	};
-}
+}

inkcpp/include/traits.h

@@ -168,4 +168,4 @@ namespace ink::runtime::internal
 
 	template<> struct gen_seq<0> : seq<> {};
 	template<> struct gen_seq<1> : seq<0> {};
-}
+}

inkcpp/output.cpp

@@ -5,12 +5,47 @@
 #include <iomanip>
 #endif
 
+#include <cstdio>
+#include <errno.h>
+#include <type_traits>
+
 namespace ink
 {
 	namespace runtime
 	{
 		namespace internal
 		{
+			template<typename T>
+			int toStr(char * buffer, size_t size, T value) {
+				static_assert(!std::is_same<T,T>::value, "Type not supported for conversion!");
+				return EINVAL;
+			}
+
+			// error behavior from: https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/itoa-s-itow-s?view=msvc-160
+			template<>
+			int toStr(char * buffer, size_t size, int 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
+			template<>
+			int toStr(char * buffer, size_t size, float value) {
+#ifdef WIN32
+				return _gcvt_s(buffer, size, value, 11);
+#else
+				if ( buffer == nullptr || size < 1 ) { return EINVAL; }
+				int res = snprintf(buffer, size, "%f.10", value);
+				if (res > 0 && res < size) { return 0; }
+				return EINVAL;
+#endif
+			}
 			basic_stream::basic_stream(data* buffer, size_t len)
 				: _data(buffer), _max(len), _size(0), _save(~0)
 			{
@@ -79,7 +114,7 @@ namespace ink
 			template<typename OUT>
 			inline void write_char(OUT& output, char c)
 			{
-				static_assert(false, "Invalid output type");
+				static_assert(! std::is_same<OUT,OUT>::value, "Invalid output type");
 			}
 
 			template<>
@@ -415,13 +450,13 @@ namespace ink
 					{
 					case data_type::int32:
 						// Convert to string and advance
-						_itoa_s(_data[i].integer_value, ptr, end - ptr, 10);
+						toStr(ptr, end - ptr, _data[i].integer_value);
 						while (*ptr != 0) ptr++;
 
 						break;
 					case data_type::float32:
 						// Convert to string and advance
-						_gcvt_s(ptr, end - ptr, (double)_data[i].float_value, 11);
+						toStr(ptr, end - ptr, _data[i].float_value);
 						while (*ptr != 0) ptr++;
 
 						break;
@@ -554,4 +589,4 @@ namespace ink
 
 		}
 	}
-}
+}

inkcpp/runner_impl.h

@@ -108,9 +108,6 @@ namespace ink::runtime::internal
 		template<typename T>
 		inline T read();
 
-		template<>
-		inline const char* read();
-
 		choice& add_choice();
 		void clear_choices();
 
@@ -168,7 +165,10 @@ namespace ink::runtime::internal
 		bool _saved = false;
 	};
 
+	template<>
+	inline const char* runner_impl::read();
+
 #ifdef INK_ENABLE_STL
 	std::ostream& operator<<(std::ostream&, runner_impl&);
 #endif
-}
+}

inkcpp_cl/test.cpp

@@ -173,7 +173,7 @@ bool test_directory(const std::string& directory)
 	{
 		if (p.path().extension() == ".ink")
 		{
-			bool success = test(p.path().u8string());
+			bool success = test(p.path().string());
 			if (!success)
 				return false;
 		}

inkcpp_compiler/binary_emitter.cpp

@@ -4,13 +4,33 @@
 #include <map>
 #include <fstream>
 
+#ifndef WIN32
+#include <cstring>
+#endif
+
 namespace ink::compiler::internal
 {
 	using std::vector;
 	using std::map;
 	using std::string;
 	using std::tuple;
 
+	char* strtok_s(char * s, const char * sep, char** context) {
+#ifdef WIN32
+		return strtok_s(s, sep, context);
+#else
+		if (
+				context == nullptr ||
+				sep == nullptr ||
+				s == nullptr && *context == nullptr )
+		{
+			errno = EINVAL;
+			return nullptr;
+		}
+		return strtok_r(s, sep, context);
+#endif
+	}
+
 	// holds information about a container
 	struct container_data
 	{
@@ -243,7 +263,8 @@ namespace ink::compiler::internal
 			// We need to parse the path
 			offset_t noop_offset = ~0;
 			char* _context = nullptr;
-			const char* token = strtok_s(const_cast<char*>(path_cstr), ".", &_context);
+			const char* token = ink::compiler::internal::strtok_s(
+					const_cast<char*>(path_cstr), ".", &_context);
 			while (token != nullptr)
 			{
 				// Number
@@ -275,7 +296,7 @@ namespace ink::compiler::internal
 				firstParent = false;
 
 				// Get the next token
-				token = strtok_s(nullptr, ".", &_context);
+				token = ink::compiler::internal::strtok_s(nullptr, ".", &_context);
 			}
 
 			if (noop_offset != ~0)
@@ -339,4 +360,4 @@ namespace ink::compiler::internal
 			write_container_hash_map(out, name, child.second);
 		}
 	}
-}
+}

inkcpp_compiler/binary_stream.cpp

@@ -1,11 +1,22 @@
 #include "binary_stream.h"
 
+#include <cstring>
+
 namespace ink
 {
 	namespace compiler
 	{
 		namespace internal
 		{
+			template<>
+			size_t binary_stream::write(const std::string& value)
+			{
+				constexpr byte_t ZERO = 0;
+				size_t len = write((const byte_t*)value.c_str(), value.length());
+				len += write(&ZERO, 1);
+				return len;
+			}
+
 			binary_stream::binary_stream()
 				: _currentSlab(nullptr)
 				, _ptr(nullptr)
@@ -124,4 +135,4 @@ namespace ink
 			}
 		}
 	}
-}
+}

inkcpp_compiler/binary_stream.h

@@ -26,14 +26,6 @@ namespace ink
 				}
 
 				// Write a string plus a null terminator
-				template<>
-				size_t write(const std::string& value)
-				{
-					const byte_t ZERO = 0;
-					size_t len = write((const byte_t*)value.c_str(), value.length());
-					len += write(&ZERO, 1);
-					return len;
-				}
 
 				// Writes data to the end of the stream
 				size_t write(const byte_t* data, size_t len);
@@ -71,6 +63,8 @@ namespace ink
 				// Write head
 				byte_t* _ptr = nullptr;
 			};
+			template<>
+			size_t binary_stream::write(const std::string& value);
 		}
 	}
-}
+}

inkcpp_compiler/command.cpp

@@ -66,4 +66,4 @@ namespace ink
 	};
 
 	static_assert(sizeof(CommandStrings) / sizeof(const char*) == (int)Command::NUM_COMMANDS, "CommandStrings list much match Command enumeration");
-}
+}

inkcpp_compiler/include/compiler.h

@@ -2,7 +2,7 @@
 
 #include "config.h"
 #ifdef INK_EXPOSE_JSON
-#include "json.hpp"
+#include "../json.hpp"
 #endif
 #include "compilation_results.h"
 #include <iostream>
@@ -31,4 +31,4 @@ namespace ink
 		// stream -> file
 		void run(std::istream& in, const char* filenameOut, compilation_results* results = nullptr);
 	}
-}
+}

inkcpp_compiler/reporter.cpp

@@ -62,7 +62,9 @@ namespace ink::compiler::internal
 		_list = list;
 
 		// Make sure our buffer is empty
+#ifdef WIN32
 		_Tidy();
+#endif
 	}
 
 	void error_strbuf::throw_on_sync(bool t)
@@ -82,7 +84,9 @@ namespace ink::compiler::internal
 
 		// Clear our state
 		_list = nullptr;
+#ifdef WIN32
 		_Tidy();
+#endif
 
 		// Should we throw?
 		if (_throw)
@@ -94,4 +98,4 @@ namespace ink::compiler::internal
 		// Return success
 		return 0;
 	}
-}
+}

shared/private/command.h

@@ -126,6 +126,6 @@ namespace ink
 	constexpr unsigned int CommandSize = sizeof(Command) + sizeof(CommandFlag) + sizeof(PayloadType);
 
 #ifdef INK_COMPILER
-	const char* CommandStrings[];
+	extern const char* CommandStrings[];
 #endif
 }