RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 07:57:47 +00:00
Code Issues Activity Actions

Meta: Refactor the IPC-compiler and port it to LibMain

Browse source 
This does a few things in total:
* Ports the IPC-compiler to LibMain
* Extract some compiler steps into separate functions
* Minify some appends to use appendln (or appendff in the case of
  StringBuilder)

This reduces the clang-tidies maximum cognitive-complexity score for
this file from 325 to under 100.
This commit is contained in:
Hendiadyoin1 2022-02-22 19:24:30 +01:00 • committed by Andreas Kling
parent 50b6e74d33
commit bd6927ecab
2 changed files with 428 additions and 478 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Meta/Lagom/Tools/CodeGenerators/IPCCompiler/CMakeLists.txt
View file

@ -2,4 +2,4 @@ set(SOURCES
main.cpp main.cpp
) )
lagom_tool(IPCCompiler) lagom_tool(IPCCompiler LIBS LagomMain)

478
Meta/Lagom/Tools/CodeGenerators/IPCCompiler/main.cpp
View file

@ -11,6 +11,7 @@
#include <AK/SourceGenerator.h> #include <AK/SourceGenerator.h>
#include <AK/StringBuilder.h> #include <AK/StringBuilder.h>
#include <LibCore/File.h> #include <LibCore/File.h>
#include <LibMain/Main.h>
#include <ctype.h> #include <ctype.h>
#include <stdio.h> #include <stdio.h>
@ -65,7 +66,7 @@ static bool is_primitive_type(String const& type)
return type.is_one_of("u8", "i8", "u16", "i16", "u32", "i32", "u64", "i64", "bool", "double", "float", "int", "unsigned", "unsigned int"); return type.is_one_of("u8", "i8", "u16", "i16", "u32", "i32", "u64", "i64", "bool", "double", "float", "int", "unsigned", "unsigned int");
} }
static String message_name(String const& endpoint, String& message, bool is_response) static String message_name(String const& endpoint, String const& message, bool is_response)
{ {
StringBuilder builder; StringBuilder builder;
builder.append("Messages::"); builder.append("Messages::");
@ -77,32 +78,20 @@ static String message_name(String const& endpoint, String& message, bool is_resp
return builder.to_string(); return builder.to_string();
} }
int main(int argc, char** argv) Vector<Endpoint> parse(ByteBuffer const& file_contents)
{ {
if (argc != 2) {
outln("usage: {} <IPC endpoint definition file>", argv[0]);
return 0;
}
auto file = Core::File::construct(argv[1]);
if (!file->open(Core::OpenMode::ReadOnly)) {
warnln("Error: Cannot open {}: {}", argv[1], file->error_string());
return 1;
}
auto file_contents = file->read_all();
GenericLexer lexer(file_contents); GenericLexer lexer(file_contents);
Vector<Endpoint> endpoints; Vector<Endpoint> endpoints;
auto assert_specific = [&](char ch) { auto assert_specific = [&lexer](char ch) {
if (lexer.peek() != ch) if (lexer.peek() != ch)
warnln("assert_specific: wanted '{}', but got '{}' at index {}", ch, lexer.peek(), lexer.tell()); warnln("assert_specific: wanted '{}', but got '{}' at index {}", ch, lexer.peek(), lexer.tell());
bool saw_expected = lexer.consume_specific(ch); bool saw_expected = lexer.consume_specific(ch);
VERIFY(saw_expected); VERIFY(saw_expected);
}; };
auto consume_whitespace = [&] { auto consume_whitespace = [&lexer] {
lexer.ignore_while([](char ch) { return isspace(ch); }); lexer.ignore_while([](char ch) { return isspace(ch); });
if (lexer.peek() == '/' && lexer.peek(1) == '/') if (lexer.peek() == '/' && lexer.peek(1) == '/')
lexer.ignore_until([](char ch) { return ch == '\n'; }); lexer.ignore_until([](char ch) { return ch == '\n'; });
@ -239,79 +228,35 @@ int main(int argc, char** argv)
while (lexer.tell() < file_contents.size()) while (lexer.tell() < file_contents.size())
parse_endpoint(); parse_endpoint();
StringBuilder builder; return endpoints;
SourceGenerator generator { builder };
generator.append("#pragma once\n");
// This must occur before LibIPC/Decoder.h
for (auto& endpoint : endpoints) {
for (auto& include : endpoint.includes) {
generator.append(include);
generator.append("\n");
}
} }
generator.append(R"~~~(#include <AK/MemoryStream.h> HashMap<String, int> build_message_ids_for_endpoint(SourceGenerator generator, Endpoint const& endpoint)
#include <AK/OwnPtr.h> {
#include <AK/Result.h>
#include <AK/Utf8View.h>
#include <LibIPC/Connection.h>
#include <LibIPC/Decoder.h>
#include <LibIPC/Dictionary.h>
#include <LibIPC/Encoder.h>
#include <LibIPC/File.h>
#include <LibIPC/Message.h>
#include <LibIPC/Stub.h>
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#endif
)~~~");
for (auto& endpoint : endpoints) {
auto endpoint_generator = generator.fork();
endpoint_generator.set("endpoint.name", endpoint.name);
endpoint_generator.set("endpoint.magic", String::number(endpoint.magic));
endpoint_generator.append(R"~~~(
namespace Messages::@endpoint.name@ {
)~~~");
HashMap<String, int> message_ids; HashMap<String, int> message_ids;
endpoint_generator.append(R"~~~( generator.appendln("\nenum class MessageID : i32 {");
enum class MessageID : i32 { for (auto const& message : endpoint.messages) {
)~~~");
for (auto& message : endpoint.messages) {
auto message_generator = endpoint_generator.fork();
message_ids.set(message.name, message_ids.size() + 1); message_ids.set(message.name, message_ids.size() + 1);
message_generator.set("message.name", message.name); generator.set("message.pascal_name", pascal_case(message.name));
message_generator.set("message.pascal_name", pascal_case(message.name)); generator.set("message.id", String::number(message_ids.size()));
message_generator.set("message.id", String::number(message_ids.size()));
message_generator.append(R"~~~( generator.appendln(" @message.pascal_name@ = @message.id@,");
@message.pascal_name@ = @message.id@,
)~~~");
if (message.is_synchronous) { if (message.is_synchronous) {
message_ids.set(message.response_name(), message_ids.size() + 1); message_ids.set(message.response_name(), message_ids.size() + 1);
message_generator.set("message.name", message.response_name()); generator.set("message.pascal_name", pascal_case(message.response_name()));
message_generator.set("message.pascal_name", pascal_case(message.response_name())); generator.set("message.id", String::number(message_ids.size()));
message_generator.set("message.id", String::number(message_ids.size()));
message_generator.append(R"~~~( generator.appendln(" @message.pascal_name@ = @message.id@,");
@message.pascal_name@ = @message.id@,
)~~~");
} }
} }
endpoint_generator.append(R"~~~( generator.appendln("};");
}; return message_ids;
)~~~"); }
auto constructor_for_message = [&](const String& name, const Vector<Parameter>& parameters) { String constructor_for_message(String const& name, Vector<Parameter> const& parameters)
{
StringBuilder builder; StringBuilder builder;
builder.append(name); builder.append(name);
@ -319,50 +264,41 @@ enum class MessageID : i32 {
builder.append("() {}"); builder.append("() {}");
return builder.to_string(); return builder.to_string();
} }
builder.append('('); builder.append('(');
for (size_t i = 0; i < parameters.size(); ++i) { for (size_t i = 0; i < parameters.size(); ++i) {
auto& parameter = parameters[i]; auto const& parameter = parameters[i];
builder.append(parameter.type); builder.appendff("{} {}", parameter.type, parameter.name);
builder.append(" ");
builder.append(parameter.name);
if (i != parameters.size() - 1) if (i != parameters.size() - 1)
builder.append(", "); builder.append(", ");
} }
builder.append(") : "); builder.append(") : ");
for (size_t i = 0; i < parameters.size(); ++i) { for (size_t i = 0; i < parameters.size(); ++i) {
auto& parameter = parameters[i]; auto const& parameter = parameters[i];
builder.append("m_"); builder.appendff("m_{}(move({}))", parameter.name, parameter.name);
builder.append(parameter.name);
builder.append("(move(");
builder.append(parameter.name);
builder.append("))");
if (i != parameters.size() - 1) if (i != parameters.size() - 1)
builder.append(", "); builder.append(", ");
} }
builder.append(" {}"); builder.append(" {}");
return builder.to_string(); return builder.to_string();
}; }
auto do_message = [&](const String& name, const Vector<Parameter>& parameters, const String& response_type = {}) { void do_message(SourceGenerator message_generator, const String& name, const Vector<Parameter>& parameters, const String& response_type = {})
auto message_generator = endpoint_generator.fork(); {
auto pascal_name = pascal_case(name); auto pascal_name = pascal_case(name);
message_generator.set("message.name", name); message_generator.set("message.name", name);
message_generator.set("message.pascal_name", pascal_name); message_generator.set("message.pascal_name", pascal_name);
message_generator.set("message.response_type", response_type); message_generator.set("message.response_type", response_type);
message_generator.set("message.constructor", constructor_for_message(pascal_name, parameters)); message_generator.set("message.constructor", constructor_for_message(pascal_name, parameters));
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
class @message.pascal_name@ final : public IPC::Message { class @message.pascal_name@ final : public IPC::Message {
public: public:)~~~");
)~~~");
if (!response_type.is_null()) if (!response_type.is_null())
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
typedef class @message.response_type@ ResponseType; typedef class @message.response_type@ ResponseType;)~~~");
)~~~");
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
@message.pascal_name@(decltype(nullptr)) : m_ipc_message_valid(false) { } @message.pascal_name@(decltype(nullptr)) : m_ipc_message_valid(false) { }
@message.pascal_name@(@message.pascal_name@ const&) = default; @message.pascal_name@(@message.pascal_name@ const&) = default;
@message.pascal_name@(@message.pascal_name@&&) = default; @message.pascal_name@(@message.pascal_name@&&) = default;
@ -377,10 +313,9 @@ public:
static OwnPtr<@message.pascal_name@> decode(InputMemoryStream& stream, Core::Stream::LocalSocket& socket) static OwnPtr<@message.pascal_name@> decode(InputMemoryStream& stream, Core::Stream::LocalSocket& socket)
{ {
IPC::Decoder decoder { stream, socket }; IPC::Decoder decoder { stream, socket };)~~~");
)~~~");
for (auto& parameter : parameters) { for (auto const& parameter : parameters) {
auto parameter_generator = message_generator.fork(); auto parameter_generator = message_generator.fork();
parameter_generator.set("parameter.type", parameter.type); parameter_generator.set("parameter.type", parameter.type);
@ -391,38 +326,33 @@ public:
else else
parameter_generator.set("parameter.initial_value", "{}"); parameter_generator.set("parameter.initial_value", "{}");
parameter_generator.append(R"~~~( parameter_generator.appendln(R"~~~(
@parameter.type@ @parameter.name@ = @parameter.initial_value@; @parameter.type@ @parameter.name@ = @parameter.initial_value@;
if (decoder.decode(@parameter.name@).is_error()) if (decoder.decode(@parameter.name@).is_error())
return {}; return {};)~~~");
)~~~");
if (parameter.attributes.contains_slow("UTF8")) { if (parameter.attributes.contains_slow("UTF8")) {
parameter_generator.append(R"~~~( parameter_generator.appendln(R"~~~(
if (!Utf8View(@parameter.name@).validate()) if (!Utf8View(@parameter.name@).validate())
return {}; return {};)~~~");
)~~~");
} }
} }
StringBuilder builder; StringBuilder builder;
for (size_t i = 0; i < parameters.size(); ++i) { for (size_t i = 0; i < parameters.size(); ++i) {
auto& parameter = parameters[i]; auto const& parameter = parameters[i];
builder.append("move("); builder.appendff("move({})", parameter.name);
builder.append(parameter.name);
builder.append(")");
if (i != parameters.size() - 1) if (i != parameters.size() - 1)
builder.append(", "); builder.append(", ");
} }
message_generator.set("message.constructor_call_parameters", builder.build()); message_generator.set("message.constructor_call_parameters", builder.build());
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
return make<@message.pascal_name@>(@message.constructor_call_parameters@); return make<@message.pascal_name@>(@message.constructor_call_parameters@);
} })~~~");
)~~~");
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
virtual bool valid() const override { return m_ipc_message_valid; } virtual bool valid() const override { return m_ipc_message_valid; }
virtual IPC::MessageBuffer encode() const override virtual IPC::MessageBuffer encode() const override
@ -432,79 +362,46 @@ public:
IPC::MessageBuffer buffer; IPC::MessageBuffer buffer;
IPC::Encoder stream(buffer); IPC::Encoder stream(buffer);
stream << endpoint_magic(); stream << endpoint_magic();
stream << (int)MessageID::@message.pascal_name@; stream << (int)MessageID::@message.pascal_name@;)~~~");
)~~~");
for (auto& parameter : parameters) { for (auto const& parameter : parameters) {
auto parameter_generator = message_generator.fork(); auto parameter_generator = message_generator.fork();
parameter_generator.set("parameter.name", parameter.name); parameter_generator.set("parameter.name", parameter.name);
parameter_generator.append(R"~~~( parameter_generator.appendln(R"~~~(
stream << m_@parameter.name@; stream << m_@parameter.name@;)~~~");
)~~~");
} }
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
return buffer; return buffer;
} })~~~");
)~~~");
for (auto& parameter : parameters) { for (auto const& parameter : parameters) {
auto parameter_generator = message_generator.fork(); auto parameter_generator = message_generator.fork();
parameter_generator.set("parameter.type", parameter.type); parameter_generator.set("parameter.type", parameter.type);
parameter_generator.set("parameter.name", parameter.name); parameter_generator.set("parameter.name", parameter.name);
parameter_generator.append(R"~~~( parameter_generator.appendln(R"~~~(
const @parameter.type@& @parameter.name@() const { return m_@parameter.name@; } const @parameter.type@& @parameter.name@() const { return m_@parameter.name@; }
@parameter.type@ take_@parameter.name@() { return move(m_@parameter.name@); } @parameter.type@ take_@parameter.name@() { return move(m_@parameter.name@); })~~~");
)~~~");
} }
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
private: private:
bool m_ipc_message_valid { true }; bool m_ipc_message_valid { true };)~~~");
)~~~");
for (auto& parameter : parameters) { for (auto const& parameter : parameters) {
auto parameter_generator = message_generator.fork(); auto parameter_generator = message_generator.fork();
parameter_generator.set("parameter.type", parameter.type); parameter_generator.set("parameter.type", parameter.type);
parameter_generator.set("parameter.name", parameter.name); parameter_generator.set("parameter.name", parameter.name);
parameter_generator.append(R"~~~( parameter_generator.appendln(R"~~~(
@parameter.type@ m_@parameter.name@ {}; @parameter.type@ m_@parameter.name@ {};)~~~");
)~~~");
} }
message_generator.append(R"~~~( message_generator.appendln("\n};");
};
)~~~");
};
for (auto& message : endpoint.messages) {
String response_name;
if (message.is_synchronous) {
response_name = message.response_name();
do_message(response_name, message.outputs);
}
do_message(message.name, message.inputs, response_name);
} }
endpoint_generator.append(R"~~~( void do_message_for_proxy(SourceGenerator message_generator, Endpoint const& endpoint, Message const& message)
} // namespace Messages::@endpoint.name@ {
)~~~");
endpoint_generator.append(R"~~~(
template<typename LocalEndpoint, typename PeerEndpoint>
class @endpoint.name@Proxy {
public:
// Used to disambiguate the constructor call.
struct Tag { };
@endpoint.name@Proxy(IPC::Connection<LocalEndpoint, PeerEndpoint>& connection, Tag)
: m_connection(connection)
{ }
)~~~");
for (auto& message : endpoint.messages) {
auto message_generator = endpoint_generator.fork();
auto do_implement_proxy = [&](String const& name, Vector<Parameter> const& parameters, bool is_synchronous, bool is_try) { auto do_implement_proxy = [&](String const& name, Vector<Parameter> const& parameters, bool is_synchronous, bool is_try) {
String return_type = "void"; String return_type = "void";
if (is_synchronous) { if (is_synchronous) {
@ -514,13 +411,9 @@ public:
return_type = message_name(endpoint.name, message.name, true); return_type = message_name(endpoint.name, message.name, true);
} }
String inner_return_type = return_type; String inner_return_type = return_type;
if (is_try) { if (is_try)
StringBuilder builder; return_type = String::formatted("IPC::IPCErrorOr<{}>", return_type);
builder.append("Result<");
builder.append(return_type);
builder.append(", IPC::ErrorCode>");
return_type = builder.to_string();
}
message_generator.set("message.name", message.name); message_generator.set("message.name", message.name);
message_generator.set("message.pascal_name", pascal_case(message.name)); message_generator.set("message.pascal_name", pascal_case(message.name));
message_generator.set("message.complex_return_type", return_type); message_generator.set("message.complex_return_type", return_type);
@ -528,11 +421,11 @@ public:
message_generator.set("try_prefix_maybe", is_try ? "try_" : ""); message_generator.set("try_prefix_maybe", is_try ? "try_" : "");
message_generator.set("handler_name", name); message_generator.set("handler_name", name);
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
@message.complex_return_type@ @try_prefix_maybe@@async_prefix_maybe@@handler_name@()~~~"); @message.complex_return_type@ @try_prefix_maybe@@async_prefix_maybe@@handler_name@()~~~");
for (size_t i = 0; i < parameters.size(); ++i) { for (size_t i = 0; i < parameters.size(); ++i) {
auto& parameter = parameters[i]; auto const& parameter = parameters[i];
auto argument_generator = message_generator.fork(); auto argument_generator = message_generator.fork();
argument_generator.set("argument.type", parameter.type); argument_generator.set("argument.type", parameter.type);
argument_generator.set("argument.name", parameter.name); argument_generator.set("argument.name", parameter.name);
@ -565,7 +458,7 @@ public:
} }
for (size_t i = 0; i < parameters.size(); ++i) { for (size_t i = 0; i < parameters.size(); ++i) {
auto& parameter = parameters[i]; auto const& parameter = parameters[i];
auto argument_generator = message_generator.fork(); auto argument_generator = message_generator.fork();
argument_generator.set("argument.name", parameter.name); argument_generator.set("argument.name", parameter.name);
if (is_primitive_type(parameters[i].type)) if (is_primitive_type(parameters[i].type))
@ -592,25 +485,20 @@ public:
} else if (is_try) { } else if (is_try) {
message_generator.append(R"~~~(); message_generator.append(R"~~~();
if (!result) if (!result)
return IPC::ErrorCode::PeerDisconnected; return IPC::ErrorCode::PeerDisconnected;)~~~");
)~~~");
if (inner_return_type != "void") { if (inner_return_type != "void") {
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
return move(*result); return move(*result);)~~~");
)~~~");
} else { } else {
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
return { }; return { };)~~~");
)~~~");
} }
} else { } else {
message_generator.append(R"~~~( }); message_generator.appendln(" });");
)~~~");
} }
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
} })~~~");
)~~~");
}; };
do_implement_proxy(message.name, message.inputs, message.is_synchronous, false); do_implement_proxy(message.name, message.inputs, message.is_synchronous, false);
@ -620,13 +508,46 @@ public:
} }
} }
endpoint_generator.append(R"~~~( void build_endpoint(SourceGenerator generator, Endpoint const& endpoint)
{
generator.set("endpoint.name", endpoint.name);
generator.set("endpoint.magic", String::number(endpoint.magic));
generator.appendln("\nnamespace Messages::@endpoint.name@ {");
HashMap<String, int> message_ids = build_message_ids_for_endpoint(generator.fork(), endpoint);
for (auto const& message : endpoint.messages) {
String response_name;
if (message.is_synchronous) {
response_name = message.response_name();
do_message(generator.fork(), response_name, message.outputs);
}
do_message(generator.fork(), message.name, message.inputs, response_name);
}
generator.appendln(R"~~~(
} // namespace Messages::@endpoint.name@
template<typename LocalEndpoint, typename PeerEndpoint>
class @endpoint.name@Proxy {
public:
// Used to disambiguate the constructor call.
struct Tag { };
@endpoint.name@Proxy(IPC::Connection<LocalEndpoint, PeerEndpoint>& connection, Tag)
: m_connection(connection)
{ })~~~");
for (auto const& message : endpoint.messages)
do_message_for_proxy(generator.fork(), endpoint, message);
generator.appendln(R"~~~(
private: private:
IPC::Connection<LocalEndpoint, PeerEndpoint>& m_connection; IPC::Connection<LocalEndpoint, PeerEndpoint>& m_connection;
}; };)~~~");
)~~~");
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
template<typename LocalEndpoint, typename PeerEndpoint> template<typename LocalEndpoint, typename PeerEndpoint>
class @endpoint.name@Proxy; class @endpoint.name@Proxy;
class @endpoint.name@Stub; class @endpoint.name@Stub;
@ -644,57 +565,49 @@ public:
InputMemoryStream stream { buffer }; InputMemoryStream stream { buffer };
u32 message_endpoint_magic = 0; u32 message_endpoint_magic = 0;
stream >> message_endpoint_magic; stream >> message_endpoint_magic;
if (stream.handle_any_error()) { if (stream.handle_any_error()) {)~~~");
)~~~");
if constexpr (GENERATE_DEBUG) { if constexpr (GENERATE_DEBUG) {
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
dbgln("Failed to read message endpoint magic"); dbgln(\"Failed to read message endpoint magic\"))~~~");
)~~~");
} }
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
return {}; return {};
} }
if (message_endpoint_magic != @endpoint.magic@) { if (message_endpoint_magic != @endpoint.magic@) {)~~~");
)~~~");
if constexpr (GENERATE_DEBUG) { if constexpr (GENERATE_DEBUG) {
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
dbgln("@endpoint.name@: Endpoint magic number message_endpoint_magic != @endpoint.magic@, not my message! (the other endpoint may have handled it)"); dbgln(\"@endpoint.name@: Endpoint magic number message_endpoint_magic != @endpoint.magic@, not my message! (the other endpoint may have handled it)\"))~~~");
)~~~");
} }
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
return {}; return {};
} }
i32 message_id = 0; i32 message_id = 0;
stream >> message_id; stream >> message_id;
if (stream.handle_any_error()) { if (stream.handle_any_error()) {)~~~");
)~~~");
if constexpr (GENERATE_DEBUG) { if constexpr (GENERATE_DEBUG) {
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
dbgln("Failed to read message ID"); dbgln(\"Failed to read message ID\"))~~~");
)~~~");
} }
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
return {}; return {};
} }
OwnPtr<IPC::Message> message; OwnPtr<IPC::Message> message;
switch (message_id) { switch (message_id) {)~~~");
)~~~");
for (auto& message : endpoint.messages) { for (auto const& message : endpoint.messages) {
auto do_decode_message = [&](const String& name) { auto do_decode_message = [&](const String& name) {
auto message_generator = endpoint_generator.fork(); auto message_generator = generator.fork();
message_generator.set("message.name", name); message_generator.set("message.name", name);
message_generator.set("message.pascal_name", pascal_case(name)); message_generator.set("message.pascal_name", pascal_case(name));
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
case (int)Messages::@endpoint.name@::MessageID::@message.pascal_name@: case (int)Messages::@endpoint.name@::MessageID::@message.pascal_name@:
message = Messages::@endpoint.name@::@message.pascal_name@::decode(stream, socket); message = Messages::@endpoint.name@::@message.pascal_name@::decode(stream, socket);
break; break;)~~~");
)~~~");
}; };
do_decode_message(message.name); do_decode_message(message.name);
@ -702,26 +615,22 @@ public:
do_decode_message(message.response_name()); do_decode_message(message.response_name());
} }
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
default: default:)~~~");
)~~~");
if constexpr (GENERATE_DEBUG) { if constexpr (GENERATE_DEBUG) {
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
dbgln("Failed to decode @endpoint.name@.({})", message_id); dbgln(\"Failed to decode @endpoint.name@.({})\", message_id))~~~");
)~~~");
} }
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
return {}; return {};
} }
if (stream.handle_any_error()) { if (stream.handle_any_error()) {)~~~");
)~~~");
if constexpr (GENERATE_DEBUG) { if constexpr (GENERATE_DEBUG) {
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
dbgln("Failed to read the message"); dbgln(\"Failed to read the message\");)~~~");
)~~~");
} }
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
return {}; return {};
} }
@ -740,15 +649,14 @@ public:
virtual OwnPtr<IPC::MessageBuffer> handle(const IPC::Message& message) override virtual OwnPtr<IPC::MessageBuffer> handle(const IPC::Message& message) override
{ {
switch (message.message_id()) { switch (message.message_id()) {)~~~");
)~~~"); for (auto const& message : endpoint.messages) {
for (auto& message : endpoint.messages) {
auto do_handle_message = [&](String const& name, Vector<Parameter> const& parameters, bool returns_something) { auto do_handle_message = [&](String const& name, Vector<Parameter> const& parameters, bool returns_something) {
auto message_generator = endpoint_generator.fork(); auto message_generator = generator.fork();
StringBuilder argument_generator; StringBuilder argument_generator;
for (size_t i = 0; i < parameters.size(); ++i) { for (size_t i = 0; i < parameters.size(); ++i) {
auto& parameter = parameters[i]; auto const& parameter = parameters[i];
argument_generator.append("request."); argument_generator.append("request.");
argument_generator.append(parameter.name); argument_generator.append(parameter.name);
argument_generator.append("()"); argument_generator.append("()");
@ -760,48 +668,42 @@ public:
message_generator.set("message.response_type", pascal_case(message.response_name())); message_generator.set("message.response_type", pascal_case(message.response_name()));
message_generator.set("handler_name", name); message_generator.set("handler_name", name);
message_generator.set("arguments", argument_generator.to_string()); message_generator.set("arguments", argument_generator.to_string());
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
case (int)Messages::@endpoint.name@::MessageID::@message.pascal_name@: { case (int)Messages::@endpoint.name@::MessageID::@message.pascal_name@: {)~~~");
)~~~");
if (returns_something) { if (returns_something) {
if (message.outputs.is_empty()) { if (message.outputs.is_empty()) {
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
[[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.pascal_name@&>(message); [[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.pascal_name@&>(message);
@handler_name@(@arguments@); @handler_name@(@arguments@);
auto response = Messages::@endpoint.name@::@message.response_type@ { }; auto response = Messages::@endpoint.name@::@message.response_type@ { };
return make<IPC::MessageBuffer>(response.encode()); return make<IPC::MessageBuffer>(response.encode());)~~~");
)~~~");
} else { } else {
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
[[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.pascal_name@&>(message); [[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.pascal_name@&>(message);
auto response = @handler_name@(@arguments@); auto response = @handler_name@(@arguments@);
if (!response.valid()) if (!response.valid())
return {}; return {};
return make<IPC::MessageBuffer>(response.encode()); return make<IPC::MessageBuffer>(response.encode());)~~~");
)~~~");
} }
} else { } else {
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
[[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.pascal_name@&>(message); [[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.pascal_name@&>(message);
@handler_name@(@arguments@); @handler_name@(@arguments@);
return {}; return {};)~~~");
)~~~");
} }
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
} })~~~");
)~~~");
}; };
do_handle_message(message.name, message.inputs, message.is_synchronous); do_handle_message(message.name, message.inputs, message.is_synchronous);
} }
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
default: default:
return {}; return {};
} }
} })~~~");
)~~~");
for (auto& message : endpoint.messages) { for (auto const& message : endpoint.messages) {
auto message_generator = endpoint_generator.fork(); auto message_generator = generator.fork();
auto do_handle_message_decl = [&](String const& name, Vector<Parameter> const& parameters, bool is_response) { auto do_handle_message_decl = [&](String const& name, Vector<Parameter> const& parameters, bool is_response) {
String return_type = "void"; String return_type = "void";
@ -810,7 +712,7 @@ public:
message_generator.set("message.complex_return_type", return_type); message_generator.set("message.complex_return_type", return_type);
message_generator.set("handler_name", name); message_generator.set("handler_name", name);
message_generator.append(R"~~~( message_generator.appendln(R"~~~(
virtual @message.complex_return_type@ @handler_name@()~~~"); virtual @message.complex_return_type@ @handler_name@()~~~");
auto make_argument_type = [](String const& type) { auto make_argument_type = [](String const& type) {
@ -826,7 +728,7 @@ public:
}; };
for (size_t i = 0; i < parameters.size(); ++i) { for (size_t i = 0; i < parameters.size(); ++i) {
auto& parameter = parameters[i]; auto const& parameter = parameters[i];
auto argument_generator = message_generator.fork(); auto argument_generator = message_generator.fork();
argument_generator.set("argument.type", make_argument_type(parameter.type)); argument_generator.set("argument.type", make_argument_type(parameter.type));
argument_generator.set("argument.name", parameter.name); argument_generator.set("argument.name", parameter.name);
@ -836,28 +738,75 @@ public:
} }
if (is_response) { if (is_response) {
message_generator.append(R"~~~() { }; message_generator.append(") { };");
)~~~");
} else { } else {
message_generator.append(R"~~~() = 0; message_generator.appendln(") = 0;");
)~~~");
} }
}; };
do_handle_message_decl(message.name, message.inputs, false); do_handle_message_decl(message.name, message.inputs, false);
} }
endpoint_generator.append(R"~~~( generator.appendln(R"~~~(
private: private:
}; };
#ifdef __clang__ #ifdef __clang__
#pragma clang diagnostic pop #pragma clang diagnostic pop
#endif #endif)~~~");
)~~~");
} }
outln("{}", generator.as_string_view()); void build(StringBuilder& builder, Vector<Endpoint> const& endpoints)
{
SourceGenerator generator { builder };
generator.appendln("#pragma once");
// This must occur before LibIPC/Decoder.h
for (auto const& endpoint : endpoints) {
for (auto const& include : endpoint.includes) {
generator.appendln(include);
}
}
generator.appendln(R"~~~(#include <AK/MemoryStream.h>
#include <AK/OwnPtr.h>
#include <AK/Result.h>
#include <AK/Utf8View.h>
#include <LibIPC/Connection.h>
#include <LibIPC/Decoder.h>
#include <LibIPC/Dictionary.h>
#include <LibIPC/Encoder.h>
#include <LibIPC/File.h>
#include <LibIPC/Message.h>
#include <LibIPC/Stub.h>
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#endif)~~~");
for (auto const& endpoint : endpoints)
build_endpoint(generator.fork(), endpoint);
}
ErrorOr<int> serenity_main(Main::Arguments arguments)
{
if (arguments.argc != 2) {
outln("usage: {} <IPC endpoint definition file>", arguments.strings[0]);
return 1;
}
auto file = TRY(Core::File::open(arguments.strings[1], Core::OpenMode::ReadOnly));
auto file_contents = file->read_all();
auto endpoints = parse(file_contents);
StringBuilder builder;
build(builder, endpoints);
outln("{}", builder.string_view());
if constexpr (GENERATE_DEBUG) { if constexpr (GENERATE_DEBUG) {
for (auto& endpoint : endpoints) { for (auto& endpoint : endpoints) {
@ -880,4 +829,5 @@ private:
} }
} }
} }
return 0;
} }