main.cpp 30 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Debug.h>
  7. #include <AK/Function.h>
  8. #include <AK/GenericLexer.h>
  9. #include <AK/HashMap.h>
  10. #include <AK/SourceGenerator.h>
  11. #include <AK/StringBuilder.h>
  12. #include <LibCore/Stream.h>
  13. #include <LibMain/Main.h>
  14. #include <ctype.h>
  15. #include <stdio.h>
  16. struct Parameter {
  17. Vector<DeprecatedString> attributes;
  18. DeprecatedString type;
  19. DeprecatedString name;
  20. };
  21. static DeprecatedString pascal_case(DeprecatedString const& identifier)
  22. {
  23. StringBuilder builder;
  24. bool was_new_word = true;
  25. for (auto ch : identifier) {
  26. if (ch == '_') {
  27. was_new_word = true;
  28. continue;
  29. }
  30. if (was_new_word) {
  31. builder.append(toupper(ch));
  32. was_new_word = false;
  33. } else
  34. builder.append(ch);
  35. }
  36. return builder.to_deprecated_string();
  37. }
  38. struct Message {
  39. DeprecatedString name;
  40. bool is_synchronous { false };
  41. Vector<Parameter> inputs;
  42. Vector<Parameter> outputs;
  43. DeprecatedString response_name() const
  44. {
  45. StringBuilder builder;
  46. builder.append(pascal_case(name));
  47. builder.append("Response"sv);
  48. return builder.to_deprecated_string();
  49. }
  50. };
  51. struct Endpoint {
  52. Vector<DeprecatedString> includes;
  53. DeprecatedString name;
  54. u32 magic;
  55. Vector<Message> messages;
  56. };
  57. static bool is_primitive_type(DeprecatedString const& type)
  58. {
  59. return type.is_one_of("u8", "i8", "u16", "i16", "u32", "i32", "u64", "i64", "size_t", "bool", "double", "float", "int", "unsigned", "unsigned int");
  60. }
  61. static bool is_simple_type(DeprecatedString const& type)
  62. {
  63. // Small types that it makes sense just to pass by value.
  64. return type.is_one_of("Gfx::Color", "Gfx::IntPoint", "Gfx::FloatPoint", "Gfx::IntSize", "Gfx::FloatSize");
  65. }
  66. static bool is_primitive_or_simple_type(DeprecatedString const& type)
  67. {
  68. return is_primitive_type(type) || is_simple_type(type);
  69. }
  70. static DeprecatedString message_name(DeprecatedString const& endpoint, DeprecatedString const& message, bool is_response)
  71. {
  72. StringBuilder builder;
  73. builder.append("Messages::"sv);
  74. builder.append(endpoint);
  75. builder.append("::"sv);
  76. builder.append(pascal_case(message));
  77. if (is_response)
  78. builder.append("Response"sv);
  79. return builder.to_deprecated_string();
  80. }
  81. Vector<Endpoint> parse(ByteBuffer const& file_contents)
  82. {
  83. GenericLexer lexer(file_contents);
  84. Vector<Endpoint> endpoints;
  85. auto assert_specific = [&lexer](char ch) {
  86. if (lexer.peek() != ch)
  87. warnln("assert_specific: wanted '{}', but got '{}' at index {}", ch, lexer.peek(), lexer.tell());
  88. bool saw_expected = lexer.consume_specific(ch);
  89. VERIFY(saw_expected);
  90. };
  91. auto consume_whitespace = [&lexer] {
  92. lexer.ignore_while([](char ch) { return isspace(ch); });
  93. if (lexer.peek() == '/' && lexer.peek(1) == '/')
  94. lexer.ignore_until([](char ch) { return ch == '\n'; });
  95. };
  96. auto parse_parameter = [&](Vector<Parameter>& storage) {
  97. for (;;) {
  98. Parameter parameter;
  99. if (lexer.is_eof()) {
  100. warnln("EOF when parsing parameter");
  101. VERIFY_NOT_REACHED();
  102. }
  103. consume_whitespace();
  104. if (lexer.peek() == ')')
  105. break;
  106. if (lexer.consume_specific('[')) {
  107. for (;;) {
  108. if (lexer.consume_specific(']')) {
  109. consume_whitespace();
  110. break;
  111. }
  112. if (lexer.consume_specific(',')) {
  113. consume_whitespace();
  114. }
  115. auto attribute = lexer.consume_until([](char ch) { return ch == ']' || ch == ','; });
  116. parameter.attributes.append(attribute);
  117. consume_whitespace();
  118. }
  119. }
  120. // FIXME: This is not entirely correct. Types can have spaces, for example `HashMap<int, DeprecatedString>`.
  121. // Maybe we should use LibCpp::Parser for parsing types.
  122. parameter.type = lexer.consume_until([](char ch) { return isspace(ch); });
  123. VERIFY(!lexer.is_eof());
  124. consume_whitespace();
  125. parameter.name = lexer.consume_until([](char ch) { return isspace(ch) || ch == ',' || ch == ')'; });
  126. consume_whitespace();
  127. storage.append(move(parameter));
  128. if (lexer.consume_specific(','))
  129. continue;
  130. if (lexer.peek() == ')')
  131. break;
  132. }
  133. };
  134. auto parse_parameters = [&](Vector<Parameter>& storage) {
  135. for (;;) {
  136. consume_whitespace();
  137. parse_parameter(storage);
  138. consume_whitespace();
  139. if (lexer.consume_specific(','))
  140. continue;
  141. if (lexer.peek() == ')')
  142. break;
  143. }
  144. };
  145. auto parse_message = [&] {
  146. Message message;
  147. consume_whitespace();
  148. message.name = lexer.consume_until([](char ch) { return isspace(ch) || ch == '('; });
  149. consume_whitespace();
  150. assert_specific('(');
  151. parse_parameters(message.inputs);
  152. assert_specific(')');
  153. consume_whitespace();
  154. assert_specific('=');
  155. auto type = lexer.consume();
  156. if (type == '>')
  157. message.is_synchronous = true;
  158. else if (type == '|')
  159. message.is_synchronous = false;
  160. else
  161. VERIFY_NOT_REACHED();
  162. consume_whitespace();
  163. if (message.is_synchronous) {
  164. assert_specific('(');
  165. parse_parameters(message.outputs);
  166. assert_specific(')');
  167. }
  168. consume_whitespace();
  169. endpoints.last().messages.append(move(message));
  170. };
  171. auto parse_messages = [&] {
  172. for (;;) {
  173. consume_whitespace();
  174. if (lexer.peek() == '}')
  175. break;
  176. parse_message();
  177. consume_whitespace();
  178. }
  179. };
  180. auto parse_include = [&] {
  181. DeprecatedString include;
  182. consume_whitespace();
  183. include = lexer.consume_while([](char ch) { return ch != '\n'; });
  184. consume_whitespace();
  185. endpoints.last().includes.append(move(include));
  186. };
  187. auto parse_includes = [&] {
  188. for (;;) {
  189. consume_whitespace();
  190. if (lexer.peek() != '#')
  191. break;
  192. parse_include();
  193. consume_whitespace();
  194. }
  195. };
  196. auto parse_endpoint = [&] {
  197. endpoints.empend();
  198. consume_whitespace();
  199. parse_includes();
  200. consume_whitespace();
  201. lexer.consume_specific("endpoint");
  202. consume_whitespace();
  203. endpoints.last().name = lexer.consume_while([](char ch) { return !isspace(ch); });
  204. endpoints.last().magic = Traits<DeprecatedString>::hash(endpoints.last().name);
  205. consume_whitespace();
  206. assert_specific('{');
  207. parse_messages();
  208. assert_specific('}');
  209. consume_whitespace();
  210. };
  211. while (lexer.tell() < file_contents.size())
  212. parse_endpoint();
  213. return endpoints;
  214. }
  215. HashMap<DeprecatedString, int> build_message_ids_for_endpoint(SourceGenerator generator, Endpoint const& endpoint)
  216. {
  217. HashMap<DeprecatedString, int> message_ids;
  218. generator.appendln("\nenum class MessageID : i32 {");
  219. for (auto const& message : endpoint.messages) {
  220. message_ids.set(message.name, message_ids.size() + 1);
  221. generator.set("message.pascal_name", pascal_case(message.name));
  222. generator.set("message.id", DeprecatedString::number(message_ids.size()));
  223. generator.appendln(" @message.pascal_name@ = @message.id@,");
  224. if (message.is_synchronous) {
  225. message_ids.set(message.response_name(), message_ids.size() + 1);
  226. generator.set("message.pascal_name", pascal_case(message.response_name()));
  227. generator.set("message.id", DeprecatedString::number(message_ids.size()));
  228. generator.appendln(" @message.pascal_name@ = @message.id@,");
  229. }
  230. }
  231. generator.appendln("};");
  232. return message_ids;
  233. }
  234. DeprecatedString constructor_for_message(DeprecatedString const& name, Vector<Parameter> const& parameters)
  235. {
  236. StringBuilder builder;
  237. builder.append(name);
  238. if (parameters.is_empty()) {
  239. builder.append("() {}"sv);
  240. return builder.to_deprecated_string();
  241. }
  242. builder.append('(');
  243. for (size_t i = 0; i < parameters.size(); ++i) {
  244. auto const& parameter = parameters[i];
  245. builder.appendff("{} {}", parameter.type, parameter.name);
  246. if (i != parameters.size() - 1)
  247. builder.append(", "sv);
  248. }
  249. builder.append(") : "sv);
  250. for (size_t i = 0; i < parameters.size(); ++i) {
  251. auto const& parameter = parameters[i];
  252. builder.appendff("m_{}(move({}))", parameter.name, parameter.name);
  253. if (i != parameters.size() - 1)
  254. builder.append(", "sv);
  255. }
  256. builder.append(" {}"sv);
  257. return builder.to_deprecated_string();
  258. }
  259. static void append_handle_stream_error(SourceGenerator& generator, StringView error_message)
  260. {
  261. if constexpr (GENERATE_DEBUG) {
  262. generator.set("error_message"sv, error_message);
  263. generator.append(R"~~~(
  264. if (stream.handle_any_error()) {
  265. dbgln("@error_message@");
  266. return Error::from_string_literal("@error_message@");
  267. })~~~");
  268. } else {
  269. generator.append(R"~~~(
  270. TRY(stream.try_handle_any_error());)~~~");
  271. }
  272. }
  273. void do_message(SourceGenerator message_generator, DeprecatedString const& name, Vector<Parameter> const& parameters, DeprecatedString const& response_type = {})
  274. {
  275. auto pascal_name = pascal_case(name);
  276. message_generator.set("message.name", name);
  277. message_generator.set("message.pascal_name", pascal_name);
  278. message_generator.set("message.response_type", response_type);
  279. message_generator.set("message.constructor", constructor_for_message(pascal_name, parameters));
  280. message_generator.appendln(R"~~~(
  281. class @message.pascal_name@ final : public IPC::Message {
  282. public:)~~~");
  283. if (!response_type.is_null())
  284. message_generator.appendln(R"~~~(
  285. typedef class @message.response_type@ ResponseType;)~~~");
  286. message_generator.appendln(R"~~~(
  287. @message.pascal_name@(decltype(nullptr)) : m_ipc_message_valid(false) { }
  288. @message.pascal_name@(@message.pascal_name@ const&) = default;
  289. @message.pascal_name@(@message.pascal_name@&&) = default;
  290. @message.pascal_name@& operator=(@message.pascal_name@ const&) = default;
  291. @message.constructor@)~~~");
  292. if (parameters.size() == 1) {
  293. auto const& parameter = parameters[0];
  294. message_generator.set("parameter.type"sv, parameter.type);
  295. message_generator.set("parameter.name"sv, parameter.name);
  296. message_generator.appendln(R"~~~(
  297. template <typename WrappedReturnType>
  298. requires(!SameAs<WrappedReturnType, @parameter.type@>)
  299. @message.pascal_name@(WrappedReturnType&& value)
  300. : m_@parameter.name@(forward<WrappedReturnType>(value))
  301. {
  302. })~~~");
  303. }
  304. message_generator.appendln(R"~~~(
  305. virtual ~@message.pascal_name@() override {}
  306. virtual u32 endpoint_magic() const override { return @endpoint.magic@; }
  307. virtual i32 message_id() const override { return (int)MessageID::@message.pascal_name@; }
  308. static i32 static_message_id() { return (int)MessageID::@message.pascal_name@; }
  309. virtual const char* message_name() const override { return "@endpoint.name@::@message.pascal_name@"; }
  310. static ErrorOr<NonnullOwnPtr<@message.pascal_name@>> decode(InputMemoryStream& stream, Core::Stream::LocalSocket& socket)
  311. {
  312. IPC::Decoder decoder { stream, socket };)~~~");
  313. for (auto const& parameter : parameters) {
  314. auto parameter_generator = message_generator.fork();
  315. parameter_generator.set("parameter.type", parameter.type);
  316. parameter_generator.set("parameter.name", parameter.name);
  317. if (parameter.type == "bool")
  318. parameter_generator.set("parameter.initial_value", "false");
  319. else
  320. parameter_generator.set("parameter.initial_value", "{}");
  321. parameter_generator.appendln(R"~~~(
  322. @parameter.type@ @parameter.name@ = @parameter.initial_value@;
  323. TRY(decoder.decode(@parameter.name@));)~~~");
  324. if (parameter.attributes.contains_slow("UTF8")) {
  325. parameter_generator.appendln(R"~~~(
  326. if (!Utf8View(@parameter.name@).validate())
  327. return Error::from_string_literal("Decoded @parameter.name@ is invalid UTF-8");)~~~");
  328. }
  329. }
  330. StringBuilder builder;
  331. for (size_t i = 0; i < parameters.size(); ++i) {
  332. auto const& parameter = parameters[i];
  333. builder.appendff("move({})", parameter.name);
  334. if (i != parameters.size() - 1)
  335. builder.append(", "sv);
  336. }
  337. message_generator.set("message.constructor_call_parameters", builder.build());
  338. append_handle_stream_error(message_generator, "Failed to read the message"sv);
  339. message_generator.appendln(R"~~~(
  340. return make<@message.pascal_name@>(@message.constructor_call_parameters@);
  341. })~~~");
  342. message_generator.appendln(R"~~~(
  343. virtual bool valid() const override { return m_ipc_message_valid; }
  344. virtual IPC::MessageBuffer encode() const override
  345. {
  346. VERIFY(valid());
  347. IPC::MessageBuffer buffer;
  348. IPC::Encoder stream(buffer);
  349. stream << endpoint_magic();
  350. stream << (int)MessageID::@message.pascal_name@;)~~~");
  351. for (auto const& parameter : parameters) {
  352. auto parameter_generator = message_generator.fork();
  353. parameter_generator.set("parameter.name", parameter.name);
  354. parameter_generator.appendln(R"~~~(
  355. stream << m_@parameter.name@;)~~~");
  356. }
  357. message_generator.appendln(R"~~~(
  358. return buffer;
  359. })~~~");
  360. for (auto const& parameter : parameters) {
  361. auto parameter_generator = message_generator.fork();
  362. parameter_generator.set("parameter.type", parameter.type);
  363. parameter_generator.set("parameter.name", parameter.name);
  364. parameter_generator.appendln(R"~~~(
  365. const @parameter.type@& @parameter.name@() const { return m_@parameter.name@; }
  366. @parameter.type@ take_@parameter.name@() { return move(m_@parameter.name@); })~~~");
  367. }
  368. message_generator.appendln(R"~~~(
  369. private:
  370. bool m_ipc_message_valid { true };)~~~");
  371. for (auto const& parameter : parameters) {
  372. auto parameter_generator = message_generator.fork();
  373. parameter_generator.set("parameter.type", parameter.type);
  374. parameter_generator.set("parameter.name", parameter.name);
  375. parameter_generator.appendln(R"~~~(
  376. @parameter.type@ m_@parameter.name@ {};)~~~");
  377. }
  378. message_generator.appendln("\n};");
  379. }
  380. void do_message_for_proxy(SourceGenerator message_generator, Endpoint const& endpoint, Message const& message)
  381. {
  382. auto do_implement_proxy = [&](DeprecatedString const& name, Vector<Parameter> const& parameters, bool is_synchronous, bool is_try) {
  383. DeprecatedString return_type = "void";
  384. if (is_synchronous) {
  385. if (message.outputs.size() == 1)
  386. return_type = message.outputs[0].type;
  387. else if (!message.outputs.is_empty())
  388. return_type = message_name(endpoint.name, message.name, true);
  389. }
  390. DeprecatedString inner_return_type = return_type;
  391. if (is_try)
  392. return_type = DeprecatedString::formatted("IPC::IPCErrorOr<{}>", return_type);
  393. message_generator.set("message.name", message.name);
  394. message_generator.set("message.pascal_name", pascal_case(message.name));
  395. message_generator.set("message.complex_return_type", return_type);
  396. message_generator.set("async_prefix_maybe", is_synchronous ? "" : "async_");
  397. message_generator.set("try_prefix_maybe", is_try ? "try_" : "");
  398. message_generator.set("handler_name", name);
  399. message_generator.appendln(R"~~~(
  400. @message.complex_return_type@ @try_prefix_maybe@@async_prefix_maybe@@handler_name@()~~~");
  401. for (size_t i = 0; i < parameters.size(); ++i) {
  402. auto const& parameter = parameters[i];
  403. auto argument_generator = message_generator.fork();
  404. argument_generator.set("argument.type", parameter.type);
  405. argument_generator.set("argument.name", parameter.name);
  406. argument_generator.append("@argument.type@ @argument.name@");
  407. if (i != parameters.size() - 1)
  408. argument_generator.append(", ");
  409. }
  410. message_generator.append(") {");
  411. if (is_synchronous && !is_try) {
  412. if (return_type != "void") {
  413. message_generator.append(R"~~~(
  414. return )~~~");
  415. if (message.outputs.size() != 1)
  416. message_generator.append("move(*");
  417. } else {
  418. message_generator.append(R"~~~(
  419. (void) )~~~");
  420. }
  421. message_generator.append("m_connection.template send_sync<Messages::@endpoint.name@::@message.pascal_name@>(");
  422. } else if (is_try) {
  423. message_generator.append(R"~~~(
  424. auto result = m_connection.template send_sync_but_allow_failure<Messages::@endpoint.name@::@message.pascal_name@>()~~~");
  425. } else {
  426. message_generator.append(R"~~~(
  427. // FIXME: Handle post_message failures.
  428. (void) m_connection.post_message(Messages::@endpoint.name@::@message.pascal_name@ { )~~~");
  429. }
  430. for (size_t i = 0; i < parameters.size(); ++i) {
  431. auto const& parameter = parameters[i];
  432. auto argument_generator = message_generator.fork();
  433. argument_generator.set("argument.name", parameter.name);
  434. if (is_primitive_or_simple_type(parameters[i].type))
  435. argument_generator.append("@argument.name@");
  436. else
  437. argument_generator.append("move(@argument.name@)");
  438. if (i != parameters.size() - 1)
  439. argument_generator.append(", ");
  440. }
  441. if (is_synchronous && !is_try) {
  442. if (return_type != "void") {
  443. message_generator.append(")");
  444. }
  445. if (message.outputs.size() == 1) {
  446. message_generator.append("->take_");
  447. message_generator.append(message.outputs[0].name);
  448. message_generator.append("()");
  449. } else
  450. message_generator.append(")");
  451. message_generator.append(";");
  452. } else if (is_try) {
  453. message_generator.append(R"~~~();
  454. if (!result)
  455. return IPC::ErrorCode::PeerDisconnected;)~~~");
  456. if (inner_return_type != "void") {
  457. message_generator.appendln(R"~~~(
  458. return move(*result);)~~~");
  459. } else {
  460. message_generator.appendln(R"~~~(
  461. return { };)~~~");
  462. }
  463. } else {
  464. message_generator.appendln(" });");
  465. }
  466. message_generator.appendln(R"~~~(
  467. })~~~");
  468. };
  469. do_implement_proxy(message.name, message.inputs, message.is_synchronous, false);
  470. if (message.is_synchronous) {
  471. do_implement_proxy(message.name, message.inputs, false, false);
  472. do_implement_proxy(message.name, message.inputs, true, true);
  473. }
  474. }
  475. void build_endpoint(SourceGenerator generator, Endpoint const& endpoint)
  476. {
  477. generator.set("endpoint.name", endpoint.name);
  478. generator.set("endpoint.magic", DeprecatedString::number(endpoint.magic));
  479. generator.appendln("\nnamespace Messages::@endpoint.name@ {");
  480. HashMap<DeprecatedString, int> message_ids = build_message_ids_for_endpoint(generator.fork(), endpoint);
  481. for (auto const& message : endpoint.messages) {
  482. DeprecatedString response_name;
  483. if (message.is_synchronous) {
  484. response_name = message.response_name();
  485. do_message(generator.fork(), response_name, message.outputs);
  486. }
  487. do_message(generator.fork(), message.name, message.inputs, response_name);
  488. }
  489. generator.appendln(R"~~~(
  490. } // namespace Messages::@endpoint.name@
  491. template<typename LocalEndpoint, typename PeerEndpoint>
  492. class @endpoint.name@Proxy {
  493. public:
  494. // Used to disambiguate the constructor call.
  495. struct Tag { };
  496. @endpoint.name@Proxy(IPC::Connection<LocalEndpoint, PeerEndpoint>& connection, Tag)
  497. : m_connection(connection)
  498. { })~~~");
  499. for (auto const& message : endpoint.messages)
  500. do_message_for_proxy(generator.fork(), endpoint, message);
  501. generator.appendln(R"~~~(
  502. private:
  503. IPC::Connection<LocalEndpoint, PeerEndpoint>& m_connection;
  504. };)~~~");
  505. generator.append(R"~~~(
  506. template<typename LocalEndpoint, typename PeerEndpoint>
  507. class @endpoint.name@Proxy;
  508. class @endpoint.name@Stub;
  509. class @endpoint.name@Endpoint {
  510. public:
  511. template<typename LocalEndpoint>
  512. using Proxy = @endpoint.name@Proxy<LocalEndpoint, @endpoint.name@Endpoint>;
  513. using Stub = @endpoint.name@Stub;
  514. static u32 static_magic() { return @endpoint.magic@; }
  515. static ErrorOr<NonnullOwnPtr<IPC::Message>> decode_message(ReadonlyBytes buffer, [[maybe_unused]] Core::Stream::LocalSocket& socket)
  516. {
  517. InputMemoryStream stream { buffer };
  518. u32 message_endpoint_magic = 0;
  519. stream >> message_endpoint_magic;)~~~");
  520. append_handle_stream_error(generator, "Failed to read message endpoint magic"sv);
  521. generator.append(R"~~~(
  522. if (message_endpoint_magic != @endpoint.magic@) {)~~~");
  523. if constexpr (GENERATE_DEBUG) {
  524. generator.append(R"~~~(
  525. dbgln("@endpoint.name@: Endpoint magic number message_endpoint_magic != @endpoint.magic@, not my message! (the other endpoint may have handled it)");)~~~");
  526. }
  527. generator.appendln(R"~~~(
  528. return Error::from_string_literal("Endpoint magic number mismatch, not my message!");
  529. }
  530. i32 message_id = 0;
  531. stream >> message_id;)~~~");
  532. append_handle_stream_error(generator, "Failed to read message ID"sv);
  533. generator.appendln(R"~~~(
  534. switch (message_id) {)~~~");
  535. for (auto const& message : endpoint.messages) {
  536. auto do_decode_message = [&](DeprecatedString const& name) {
  537. auto message_generator = generator.fork();
  538. message_generator.set("message.name", name);
  539. message_generator.set("message.pascal_name", pascal_case(name));
  540. message_generator.append(R"~~~(
  541. case (int)Messages::@endpoint.name@::MessageID::@message.pascal_name@:
  542. return TRY(Messages::@endpoint.name@::@message.pascal_name@::decode(stream, socket));)~~~");
  543. };
  544. do_decode_message(message.name);
  545. if (message.is_synchronous)
  546. do_decode_message(message.response_name());
  547. }
  548. generator.append(R"~~~(
  549. default:)~~~");
  550. if constexpr (GENERATE_DEBUG) {
  551. generator.append(R"~~~(
  552. dbgln("Failed to decode @endpoint.name@.({})", message_id);)~~~");
  553. }
  554. generator.appendln(R"~~~(
  555. return Error::from_string_literal("Failed to decode @endpoint.name@ message");
  556. })~~~");
  557. generator.appendln(R"~~~(
  558. VERIFY_NOT_REACHED();
  559. }
  560. };
  561. class @endpoint.name@Stub : public IPC::Stub {
  562. public:
  563. @endpoint.name@Stub() { }
  564. virtual ~@endpoint.name@Stub() override { }
  565. virtual u32 magic() const override { return @endpoint.magic@; }
  566. virtual DeprecatedString name() const override { return "@endpoint.name@"; }
  567. virtual OwnPtr<IPC::MessageBuffer> handle(const IPC::Message& message) override
  568. {
  569. switch (message.message_id()) {)~~~");
  570. for (auto const& message : endpoint.messages) {
  571. auto do_handle_message = [&](DeprecatedString const& name, Vector<Parameter> const& parameters, bool returns_something) {
  572. auto message_generator = generator.fork();
  573. StringBuilder argument_generator;
  574. for (size_t i = 0; i < parameters.size(); ++i) {
  575. auto const& parameter = parameters[i];
  576. argument_generator.append("request."sv);
  577. argument_generator.append(parameter.name);
  578. argument_generator.append("()"sv);
  579. if (i != parameters.size() - 1)
  580. argument_generator.append(", "sv);
  581. }
  582. message_generator.set("message.pascal_name", pascal_case(name));
  583. message_generator.set("message.response_type", pascal_case(message.response_name()));
  584. message_generator.set("handler_name", name);
  585. message_generator.set("arguments", argument_generator.to_deprecated_string());
  586. message_generator.appendln(R"~~~(
  587. case (int)Messages::@endpoint.name@::MessageID::@message.pascal_name@: {)~~~");
  588. if (returns_something) {
  589. if (message.outputs.is_empty()) {
  590. message_generator.appendln(R"~~~(
  591. [[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.pascal_name@&>(message);
  592. @handler_name@(@arguments@);
  593. auto response = Messages::@endpoint.name@::@message.response_type@ { };
  594. return make<IPC::MessageBuffer>(response.encode());)~~~");
  595. } else {
  596. message_generator.appendln(R"~~~(
  597. [[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.pascal_name@&>(message);
  598. auto response = @handler_name@(@arguments@);
  599. if (!response.valid())
  600. return {};
  601. return make<IPC::MessageBuffer>(response.encode());)~~~");
  602. }
  603. } else {
  604. message_generator.appendln(R"~~~(
  605. [[maybe_unused]] auto& request = static_cast<const Messages::@endpoint.name@::@message.pascal_name@&>(message);
  606. @handler_name@(@arguments@);
  607. return {};)~~~");
  608. }
  609. message_generator.appendln(R"~~~(
  610. })~~~");
  611. };
  612. do_handle_message(message.name, message.inputs, message.is_synchronous);
  613. }
  614. generator.appendln(R"~~~(
  615. default:
  616. return {};
  617. }
  618. })~~~");
  619. for (auto const& message : endpoint.messages) {
  620. auto message_generator = generator.fork();
  621. auto do_handle_message_decl = [&](DeprecatedString const& name, Vector<Parameter> const& parameters, bool is_response) {
  622. DeprecatedString return_type = "void";
  623. if (message.is_synchronous && !message.outputs.is_empty() && !is_response)
  624. return_type = message_name(endpoint.name, message.name, true);
  625. message_generator.set("message.complex_return_type", return_type);
  626. message_generator.set("handler_name", name);
  627. message_generator.appendln(R"~~~(
  628. virtual @message.complex_return_type@ @handler_name@()~~~");
  629. auto make_argument_type = [](DeprecatedString const& type) {
  630. StringBuilder builder;
  631. bool const_ref = !is_primitive_or_simple_type(type);
  632. builder.append(type);
  633. if (const_ref)
  634. builder.append(" const&"sv);
  635. return builder.to_deprecated_string();
  636. };
  637. for (size_t i = 0; i < parameters.size(); ++i) {
  638. auto const& parameter = parameters[i];
  639. auto argument_generator = message_generator.fork();
  640. argument_generator.set("argument.type", make_argument_type(parameter.type));
  641. argument_generator.set("argument.name", parameter.name);
  642. argument_generator.append("[[maybe_unused]] @argument.type@ @argument.name@");
  643. if (i != parameters.size() - 1)
  644. argument_generator.append(", ");
  645. }
  646. if (is_response) {
  647. message_generator.append(") { };");
  648. } else {
  649. message_generator.appendln(") = 0;");
  650. }
  651. };
  652. do_handle_message_decl(message.name, message.inputs, false);
  653. }
  654. generator.appendln(R"~~~(
  655. private:
  656. };
  657. #if defined(AK_COMPILER_CLANG)
  658. #pragma clang diagnostic pop
  659. #endif)~~~");
  660. }
  661. void build(StringBuilder& builder, Vector<Endpoint> const& endpoints)
  662. {
  663. SourceGenerator generator { builder };
  664. generator.appendln("#pragma once");
  665. // This must occur before LibIPC/Decoder.h
  666. for (auto const& endpoint : endpoints) {
  667. for (auto const& include : endpoint.includes) {
  668. generator.appendln(include);
  669. }
  670. }
  671. generator.appendln(R"~~~(#include <AK/MemoryStream.h>
  672. #include <AK/Error.h>
  673. #include <AK/OwnPtr.h>
  674. #include <AK/Result.h>
  675. #include <AK/Utf8View.h>
  676. #include <LibIPC/Connection.h>
  677. #include <LibIPC/Decoder.h>
  678. #include <LibIPC/Dictionary.h>
  679. #include <LibIPC/Encoder.h>
  680. #include <LibIPC/File.h>
  681. #include <LibIPC/Message.h>
  682. #include <LibIPC/Stub.h>
  683. #if defined(AK_COMPILER_CLANG)
  684. #pragma clang diagnostic push
  685. #pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
  686. #endif)~~~");
  687. for (auto const& endpoint : endpoints)
  688. build_endpoint(generator.fork(), endpoint);
  689. }
  690. ErrorOr<int> serenity_main(Main::Arguments arguments)
  691. {
  692. if (arguments.argc != 2) {
  693. outln("usage: {} <IPC endpoint definition file>", arguments.strings[0]);
  694. return 1;
  695. }
  696. auto file = TRY(Core::Stream::File::open(arguments.strings[1], Core::Stream::OpenMode::Read));
  697. auto file_contents = TRY(file->read_until_eof());
  698. auto endpoints = parse(file_contents);
  699. StringBuilder builder;
  700. build(builder, endpoints);
  701. outln("{}", builder.string_view());
  702. if constexpr (GENERATE_DEBUG) {
  703. for (auto& endpoint : endpoints) {
  704. warnln("Endpoint '{}' (magic: {})", endpoint.name, endpoint.magic);
  705. for (auto& message : endpoint.messages) {
  706. warnln(" Message: '{}'", message.name);
  707. warnln(" Sync: {}", message.is_synchronous);
  708. warnln(" Inputs:");
  709. for (auto& parameter : message.inputs)
  710. warnln(" Parameter: {} ({})", parameter.name, parameter.type);
  711. if (message.inputs.is_empty())
  712. warnln(" (none)");
  713. if (message.is_synchronous) {
  714. warnln(" Outputs:");
  715. for (auto& parameter : message.outputs)
  716. warnln(" Parameter: {} ({})", parameter.name, parameter.type);
  717. if (message.outputs.is_empty())
  718. warnln(" (none)");
  719. }
  720. }
  721. }
  722. }
  723. return 0;
  724. }