res2cpp.cpp

#include <filesystem>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <optional>
#include <algorithm>
#include <cstring>
#include <map>

void print_help_message() {
 std::cout <<
 "res2cpp v1.0 (c) 2024 by Albert Kalchmair\n"
 "\n"
 "Usage: res2cpp [-options]\n"
 " -c, --config <file> sets the path of the config file (stdin when not set).\n"
 " -s, --source <file> sets the path of the source file.\n"
 " -h, --header <file> sets the path of the header file.\n"
 //" -e, --embed use #embed for embedding files.\n"
 " -d, --data <type> use type for data (e.g. uint8_t, std::byte, void)\n"
 " -t, --type <type> use type for resource (e.g. std::span<const uint8_t>).\n"
 " -a, --alias <type> declare an alias for resource type.\n"
 " -i, --include <file> add #include to generated header.\n"
 " -x, --xor <key> encrypt the data using a simple XOR cipher.\n"
 " -n, --native optimize for native endianness to improve compile-time.\n"
 "\n"
 "All Rights Reserved.\n"
 "This program comes with absolutely no warranty.\n"
 "See the GNU General Public License, version 3 for details.\n"
 "\n";
}

struct Settings {
 std::filesystem::path config_file;
 std::filesystem::path source_file;
 std::filesystem::path header_file;
 std::optional<bool> little_endian;
 std::string data_type{ "unsigned char" };
 std::string resource_type;
 std::string resource_alias;
 std::vector<std::string> includes;
 std::string xor_key;
};

struct Definition {
 std::string id;
 std::string path;
 bool is_header;
};

struct Resource {
 std::string id;
 std::filesystem::path path;

 friend bool operator<(const Resource& a, const Resource& b) {
 return std::tie(a.id, a.path) < std::tie(b.id, b.path);
 }
};

struct State {
 std::filesystem::path base_path;
 std::string id_prefix;
 std::string path_prefix;
 std::vector<Resource> resources;
};

bool is_space(char c) {
 return std::isspace(static_cast<unsigned char>(c));
}

bool is_alnum(char c) {
 return (std::isalnum(static_cast<unsigned char>(c)));
}

bool is_digit(char c) {
 return (std::isdigit(static_cast<unsigned char>(c)));
}

std::filesystem::path utf8_to_path(std::string_view utf8_string) {
#if defined(__cpp_char8_t)
 static_assert(sizeof(char) == sizeof(char8_t));
 return std::filesystem::path(
 reinterpret_cast<const char8_t*>(utf8_string.data()),
 reinterpret_cast<const char8_t*>(utf8_string.data() + utf8_string.size()));
#else
 return std::filesystem::u8path(utf8_string);
#endif
}

std::string path_to_utf8(const std::filesystem::path& path) {
#if defined(__cpp_char8_t)
 static_assert(sizeof(char) == sizeof(char8_t));
#endif
 const auto u8string = path.generic_u8string();
 return std::string(
 reinterpret_cast<const char*>(u8string.data()),
 reinterpret_cast<const char*>(u8string.data() + u8string.size()));
}

[[noreturn]] void error(const std::string& message) {
 throw std::runtime_error(message);
}

std::string replace_all(std::string str,
 std::string_view search, std::string_view replace) {
 auto pos = size_t{ };
 while ((pos = str.find(search, pos)) != std::string::npos) {
 str.replace(pos, search.length(), replace);
 pos += replace.length();
 }
 return str;
}

std::string trim(std::string str) {
 while (!str.empty() && is_space(str.front()))
 str.erase(str.begin());
 while (!str.empty() && is_space(str.back()))
 str.pop_back();
 return str;
}

std::string remove_extension(std::string filename) {
 const auto dot = filename.rfind('.');
 if (dot == 0 ||
 dot == std::string_view::npos)
 return filename;
 return filename.substr(0, dot);
}

void add_resource(State& state, std::string&& id, std::string&& path) {
 if (!state.id_prefix.empty())
 id = state.id_prefix + id;

 if (!state.path_prefix.empty())
 path = state.path_prefix + path;

 state.resources.push_back({ std::move(id), std::move(path) });
}

bool interpret_commandline(Settings& settings, int argc, const char* argv[]) {
 for (auto i = 1; i < argc; i++) {
 const auto argument = std::string_view(argv[i]);

 if (argument == "-c" || argument == "--config") {
 if (++i >= argc)
 return false;
 settings.config_file = utf8_to_path(argv[i]);
 }
 else if (argument == "-s" || argument == "--source") {
 if (++i >= argc)
 return false;
 settings.source_file = utf8_to_path(argv[i]);
 }
 else if (argument == "-h" || argument == "--header") {
 if (++i >= argc)
 return false;
 settings.header_file = utf8_to_path(argv[i]);
 }
 else if (argument == "-n" || argument == "--native") {

 static const union {
 int dummy;
 char little;
 } native_endianness = { 1 };

 settings.little_endian.emplace(native_endianness.little == 1);
 }
 else if (argument == "-d" || argument == "--data") {
 if (++i >= argc)
 return false;
 settings.data_type = argv[i];
 }
 else if (argument == "-t" || argument == "--type") {
 if (++i >= argc)
 return false;
 settings.resource_type = argv[i];
 }
 else if (argument == "-a" || argument == "--alias") {
 if (++i >= argc)
 return false;
 settings.resource_alias = argv[i];
 }
 else if (argument == "-i" || argument == "--include") {
 if (++i >= argc)
 return false;
 settings.includes.push_back(argv[i]);
 }
 else if (argument == "-x" || argument == "--xor") {
 if (++i >= argc)
 return false;
 settings.xor_key = argv[i];
 }
 else {
 return false;
 }
 }

 // other paths can be deduced
 if (settings.source_file.empty()) {
 if (settings.config_file.empty())
 return false;
 settings.source_file = settings.config_file;
 settings.source_file.replace_extension("cpp");
 }
 if (settings.header_file.empty()) {
 settings.header_file = settings.source_file;
 settings.header_file.replace_extension("h");
 }
 return true;
}

std::string normalize_path(std::string&& path) {
 return replace_all(std::move(path), "\\", "/");
}

std::string normalize_id(std::string&& id) {
 return replace_all(
 replace_all(std::move(id), "/", "$"), "::", "/");
}

bool is_valid_identifier(std::string_view id) {
 if (id.empty())
 return false;

 auto after_slash = true;
 for (const auto& c : id) {
 if (!is_alnum(c) && c != '_' && c != '/')
 return false;
 if (after_slash && is_digit(c))
 return false;
 after_slash = (c == '/');
 }
 if (id.back() == '/')
 return false;
 return true;
}

std::string deduce_id_from_path(bool is_header, const std::string& path) {
 auto id = trim(is_header ? path : remove_extension(path));

 // replace not allowed characters
 for (auto& c : id)
 if (!is_alnum(c) && c != '/')
 c = '_';

 // insert _ before initial digits
 auto after_slash = true;
 for (auto it = id.begin(); it != id.end(); ++it) {
 if (after_slash && is_digit(*it))
 it = id.insert(it, '_');
 after_slash = (*it == '/');
 }

 // collapse multiple consecutive underscores
 auto after_underscore = false;
 for (auto it = id.begin(); it != id.end(); ) {
 if (*it == '_' && after_underscore) {
 it = id.erase(it);
 }
 else {
 after_underscore = (*it == '_');
 ++it;
 }
 }
 return id;
}

std::optional<Definition> parse_definition(const std::string& line) {
 auto it = line.begin();
 auto end = line.end();

 const auto skip_space = [&]() {
 while (it != end && is_space(*it))
 ++it;
 };
 const auto skip = [&](auto c) {
 if (it != end && *it == c) {
 ++it;
 return true;
 }
 return false;
 };
 const auto skip_until = [&](auto... c) {
 auto begin = it;
 for (; it != end; ++it)
 if (((*it == c) || ...))
 return true;
 it = begin;
 return false;
 };
 const auto skip_string = [&]() {
 if (it == end || !(*it == '"' || *it == '\''))
 return false;
 const auto c = *it;
 ++it;
 if (!skip_until(c))
 error("unterminated string");
 ++it;
 return true;
 };
 const auto skip_until_not_in_string = [&](auto... c) {
 auto begin = it;
 for (;; ++it) {
 skip_string();
 if (it == end)
 break;
 if (((*it == c) || ...))
 return true;
 }
 it = begin;
 return false;
 };

 auto definition = Definition{ };

 // check if it is a header and remove comment
 skip_space();
 auto begin = it;
 if (skip('[')) {
 skip_space();
 begin = it;
 if (!skip_until_not_in_string(']', '#') ||
 *it != ']')
 error("missing ']'");
 definition.is_header = true;
 end = it;
 }
 else {
 if (skip_until_not_in_string(']', '#')) {
 if (*it == ']')
 error("invalid definition");
 end = it;
 }
 }
 it = begin;
 if (it == end && !definition.is_header)
 return std::nullopt;

 // content can be a single sequence or two separated by '='
 // the single or the second sequence can be enclosed in quotes
 if (skip_string()) {
 // single string
 definition.path = normalize_path({ begin + 1, it - 1 });
 definition.id = deduce_id_from_path(
 definition.is_header, definition.path);
 }
 else if (skip_until('=')) {
 // first is no string
 definition.id = normalize_id(trim({ begin, it }));
 if (!definition.id.empty() &&
 !is_valid_identifier(definition.id))
 error("invalid identifier");
 ++it;
 skip_space();
 begin = it;
 if (skip_string()) {
 // second is a string
 definition.path = normalize_path({ begin + 1, it - 1 });
 }
 else {
 // second is no string
 definition.path =
 normalize_path(trim({ begin, end }));
 it = end;
 }
 }
 else {
 // single non string
 definition.path = normalize_path(trim({ begin, end }));
 definition.id = deduce_id_from_path(
 definition.is_header, definition.path);
 it = end;
 }

 // check that there is nothing following
 skip_space();
 if (it != end)
 error("invalid definition");

 if (definition.is_header) {
 it = end + 1;
 end = line.end();
 skip_space();
 if (it != end && *it != '#')
 error("invalid definition");
 }
 else if (definition.id.empty()) {
 error("missing id");
 }
 return definition;
}

void apply_definition(State& state, const Definition& definition) {
 if (definition.is_header) {
 state.id_prefix = definition.id;
 state.path_prefix = definition.path;
 }
 else {
 auto id = definition.id;
 if (!state.id_prefix.empty())
 id = state.id_prefix + "/" + id;

 auto path = state.base_path;
 if (!state.path_prefix.empty())
 path /= state.path_prefix;
 path /= definition.path;

 state.resources.push_back({ id, path });
 }
}

std::vector<Resource> read_config(std::istream& is, 
 const std::filesystem::path& base_path) {
 auto line_no = 0;
 try {
 auto state = State();
 state.base_path = base_path;

 auto line = std::string{ };
 while (is.good()) {
 std::getline(is, line);
 ++line_no;
 if (auto definition = parse_definition(line))
 apply_definition(state, *definition);
 }
 return std::move(state.resources);
 }
 catch (const std::exception& ex) {
 throw std::runtime_error(ex.what() +
 (" in line " + std::to_string(line_no)));
 }
}

std::string read_textfile(const std::filesystem::path& filename) {
 auto file = std::ifstream(filename, std::ios::in | std::ios::binary);
 if (!file.good())
 error("reading file '" + path_to_utf8(filename) + "' failed");
 return std::string(std::istreambuf_iterator<char>{ file }, { });
}

std::ofstream open_file_for_writing(const std::filesystem::path& filename) {
 auto error_code = std::error_code{ };
 std::filesystem::create_directories(filename.parent_path(), error_code);
 auto file = std::ofstream(filename, std::ios::out | std::ios::binary);
 if (!file.good())
 error("writing file '" + path_to_utf8(filename) + "' failed");
 return file;
}

void write_textfile(const std::filesystem::path& filename,
 std::string_view text) {
 auto file = open_file_for_writing(filename);
 file.write(text.data(), static_cast<std::streamsize>(text.size()));
}

bool update_textfile(const std::filesystem::path& filename,
 std::string_view text) {
 auto error_code = std::error_code{ };
 if (std::filesystem::exists(filename, error_code))
 if (const auto current = read_textfile(filename); current == text)
 return false;
 write_textfile(filename, text);
 return true;
}

size_t hexdump_file(std::ostream& os,
 const std::filesystem::path& filename,
 int word_size, bool little_endian, 
 const std::string& xor_key) {

 const auto max_per_line = 100 / (2 * word_size + 3);
 auto file = std::ifstream(filename, std::ios::in | std::ios::binary);
 if (!file.good())
 error("reading file '" + path_to_utf8(filename) + "' failed");
 auto total_size = size_t{ };
 char input[8];
 for (auto i = 0; ; ++i) {
 file.read(input, word_size);
 const auto read = file.gcount();
 if (read != word_size)
 std::memset(input + read, 0x00, word_size - read);
 if (read) {
 if (i > 0) {
 os.put(',');
 if (i % max_per_line == 0)
 os.put('\n');
 }

 if (!xor_key.empty())
 for (auto j = 0; j < word_size; ++j)
 input[j] ^= xor_key[(total_size + j) % xor_key.size()];

 os.write("0x", 2);
 for (auto j = 0; j < word_size; ++j) {
 const auto hex = "0123456789ABCDEF";
 const auto b = static_cast<unsigned char>(
 input[little_endian ? word_size - j - 1 : j]);
 os.put(hex[b / 16]);
 os.put(hex[b % 16]);
 }
 total_size += read;
 }
 if (read != word_size)
 break;
 }
 return total_size;
}

template<typename F>
void for_each_identifier(const std::string& string, F&& function) {
 const auto end = string.data() + string.size();
 for (auto it = string.data(), begin = it; ; ++it)
 if (it == end || *it == '/') {
 const auto ident = std::string_view(begin, std::distance(begin, it));
 const auto last = (it == end);
 function(ident, last);
 if (last)
 break;
 begin = it + 1;
 }
}

void generate_output(std::ostream& os, const Settings& settings,
 const std::vector<Resource>& resources, bool is_header) {

 auto qualified_resource_type =
 (!settings.resource_type.empty() ? settings.resource_type :
 "std::pair<const " + settings.data_type + "*, size_t>");
 auto current_namespace = std::vector<std::string_view>();
 auto resource_type_parts = std::vector<std::string_view>();
 auto resource_type = std::string_view();
 auto resource_by_path = std::map<std::filesystem::path, std::string_view>();

 // depending on current namespace make resource_type point
 // to fully qualified type name or last part only
 const auto qualify_resource_type = [&]() {
 resource_type = qualified_resource_type;
 if (resource_type_parts.size() > 1 &&
 current_namespace.size() >= resource_type_parts.size() - 1 &&
 std::equal(resource_type_parts.begin(),
 std::prev(resource_type_parts.end()),
 current_namespace.begin()))
 resource_type = resource_type_parts.back();
 };
 const auto write_indent = [&]() {
 for (auto i = size_t{ }; i < 2 * current_namespace.size(); ++i)
 os.put(' ');
 };
 const auto open_namespace = [&](std::string_view name) {
 write_indent();
 os << "namespace " << name << " {\n";
 current_namespace.push_back(name);
 qualify_resource_type();
 };
 const auto close_namespace = [&](std::string_view name) {
 current_namespace.pop_back();
 write_indent();
 os << "} // namespace " << name << "\n";
 };
 const auto close_namespaces = [&](size_t level) {
 if (current_namespace.size() <= level)
 return false;
 while (current_namespace.size() > level)
 close_namespace(current_namespace.back());
 return true;
 };
 const auto write_header = [&](std::string_view name) {
 write_indent();
 os << "extern const " << resource_type << " " << name << ";\n";
 };
 const auto write_output = [&](std::string_view name,
 const std::filesystem::path& path) {
 write_indent();
 os << "const "
 << (settings.little_endian.has_value() ? "uint64_t " : "uint8_t ")
 << name << "_data_[] {\n";
 const auto data_size = hexdump_file(os, path,
 (settings.little_endian.has_value() ? 8 : 1),
 settings.little_endian.value_or(true),
 settings.xor_key);
 os << "\n";
 write_indent();
 os << "};\n";
 write_indent();
 os << "const " << resource_type << " " << name
 << "{ reinterpret_cast<const " + settings.data_type + "*>("
 << name << "_data_), " << data_size << " };\n";
 };
 const auto write_duplicate = [&](std::string_view name, std::string_view first) {
 write_indent();
 os << "const " << resource_type << " " << name << " = " << first << ";\n";
 };

 if (is_header)
 os << "#pragma once\n";
 os << "\n";
 os << "// automatically generated by res2cpp";
 // ensure that all settings affect header, which invalidates output
 if (settings.little_endian.has_value())
 os << (settings.little_endian.value() ? " [LE]" : " [BE]");
 os << "\n";
 os << "// https://github.com/houmain/res2cpp\n\n";

 if (!is_header) {
 os << "#include \"" << path_to_utf8(settings.header_file) << "\"\n";
 os << "#include <cstdint>\n";
 }
 else if (settings.includes.size() == 1 &&
 settings.includes.front().front() != '<') {
 // a single local include
 os << "#include \"" << settings.includes.front() << "\"\n";
 }
 else {
 os << "#include <cstddef>\n";
 os << "#include <utility>\n";
 for (const auto& include : settings.includes)
 os << "#include " << include << "\n";
 }
 os << "\n";

 // declare type alias
 const auto resource_alias_id =
 replace_all(settings.resource_alias, "::", "/");
 if (!settings.resource_alias.empty()) {
 if (is_header)
 for_each_identifier(resource_alias_id,
 [&](std::string_view ident, bool last) {
 if (last) {
 write_indent();
 os << "using " << ident << " = " << resource_type << ";\n\n";
 }
 else {
 open_namespace(ident);
 }
 });

 qualified_resource_type = settings.resource_alias;
 resource_type = qualified_resource_type;
 }

 const auto resource_type_ident =
 replace_all(qualified_resource_type, "::", "/");
 for_each_identifier(resource_type_ident,
 [&](std::string_view ident, bool last) {
 resource_type_parts.push_back(ident);
 });

 for (const auto& [id, path] : resources) {
 auto level = size_t{ };
 for_each_identifier(id, [&](std::string_view ident, bool last) {
 if (last) {
 close_namespaces(level);
 if (is_header) {
 write_header(ident);
 }
 else if (const auto it = resource_by_path.find(path); 
 it != resource_by_path.end()) {
 write_duplicate(ident, replace_all(std::string(it->second), "/", "::"));
 }
 else {
 write_output(ident, path);
 resource_by_path[path] = id;
 }
 }
 else if (level >= current_namespace.size() ||
 current_namespace[level] != ident) {
 if (close_namespaces(level))
 os << "\n";
 open_namespace(ident);
 }
 ++level;
 });
 }
 close_namespaces(0);
}

std::optional<std::filesystem::file_time_type> get_last_write_time(
 const std::filesystem::path& filename) {
 auto error_code = std::error_code{ };
 const auto time = std::filesystem::last_write_time(filename, error_code);
 return (error_code ? std::nullopt : std::make_optional(time));
}

bool input_files_modified(const Settings& settings,
 const std::vector<Resource>& resources) {
 const auto config_time = get_last_write_time(settings.config_file);
 const auto header_time = get_last_write_time(settings.header_file);
 const auto source_time = get_last_write_time(settings.source_file);
 if (!header_time || config_time > header_time ||
 !source_time || config_time > source_time ||
 header_time > source_time)
 return true;

 for (const auto& [id, path] : resources) {
 const auto resource_time = get_last_write_time(path);
 if (!resource_time || resource_time > source_time)
 return true;
 }
 return false;
}

int main(int argc, const char* argv[]) try {
 auto settings = Settings();
 if (!interpret_commandline(settings, argc, argv)) {
 print_help_message();
 return 1;
 }

 auto resources = [&]() {
 if (settings.config_file.empty())
 return read_config(std::cin, std::filesystem::current_path());
 
 auto is = std::ifstream(settings.config_file);
 if (!is.good())
 error("opening configuration '" + 
 path_to_utf8(settings.config_file) + "' failed");
 return read_config(is, settings.config_file.parent_path());
 }();

 std::sort(begin(resources), end(resources));
 auto it = std::adjacent_find(begin(resources), end(resources),
 [](const Resource& a, const Resource& b) { return a.id == b.id; });
 if (it != end(resources))
 error("duplicate id '" + it->id + "'");

 // update header
 auto ss = std::ostringstream();
 generate_output(ss, settings, resources, true);
 update_textfile(settings.header_file, ss.str());

 // write source
 if (input_files_modified(settings, resources)) {
 auto os = open_file_for_writing(settings.source_file);
 generate_output(os, settings, resources, false);
 }
 return EXIT_SUCCESS;
}
catch (const std::exception& ex) {
 std::cerr << "ERROR: " << ex.what() << std::endl;
 return EXIT_FAILURE;
}