472 lines
17 KiB
C++
472 lines
17 KiB
C++
#include <algorithm>
|
|
#include <cctype>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <optional>
|
|
#include <regex>
|
|
#include <sstream>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
|
|
enum class MetaCoreReflectedKind {
|
|
Struct,
|
|
Class,
|
|
Enum
|
|
};
|
|
|
|
struct MetaCoreReflectedField {
|
|
std::string Name{};
|
|
std::string PropertySpec{};
|
|
};
|
|
|
|
struct MetaCoreReflectedEnumValue {
|
|
std::string Name{};
|
|
};
|
|
|
|
struct MetaCoreReflectedType {
|
|
MetaCoreReflectedKind Kind = MetaCoreReflectedKind::Struct;
|
|
std::string Name{};
|
|
std::vector<MetaCoreReflectedField> Fields{};
|
|
std::vector<MetaCoreReflectedEnumValue> EnumValues{};
|
|
};
|
|
|
|
[[nodiscard]] std::string MetaCoreTrim(std::string value) {
|
|
auto isWhitespace = [](unsigned char character) {
|
|
return std::isspace(character) != 0;
|
|
};
|
|
|
|
while (!value.empty() && isWhitespace(static_cast<unsigned char>(value.front()))) {
|
|
value.erase(value.begin());
|
|
}
|
|
while (!value.empty() && isWhitespace(static_cast<unsigned char>(value.back()))) {
|
|
value.pop_back();
|
|
}
|
|
return value;
|
|
}
|
|
|
|
[[nodiscard]] std::string MetaCoreBuildIncludePath(const std::filesystem::path& path) {
|
|
const std::string full = path.generic_string();
|
|
constexpr std::string_view marker = "/Public/";
|
|
const std::size_t markerIndex = full.find(marker);
|
|
if (markerIndex == std::string::npos) {
|
|
return path.filename().generic_string();
|
|
}
|
|
return full.substr(markerIndex + marker.size());
|
|
}
|
|
|
|
[[nodiscard]] std::string MetaCoreExtractMacroArgument(std::string_view trimmed, std::string_view macroName) {
|
|
const std::size_t prefixLength = macroName.size();
|
|
if (trimmed.size() <= prefixLength || trimmed[prefixLength] != '(') {
|
|
return {};
|
|
}
|
|
|
|
const std::size_t closeIndex = trimmed.rfind(')');
|
|
if (closeIndex == std::string_view::npos || closeIndex <= prefixLength) {
|
|
return {};
|
|
}
|
|
|
|
return MetaCoreTrim(std::string(trimmed.substr(prefixLength + 1, closeIndex - prefixLength - 1)));
|
|
}
|
|
|
|
[[nodiscard]] std::string MetaCoreEscapeCppString(std::string_view value) {
|
|
std::string escaped;
|
|
escaped.reserve(value.size());
|
|
for (const char character : value) {
|
|
switch (character) {
|
|
case '\\': escaped += "\\\\"; break;
|
|
case '"': escaped += "\\\""; break;
|
|
case '\n': escaped += "\\n"; break;
|
|
case '\r': escaped += "\\r"; break;
|
|
case '\t': escaped += "\\t"; break;
|
|
default: escaped.push_back(character); break;
|
|
}
|
|
}
|
|
return escaped;
|
|
}
|
|
|
|
[[nodiscard]] std::string MetaCoreToLower(std::string value) {
|
|
std::transform(value.begin(), value.end(), value.begin(), [](unsigned char character) {
|
|
return static_cast<char>(std::tolower(character));
|
|
});
|
|
return value;
|
|
}
|
|
|
|
[[nodiscard]] std::string MetaCoreStripQuotes(std::string value) {
|
|
value = MetaCoreTrim(std::move(value));
|
|
if (value.size() >= 2 && value.front() == '"' && value.back() == '"') {
|
|
return value.substr(1, value.size() - 2);
|
|
}
|
|
return value;
|
|
}
|
|
|
|
[[nodiscard]] bool MetaCoreIsTruthyMetadataValue(std::string value) {
|
|
value = MetaCoreToLower(MetaCoreTrim(std::move(value)));
|
|
return value.empty() || value == "true" || value == "1" || value == "yes";
|
|
}
|
|
|
|
[[nodiscard]] std::size_t MetaCoreFindUnquotedEquals(std::string_view value) {
|
|
bool inString = false;
|
|
bool escaping = false;
|
|
for (std::size_t index = 0; index < value.size(); ++index) {
|
|
const char character = value[index];
|
|
if (escaping) {
|
|
escaping = false;
|
|
continue;
|
|
}
|
|
if (character == '\\') {
|
|
escaping = inString;
|
|
continue;
|
|
}
|
|
if (character == '"') {
|
|
inString = !inString;
|
|
continue;
|
|
}
|
|
if (!inString && character == '=') {
|
|
return index;
|
|
}
|
|
}
|
|
return std::string_view::npos;
|
|
}
|
|
|
|
[[nodiscard]] std::vector<std::string> MetaCoreSplitPropertySpec(std::string_view spec) {
|
|
std::vector<std::string> tokens;
|
|
std::string token;
|
|
bool inString = false;
|
|
bool escaping = false;
|
|
int nestedDepth = 0;
|
|
|
|
for (const char character : spec) {
|
|
if (escaping) {
|
|
token.push_back(character);
|
|
escaping = false;
|
|
continue;
|
|
}
|
|
if (character == '\\') {
|
|
token.push_back(character);
|
|
escaping = inString;
|
|
continue;
|
|
}
|
|
if (character == '"') {
|
|
token.push_back(character);
|
|
inString = !inString;
|
|
continue;
|
|
}
|
|
if (!inString && (character == '(' || character == '[' || character == '{')) {
|
|
++nestedDepth;
|
|
} else if (!inString && (character == ')' || character == ']' || character == '}')) {
|
|
--nestedDepth;
|
|
}
|
|
if (!inString && nestedDepth == 0 && character == ',') {
|
|
tokens.push_back(MetaCoreTrim(token));
|
|
token.clear();
|
|
continue;
|
|
}
|
|
token.push_back(character);
|
|
}
|
|
|
|
if (!MetaCoreTrim(token).empty()) {
|
|
tokens.push_back(MetaCoreTrim(token));
|
|
}
|
|
return tokens;
|
|
}
|
|
|
|
[[nodiscard]] std::unordered_map<std::string, std::string> MetaCoreParsePropertySpec(std::string_view spec) {
|
|
std::unordered_map<std::string, std::string> metadata;
|
|
for (const std::string& token : MetaCoreSplitPropertySpec(spec)) {
|
|
const std::size_t equalsIndex = MetaCoreFindUnquotedEquals(token);
|
|
if (equalsIndex == std::string_view::npos) {
|
|
metadata.emplace(MetaCoreTrim(token), "true");
|
|
continue;
|
|
}
|
|
|
|
metadata.insert_or_assign(
|
|
MetaCoreTrim(token.substr(0, equalsIndex)),
|
|
MetaCoreTrim(token.substr(equalsIndex + 1))
|
|
);
|
|
}
|
|
return metadata;
|
|
}
|
|
|
|
[[nodiscard]] std::optional<MetaCoreReflectedEnumValue> MetaCoreParseEnumValue(std::string value) {
|
|
const std::size_t commentIndex = value.find("//");
|
|
if (commentIndex != std::string::npos) {
|
|
value = value.substr(0, commentIndex);
|
|
}
|
|
value = MetaCoreTrim(std::move(value));
|
|
if (value.empty() || value == "{" || value == "};") {
|
|
return std::nullopt;
|
|
}
|
|
if (!value.empty() && value.back() == ',') {
|
|
value.pop_back();
|
|
}
|
|
const std::size_t equalsIndex = MetaCoreFindUnquotedEquals(value);
|
|
if (equalsIndex != std::string::npos) {
|
|
value = value.substr(0, equalsIndex);
|
|
}
|
|
value = MetaCoreTrim(std::move(value));
|
|
if (value.empty()) {
|
|
return std::nullopt;
|
|
}
|
|
if (!std::regex_match(value, std::regex(R"([A-Za-z_]\w*)"))) {
|
|
return std::nullopt;
|
|
}
|
|
return MetaCoreReflectedEnumValue{value};
|
|
}
|
|
|
|
void MetaCoreEmitStringMetadataAssignment(
|
|
std::ostringstream& output,
|
|
const std::unordered_map<std::string, std::string>& metadata,
|
|
std::string_view metadataVariable,
|
|
std::string_view propertyName,
|
|
std::string_view fieldName
|
|
) {
|
|
const auto iterator = metadata.find(std::string(propertyName));
|
|
if (iterator == metadata.end()) {
|
|
return;
|
|
}
|
|
output << " " << metadataVariable << "." << fieldName << " = \""
|
|
<< MetaCoreEscapeCppString(MetaCoreStripQuotes(iterator->second)) << "\";\n";
|
|
}
|
|
|
|
void MetaCoreEmitOptionalDoubleMetadataAssignment(
|
|
std::ostringstream& output,
|
|
const std::unordered_map<std::string, std::string>& metadata,
|
|
std::string_view metadataVariable,
|
|
std::string_view propertyName,
|
|
std::string_view fieldName
|
|
) {
|
|
const auto iterator = metadata.find(std::string(propertyName));
|
|
if (iterator == metadata.end()) {
|
|
return;
|
|
}
|
|
output << " " << metadataVariable << "." << fieldName << " = "
|
|
<< MetaCoreStripQuotes(iterator->second) << ";\n";
|
|
}
|
|
|
|
void MetaCoreEmitBoolMetadataAssignment(
|
|
std::ostringstream& output,
|
|
const std::unordered_map<std::string, std::string>& metadata,
|
|
std::string_view metadataVariable,
|
|
std::string_view propertyName,
|
|
std::string_view fieldName
|
|
) {
|
|
const auto iterator = metadata.find(std::string(propertyName));
|
|
if (iterator == metadata.end()) {
|
|
return;
|
|
}
|
|
output << " " << metadataVariable << "." << fieldName << " = "
|
|
<< (MetaCoreIsTruthyMetadataValue(iterator->second) ? "true" : "false") << ";\n";
|
|
}
|
|
|
|
[[nodiscard]] std::vector<MetaCoreReflectedType> MetaCoreParseHeader(const std::filesystem::path& path) {
|
|
std::ifstream input(path);
|
|
if (!input.is_open()) {
|
|
throw std::runtime_error("Unable to open header: " + path.string());
|
|
}
|
|
|
|
const std::regex typeRegex(R"(^(struct|class|enum\s+class)\s+([A-Za-z_]\w*))");
|
|
const std::regex fieldRegex(R"(^(.+?)\s+([A-Za-z_]\w*)\s*(?:\{.*\}|=.*)?;$)");
|
|
|
|
std::vector<MetaCoreReflectedType> reflectedTypes;
|
|
std::optional<MetaCoreReflectedKind> pendingKind;
|
|
MetaCoreReflectedType* currentType = nullptr;
|
|
bool expectingField = false;
|
|
std::string pendingPropertySpec;
|
|
|
|
std::string line;
|
|
while (std::getline(input, line)) {
|
|
const std::string trimmed = MetaCoreTrim(line);
|
|
if (trimmed.empty() || trimmed.starts_with("//")) {
|
|
continue;
|
|
}
|
|
|
|
if (trimmed.starts_with("MC_STRUCT")) {
|
|
pendingKind = MetaCoreReflectedKind::Struct;
|
|
continue;
|
|
}
|
|
if (trimmed.starts_with("MC_CLASS")) {
|
|
pendingKind = MetaCoreReflectedKind::Class;
|
|
continue;
|
|
}
|
|
if (trimmed.starts_with("MC_ENUM")) {
|
|
pendingKind = MetaCoreReflectedKind::Enum;
|
|
continue;
|
|
}
|
|
if (trimmed.starts_with("MC_PROPERTY")) {
|
|
expectingField = true;
|
|
pendingPropertySpec = MetaCoreExtractMacroArgument(trimmed, "MC_PROPERTY");
|
|
continue;
|
|
}
|
|
if (trimmed.starts_with("MC_GENERATED_BODY")) {
|
|
continue;
|
|
}
|
|
|
|
if (pendingKind.has_value()) {
|
|
std::smatch match;
|
|
if (std::regex_search(trimmed, match, typeRegex)) {
|
|
reflectedTypes.push_back(MetaCoreReflectedType{
|
|
pendingKind.value(),
|
|
match[2].str(),
|
|
{},
|
|
{}
|
|
});
|
|
currentType = &reflectedTypes.back();
|
|
pendingKind.reset();
|
|
expectingField = false;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (currentType != nullptr && trimmed == "};") {
|
|
currentType = nullptr;
|
|
expectingField = false;
|
|
continue;
|
|
}
|
|
|
|
if (currentType != nullptr && currentType->Kind == MetaCoreReflectedKind::Enum) {
|
|
if (auto enumValue = MetaCoreParseEnumValue(trimmed); enumValue.has_value()) {
|
|
currentType->EnumValues.push_back(std::move(*enumValue));
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (currentType == nullptr || currentType->Kind == MetaCoreReflectedKind::Enum || !expectingField) {
|
|
continue;
|
|
}
|
|
|
|
std::smatch match;
|
|
if (!std::regex_search(trimmed, match, fieldRegex)) {
|
|
throw std::runtime_error("Unable to parse reflected field in " + path.string() + ": " + trimmed);
|
|
}
|
|
|
|
currentType->Fields.push_back(MetaCoreReflectedField{
|
|
match[2].str(),
|
|
pendingPropertySpec
|
|
});
|
|
expectingField = false;
|
|
pendingPropertySpec.clear();
|
|
}
|
|
|
|
return reflectedTypes;
|
|
}
|
|
|
|
[[nodiscard]] std::string MetaCoreBuildOutput(
|
|
const std::string& functionName,
|
|
const std::vector<std::filesystem::path>& headers
|
|
) {
|
|
std::vector<MetaCoreReflectedType> reflectedTypes;
|
|
for (const auto& header : headers) {
|
|
const auto parsed = MetaCoreParseHeader(header);
|
|
reflectedTypes.insert(reflectedTypes.end(), parsed.begin(), parsed.end());
|
|
}
|
|
|
|
std::ostringstream output;
|
|
output << "#include \"MetaCoreFoundation/MetaCoreGeneratedReflection.h\"\n";
|
|
output << "#include \"MetaCoreFoundation/MetaCoreReflection.h\"\n";
|
|
for (const auto& header : headers) {
|
|
output << "#include \"" << MetaCoreBuildIncludePath(header) << "\"\n";
|
|
}
|
|
output << "\nnamespace MetaCore {\n\n";
|
|
output << "void " << functionName << "(MetaCoreTypeRegistry& registry) {\n";
|
|
|
|
for (const auto& reflectedType : reflectedTypes) {
|
|
if (reflectedType.Kind == MetaCoreReflectedKind::Enum) {
|
|
output << " auto " << reflectedType.Name << "Builder = MetaCoreRegisterGeneratedEnum<"
|
|
<< reflectedType.Name << ">(registry, \"" << reflectedType.Name << "\");\n";
|
|
for (const auto& enumValue : reflectedType.EnumValues) {
|
|
output << " " << reflectedType.Name << "Builder.Value(\""
|
|
<< MetaCoreEscapeCppString(enumValue.Name) << "\", "
|
|
<< reflectedType.Name << "::" << enumValue.Name << ");\n";
|
|
}
|
|
continue;
|
|
}
|
|
|
|
output << " auto " << reflectedType.Name << "Builder = MetaCoreRegisterGeneratedStruct<"
|
|
<< reflectedType.Name << ">(registry, \"" << reflectedType.Name << "\");\n";
|
|
for (const auto& field : reflectedType.Fields) {
|
|
if (!field.PropertySpec.empty()) {
|
|
const std::string metadataVariable =
|
|
reflectedType.Name + field.Name + "EditorMetadata";
|
|
const auto metadata = MetaCoreParsePropertySpec(field.PropertySpec);
|
|
output << " MetaCoreFieldEditorMetadata " << metadataVariable << "{};\n";
|
|
output << " " << metadataVariable << ".RawSpec = \""
|
|
<< MetaCoreEscapeCppString(field.PropertySpec) << "\";\n";
|
|
MetaCoreEmitStringMetadataAssignment(output, metadata, metadataVariable, "DisplayName", "DisplayName");
|
|
MetaCoreEmitStringMetadataAssignment(output, metadata, metadataVariable, "Group", "Group");
|
|
MetaCoreEmitStringMetadataAssignment(output, metadata, metadataVariable, "Tooltip", "Tooltip");
|
|
MetaCoreEmitStringMetadataAssignment(output, metadata, metadataVariable, "ResourceType", "ResourceType");
|
|
MetaCoreEmitStringMetadataAssignment(output, metadata, metadataVariable, "Resource", "ResourceType");
|
|
MetaCoreEmitStringMetadataAssignment(output, metadata, metadataVariable, "DefaultValue", "DefaultValue");
|
|
MetaCoreEmitStringMetadataAssignment(output, metadata, metadataVariable, "Default", "DefaultValue");
|
|
MetaCoreEmitOptionalDoubleMetadataAssignment(output, metadata, metadataVariable, "Min", "Min");
|
|
MetaCoreEmitOptionalDoubleMetadataAssignment(output, metadata, metadataVariable, "Max", "Max");
|
|
MetaCoreEmitOptionalDoubleMetadataAssignment(output, metadata, metadataVariable, "Step", "Step");
|
|
MetaCoreEmitBoolMetadataAssignment(output, metadata, metadataVariable, "ReadOnly", "ReadOnly");
|
|
MetaCoreEmitBoolMetadataAssignment(output, metadata, metadataVariable, "Hidden", "Hidden");
|
|
MetaCoreEmitBoolMetadataAssignment(output, metadata, metadataVariable, "ResourceReference", "ResourceReference");
|
|
output << " " << reflectedType.Name << "Builder.Field<&" << reflectedType.Name << "::"
|
|
<< field.Name << ">(\"" << field.Name << "\", " << metadataVariable << ");\n";
|
|
continue;
|
|
}
|
|
|
|
output << " " << reflectedType.Name << "Builder.Field<&" << reflectedType.Name << "::"
|
|
<< field.Name << ">(\"" << field.Name << "\");\n";
|
|
}
|
|
}
|
|
|
|
output << "}\n\n} // namespace MetaCore\n";
|
|
return output.str();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main(int argc, char** argv) {
|
|
std::filesystem::path outputPath;
|
|
std::string functionName;
|
|
std::vector<std::filesystem::path> headers;
|
|
|
|
for (int index = 1; index < argc; ++index) {
|
|
const std::string_view argument(argv[index]);
|
|
if (argument == "--output" && index + 1 < argc) {
|
|
outputPath = argv[++index];
|
|
continue;
|
|
}
|
|
if (argument == "--function" && index + 1 < argc) {
|
|
functionName = argv[++index];
|
|
continue;
|
|
}
|
|
if (argument == "--module" && index + 1 < argc) {
|
|
++index;
|
|
continue;
|
|
}
|
|
|
|
headers.emplace_back(argv[index]);
|
|
}
|
|
|
|
if (outputPath.empty() || functionName.empty() || headers.empty()) {
|
|
std::cerr << "Usage: MetaCoreHeaderTool --output <file> --function <name> [--module <name>] <headers...>\n";
|
|
return 1;
|
|
}
|
|
|
|
try {
|
|
const std::string output = MetaCoreBuildOutput(functionName, headers);
|
|
std::ofstream file(outputPath, std::ios::trunc);
|
|
if (!file.is_open()) {
|
|
std::cerr << "Unable to open output file: " << outputPath << '\n';
|
|
return 1;
|
|
}
|
|
file << output;
|
|
} catch (const std::exception& exception) {
|
|
std::cerr << exception.what() << '\n';
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|