Format: Fill float printing with '0's until the precision

PUBLIC items will populate the INTERFACE_INCLUDE_DIRECTORIES property of
<target>. This property is a list of public include directories
requirements for a library.

Targets may populate this property to publish the include directories
required to compile against the headers for the target.

CMakeLists.txt

@@ -4,8 +4,13 @@
 # Set project name
 set(PROJECT "ruc")
 
-# Unit tests
+if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-option(RUC_BUILD_TESTS "Build the RUC test programs" ON)
+	set(RUC_STANDALONE TRUE)
+endif()
+
+# Options
+option(BUILD_SHARED_LIBS "Build shared libraries" OFF)
+option(RUC_BUILD_TESTS "Build the RUC test programs" ${RUC_STANDALONE})
 
 # ------------------------------------------
 
@@ -55,8 +60,8 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 # Define library source files
 file(GLOB_RECURSE LIBRARY_SOURCES "src/*.cpp")
 
-add_library(${PROJECT} STATIC ${LIBRARY_SOURCES})
+add_library(${PROJECT} ${LIBRARY_SOURCES})
-target_include_directories(${PROJECT} PRIVATE
+target_include_directories(${PROJECT} PUBLIC
 	"src")
 
 # ------------------------------------------
@@ -65,8 +70,8 @@ target_include_directories(${PROJECT} PRIVATE
 # Define source files
 file(GLOB TEST_LIBRARY_SOURCES "test/*.cpp" "src/ruc/timer.cpp")
 
-add_library(${PROJECT}-test STATIC ${TEST_LIBRARY_SOURCES})
+add_library(${PROJECT}-test ${TEST_LIBRARY_SOURCES})
-target_include_directories(${PROJECT}-test PRIVATE
+target_include_directories(${PROJECT}-test PUBLIC
 	"src"
 	"test")
 
@@ -75,11 +80,8 @@ target_include_directories(${PROJECT}-test PRIVATE
 
 if (RUC_BUILD_TESTS)
 	# Define test source files
-	file(GLOB_RECURSE TEST_SOURCES "test/*.cpp")
+	file(GLOB_RECURSE TEST_SOURCES "test/unit/*.cpp")
-	set(TEST_SOURCES ${TEST_SOURCES} ${LIBRARY_SOURCES})
 
 	add_executable(${PROJECT}-unit-test ${TEST_SOURCES})
-	target_include_directories(${PROJECT}-unit-test PRIVATE
+	target_link_libraries(${PROJECT}-unit-test ruc ruc-test)
-		"src"
-		"test")
 endif()

README.org

@@ -9,3 +9,9 @@ Utility library for C++.
 - Formatting library
 - JSON parsing
 - Unit test macros
+
+** Formatting library
+
+The format specification has been heavily inspired by the ~{fmt}~ library, most of the [[https://fmt.dev/latest/syntax.html#format-specification-mini-language][mini-language]] is supported.
+
+*Note*: Development was previously done at: [[https://github.com/riyyi/manafiles/tree/6f0e3d6063ab75ad81899135689569e440ddb813/src/util][manafiles/src/util]] and [[https://github.com/riyyi/manafiles/tree/6f0e3d6063ab75ad81899135689569e440ddb813/test][manafiles/test]].

script/lint-ci.sh

@@ -37,7 +37,7 @@ fi
 subDir="$(dirname -- "$0")"
 
 # Get all files staged for commit
-files="$(git --no-pager diff --cached --name-only)"
+files="$(git --no-pager diff --cached --name-only --diff-filter=d)"
 
 failures=0
 

script/lint-clang-format.sh

@@ -31,7 +31,7 @@ else
 Either skip this script, or install clang-format-11."
 fi
 
-files="${1:-$(git --no-pager diff --cached --name-only)}"
+files="${1:-$(git --no-pager diff --cached --name-only --diff-filter=d)}"
 files="$(echo "$files" | grep -E '\.(cpp|h)$')"
 
 if [ -z "$files" ]; then

script/lint-shell-script.sh

@@ -23,7 +23,7 @@ if ! command -v shellcheck > /dev/null 2>&1; then
 Either skip this script, or install shellcheck."
 fi
 
-files="${1:-$(git --no-pager diff --cached --name-only)}"
+files="${1:-$(git --no-pager diff --cached --name-only --diff-filter=d)}"
 files="$(echo "$files" | grep -E '\.sh$')"
 
 if [ -z "$files" ]; then

src/ruc/argparser.cpp

@@ -259,6 +259,11 @@ bool ArgParser::parseArgument(std::string_view argument)
 }
 
 bool ArgParser::parse(int argc, const char* argv[])
+{
+	return parse(argc, const_cast<char**>(argv));
+}
+
+bool ArgParser::parse(int argc, char* argv[])
 {
 	bool result = true;
 

src/ruc/argparser.h

@@ -63,6 +63,7 @@ public:
 	};
 
 	bool parse(int argc, const char* argv[]);
+	bool parse(int argc, char* argv[]);
 
 	void addOption(Option&& option);
 	void addOption(bool& value, char shortName, const char* longName, const char* usageString, const char* manString);

src/ruc/file.cpp

@@ -6,8 +6,8 @@
 
 #include <cstdint> // int32_t
 #include <filesystem>
-#include <fstream> // ifstream, ios, ofstream
+#include <fstream> // std::ifstream, std::ofstream
-#include <memory>  // make_unique
+#include <memory>  // std::make_shared, std::make_unique, std::shared_ptr
 #include <string>
 #include <string_view>
 
@@ -20,14 +20,11 @@ File::File(std::string_view path)
 	: m_path(path)
 {
 	// Create input stream object and open file
-	std::ifstream file(path.data(), std::ios::in);
+	std::ifstream file(path.data());
 	VERIFY(file.is_open(), "failed to open file: '{}'", path);
 
 	// Get length of the file
-	file.seekg(0, std::ios::end);
+	int32_t size = File::length(path, file);
-	int32_t size = file.tellg();
-	file.seekg(0, std::ios::beg);
-	VERIFY(size != -1, "failed to read file length: '{}'", path);
 
 	// Allocate memory filled with zeros
 	auto buffer = std::make_unique<char[]>(size);
@@ -54,6 +51,39 @@ File File::create(std::string_view path)
 	return File(path);
 }
 
+int32_t File::length(std::string_view path, std::ifstream& file)
+{
+	file.seekg(0, std::ios::end);
+	int32_t length = file.tellg();
+	file.seekg(0, std::ios::beg);
+	VERIFY(length != -1, "failed to read file length: '{}'", path);
+
+	return length;
+}
+
+// FIXME: Deduplicate code with constructor, this broke binary files only
+std::shared_ptr<char[]> File::raw(std::string_view path)
+{
+	// Create input stream object and open file
+	std::ifstream file(path.data());
+	VERIFY(file.is_open(), "failed to open file: '{}'", path);
+
+	// Get length of the file
+	int32_t size = File::length(path, file);
+
+	// Allocate memory filled with zeros
+	auto buffer = std::make_shared<char[]>(size + 1);
+
+	// Fill buffer with file contents
+	file.read(buffer.get(), size);
+	file.close();
+
+	// Null termination
+	buffer[size] = '\0';
+
+	return buffer;
+}
+
 // -----------------------------------------
 
 void File::clear()

src/ruc/file.h

@@ -6,6 +6,8 @@
 
 #pragma once
 
+#include <cstdint> // int32_t
+#include <memory>  // std::shared_ptr
 #include <string>
 #include <string_view>
 
@@ -17,6 +19,8 @@ public:
 	virtual ~File();
 
 	static File create(std::string_view path);
+	static int32_t length(std::string_view path, std::ifstream& file);
+	static std::shared_ptr<char[]> raw(std::string_view path);
 
 	void clear();
 	File& append(std::string_view data);

src/ruc/format/builder.cpp

@@ -5,6 +5,7 @@
  */
 
 #include <algorithm> // min
+#include <charconv>  // std::to_chars
 #include <cstddef>   // size_t
 #include <cstdint>   // uint8_t, uint16_t, uint32_t, uint64_t
 #include <iomanip>   // setprecision
@@ -178,15 +179,53 @@ void Builder::putI64(int64_t value,
 
 void Builder::putF64(double number, uint8_t precision) const
 {
-	precision = std::min(precision, static_cast<uint8_t>(std::numeric_limits<double>::digits10));
+	char buffer[512];
+	auto conversion = std::to_chars(buffer, buffer + sizeof(buffer), number);
+	auto converted = std::string(buffer, conversion.ptr - buffer);
 
-	std::stringstream stream;
+	size_t dot = converted.find('.');
-	stream
+	size_t length = dot + precision + 1;
-		<< std::fixed << std::setprecision(precision)
+
-		<< number
+	// There is no number behind the decimal point
-		<< std::defaultfloat << std::setprecision(6);
+	if (dot == std::string::npos) {
-	std::string string = stream.str();
+		if (precision > 0) {
-	m_builder << string;
+			converted += '.' + std::string(precision, '0');
+		}
+		m_builder << converted;
+		return;
+	}
+
+	// If there are less numbers behind the decimal point than the precision
+	if (converted.length() < length) {
+		converted += std::string(length - converted.length(), '0');
+		m_builder << converted;
+		return;
+	}
+
+	// Only round if there are more numbers behind the decimal point than the precision,
+	// or the number that comes after the maximum precision is higher than 4
+	if (converted.length() > length && converted[length] > '4') {
+		for (size_t i = length - 1; i >= 0 && i < converted.length(); --i) {
+			if (converted[i] == '.') {
+				continue;
+			}
+			if (converted[i] < '9') { // Overflow stops here
+				converted[i]++;
+				break;
+			}
+			converted[i] = '0';
+		}
+	}
+
+	// Cut off the characters after the requested precision
+	if (converted.length() > length) {
+		size_t last_included_number = converted.find_last_not_of("0", length - 1);
+		// If precision is zero, also cut off the '.', otherwise include the '0' after the '.'
+		size_t last_character_is_dot_offset = (converted[last_included_number] == '.') ? (precision > 0 ? 1 : -1) : 0;
+		converted = converted.substr(0, last_included_number + last_character_is_dot_offset + 1);
+	}
+
+	m_builder << converted;
 }
 
 void Builder::putString(std::string_view string, char fill, Align align, size_t width) const

src/ruc/format/formatter.cpp

@@ -81,6 +81,11 @@ void Formatter<const char*>::format(Builder& builder, const char* value) const
 		value != nullptr ? std::string_view { value, strlen(value) } : "nullptr");
 }
 
+void Formatter<const unsigned char*>::format(Builder& builder, const unsigned char* value) const
+{
+	return Formatter<const char*>::format(builder, reinterpret_cast<const char*>(value));
+}
+
 // Pointer
 
 void Formatter<std::nullptr_t>::format(Builder& builder, std::nullptr_t) const

src/ruc/format/formatter.h

@@ -108,9 +108,11 @@ struct Formatter<T> {
 		uint8_t base = 0;
 		bool uppercase = false;
 		switch (specifier.type) {
+		case PresentationType::Binary:
+			base = 2;
+			break;
 		case PresentationType::BinaryUppercase:
 			uppercase = true;
-		case PresentationType::Binary:
 			base = 2;
 			break;
 		case PresentationType::Octal:
@@ -120,9 +122,11 @@ struct Formatter<T> {
 		case PresentationType::Decimal:
 			base = 10;
 			break;
+		case PresentationType::Hex:
+			base = 16;
+			break;
 		case PresentationType::HexUppercase:
 			uppercase = true;
-		case PresentationType::Hex:
 			base = 16;
 			break;
 		default:
@@ -195,6 +199,19 @@ template<size_t N>
 struct Formatter<char[N]> : Formatter<const char*> {
 };
 
+template<>
+struct Formatter<const unsigned char*> : Formatter<const char*> {
+	void format(Builder& builder, const unsigned char* value) const;
+};
+
+template<>
+struct Formatter<unsigned char*> : Formatter<const unsigned char*> {
+};
+
+template<size_t N>
+struct Formatter<unsigned char[N]> : Formatter<const unsigned char*> {
+};
+
 // Pointer
 
 template<typename T>

src/ruc/format/log.h

@@ -70,7 +70,8 @@ private:
 template<typename T>
 const LogOperatorStyle& operator<<(const LogOperatorStyle& logOperatorStyle, const T& value)
 {
-	_format(const_cast<LogOperatorStyle&>(logOperatorStyle).builder(), value);
+	Formatter<T> formatter;
+	formatter.format(const_cast<LogOperatorStyle&>(logOperatorStyle).builder(), value);
 	return logOperatorStyle;
 }
 

src/ruc/format/parser.cpp

@@ -411,6 +411,8 @@ constexpr void Parser::checkSpecifierType(const Specifier& specifier, ParameterT
 	case ParameterType::Container:
 		checkSpecifierContainerType(specifier);
 		break;
+	case ParameterType::UserDefined:
+		break;
 	default:
 		VERIFY_NOT_REACHED();
 	}

src/ruc/format/parser.h

@@ -32,6 +32,7 @@ public:
 		String,
 		Pointer,
 		Container,
+		UserDefined,
 	};
 
 	Parser(std::string_view format, size_t parameterCount);

src/ruc/json/fromjson.h

@@ -7,7 +7,8 @@
 #pragma once
 
 #include <algorithm> // transform
-#include <cstddef>   // nullptr_t
+#include <cstddef>   // nullptr_t, size_t
+#include <cstdint>   // int32_t, int64_t, uint32_t
 #include <map>
 #include <string>
 #include <unordered_map>
@@ -17,6 +18,7 @@
 #include "ruc/json/array.h"
 #include "ruc/json/object.h"
 #include "ruc/meta/assert.h"
+#include "ruc/meta/concepts.h"
 #include "ruc/meta/odr.h"
 
 namespace ruc::json {
@@ -44,15 +46,15 @@ void fromJson(const Json& json, bool& boolean)
 	boolean = json.asBool();
 }
 
-template<typename Json>
+template<typename Json, Integral T>
-void fromJson(const Json& json, int& number)
+void fromJson(const Json& json, T& number)
 {
 	VERIFY(json.type() == Json::Type::Number);
-	number = (int)json.asDouble();
+	number = static_cast<T>(json.asDouble());
 }
 
-template<typename Json>
+template<typename Json, FloatingPoint T>
-void fromJson(const Json& json, double& number)
+void fromJson(const Json& json, T& number)
 {
 	VERIFY(json.type() == Json::Type::Number);
 	number = json.asDouble();

src/ruc/json/parser.cpp

@@ -266,7 +266,7 @@ Value Parser::consumeString()
 				break;
 			default:
 				char buffer[7];
-				sprintf(buffer, "\\u%0.4X", character);
+				sprintf(buffer, "\\u%.4X", character);
 				return std::string(buffer);
 				break;
 			}

src/ruc/json/tojson.h

@@ -6,8 +6,8 @@
 
 #pragma once
 
-#include <cassert> // assert
+#include <cstddef> // nullptr_t, size_t
-#include <cstddef> // nullptr_t
+#include <cstdint> // int32_t, int64_t, uint32_t
 #include <map>
 #include <string>
 #include <unordered_map>
@@ -15,6 +15,7 @@
 
 #include "ruc/json/array.h"
 #include "ruc/json/object.h"
+#include "ruc/meta/concepts.h"
 #include "ruc/meta/odr.h"
 
 namespace ruc::json {
@@ -30,20 +31,20 @@ struct jsonConstructor {
 		json.m_value.boolean = boolean;
 	}
 
-	template<typename Json>
+	template<typename Json, Integral T>
-	static void construct(Json& json, int number)
+	static void construct(Json& json, T number)
 	{
 		json.destroy();
 		json.m_type = Json::Type::Number;
-		json.m_value.number = (double)number;
+		json.m_value.number = static_cast<double>(number);
 	}
 
-	template<typename Json>
+	template<typename Json, FloatingPoint T>
-	static void construct(Json& json, double number)
+	static void construct(Json& json, T number)
 	{
 		json.destroy();
 		json.m_type = Json::Type::Number;
-		json.m_value.number = number;
+		json.m_value.number = static_cast<double>(number);
 	}
 
 	template<typename Json>

src/ruc/meta/core.h

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2022 Riyyi
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#define BIT(x) (1 << x)
+
+#define CONCAT_IMPL(a, b) a##b
+#define CONCAT(a, b) CONCAT_IMPL(a, b)

src/ruc/meta/types.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023 Riyyi
+ *
+ * SPDX-License-Identifier: MIT
+ */
+
+#pragma once
+
+#include <typeinfo>
+
+template<typename T, typename U>
+inline bool is(U& input)
+{
+	if constexpr (requires { input.template fastIs<T>(); }) {
+		return input.template fastIs<T>();
+	}
+
+	return typeid(input) == typeid(T);
+}
+
+template<typename T, typename U>
+inline bool is(U* input)
+{
+	return input && is<T>(*input);
+}
+
+// References:
+// - serenity/AK/TypeCasts.h
+// - serenity/Userland/Libraries/LibJS/AST.h

src/ruc/singleton.h

@@ -6,7 +6,9 @@
 
 #pragma once
 
-#include <cassert>
+#include <cstdlib> // free, malloc
+
+#include "meta/assert.h"
 
 namespace ruc {
 
@@ -16,7 +18,10 @@ public:
 	static inline T& the()
 	{
 		if (s_instance == nullptr) {
-			s_instance = new T { s {} };
+			// Allocate memory for this instance
+			s_instance = static_cast<T*>(malloc(sizeof(T)));
+			// Call the constructor using "placement new"
+			new (s_instance) T { s {} };
 		}
 
 		return *s_instance;
@@ -24,10 +29,15 @@ public:
 
 	static inline void destroy()
 	{
-		if (s_instance) {
+		if (!s_instance) {
-			delete s_instance;
+			return;
 		}
 
+		// Call the destructor
+		s_instance->~T();
+		// Deallocate memory
+		free(static_cast<void*>(s_instance));
+
 		s_instance = nullptr;
 	}
 

src/ruc/system.cpp

@@ -1,3 +1,4 @@
+#include <algorithm>  // std::sort, std::unique
 #include <cerrno>     // errno, EAGAIN, EINTR
 #include <cstddef>    // size_t
 #include <cstdio>     // perror, ssize_t

test/unit/testutilformat.cpp

@@ -55,7 +55,7 @@ TEST_CASE(FormatIntegral)
 	result = format("{}", u32);
 	EXPECT_EQ(result, "4294967295");
 
-	size_t u64 = 18446744073709551615; // long unsigned int
+	size_t u64 = 18446744073709551615u; // long unsigned int
 	result = format("{}", u64);
 	EXPECT_EQ(result, "18446744073709551615");
 }
@@ -109,6 +109,14 @@ TEST_CASE(FormatString)
 	result = format("{}", cString);
 	EXPECT_EQ(result, "C string");
 
+	const unsigned char unsignedCharArray[] = "µnsïgned çhãr";
+	result = format("{}", unsignedCharArray);
+	EXPECT_EQ(result, "µnsïgned çhãr");
+
+	const unsigned char* unsignedCharPointer = &unsignedCharArray[0];
+	result = format("{}", unsignedCharPointer);
+	EXPECT_EQ(result, "µnsïgned çhãr");
+
 	std::string string = "string";
 	result = format("{}", string);
 	EXPECT_EQ(result, "string");
@@ -513,5 +521,5 @@ TEST_CASE(FormatContainers)
 }
 
 // Local Variables:
-// lsp-in-cpp-project-cache: nil
+// lsp-in-cpp-project-cache: (nil)
 // End: