GenerateWindowOrWorkerInterfaces.cpp 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497
  1. /*
  2. * Copyright (c) 2022, Andrew Kaster <akaster@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/DeprecatedString.h>
  7. #include <AK/LexicalPath.h>
  8. #include <AK/SourceGenerator.h>
  9. #include <AK/StringBuilder.h>
  10. #include <LibCore/ArgsParser.h>
  11. #include <LibCore/File.h>
  12. #include <LibIDL/IDLParser.h>
  13. #include <LibIDL/Types.h>
  14. #include <LibMain/Main.h>
  15. static ErrorOr<void> add_to_interface_sets(IDL::Interface&, Vector<IDL::Interface&>& intrinsics, Vector<IDL::Interface&>& window_exposed, Vector<IDL::Interface&>& dedicated_worker_exposed, Vector<IDL::Interface&>& shared_worker_exposed);
  16. static DeprecatedString s_error_string;
  17. struct LegacyConstructor {
  18. DeprecatedString name;
  19. DeprecatedString constructor_class;
  20. };
  21. static void consume_whitespace(GenericLexer& lexer)
  22. {
  23. bool consumed = true;
  24. while (consumed) {
  25. consumed = lexer.consume_while(is_ascii_space).length() > 0;
  26. if (lexer.consume_specific("//")) {
  27. lexer.consume_until('\n');
  28. lexer.ignore();
  29. consumed = true;
  30. }
  31. }
  32. }
  33. static Optional<LegacyConstructor> const& lookup_legacy_constructor(IDL::Interface& interface)
  34. {
  35. static HashMap<StringView, Optional<LegacyConstructor>> s_legacy_constructors;
  36. if (auto cache = s_legacy_constructors.get(interface.name); cache.has_value())
  37. return cache.value();
  38. auto attribute = interface.extended_attributes.get("LegacyFactoryFunction"sv);
  39. if (!attribute.has_value()) {
  40. s_legacy_constructors.set(interface.name, {});
  41. return s_legacy_constructors.get(interface.name).value();
  42. }
  43. GenericLexer function_lexer(attribute.value());
  44. consume_whitespace(function_lexer);
  45. auto name = function_lexer.consume_until([](auto ch) { return is_ascii_space(ch) || ch == '('; });
  46. auto constructor_class = DeprecatedString::formatted("{}Constructor", name);
  47. s_legacy_constructors.set(interface.name, LegacyConstructor { name, move(constructor_class) });
  48. return s_legacy_constructors.get(interface.name).value();
  49. }
  50. static ErrorOr<void> generate_forwarding_header(StringView output_path, Vector<IDL::Interface&>& exposed_interfaces)
  51. {
  52. StringBuilder builder;
  53. SourceGenerator generator(builder);
  54. generator.append(R"~~~(
  55. #pragma once
  56. namespace Web::Bindings {
  57. )~~~");
  58. auto add_namespace = [](SourceGenerator& gen, StringView namespace_class) {
  59. gen.set("namespace_class", namespace_class);
  60. gen.append(R"~~~(
  61. class @namespace_class@;)~~~");
  62. };
  63. auto add_interface = [](SourceGenerator& gen, StringView prototype_class, StringView constructor_class, Optional<LegacyConstructor> const& legacy_constructor) {
  64. gen.set("prototype_class", prototype_class);
  65. gen.set("constructor_class", constructor_class);
  66. gen.append(R"~~~(
  67. class @prototype_class@;
  68. class @constructor_class@;)~~~");
  69. if (legacy_constructor.has_value()) {
  70. gen.set("legacy_constructor_class", legacy_constructor->constructor_class);
  71. gen.append(R"~~~(
  72. class @legacy_constructor_class@;)~~~");
  73. }
  74. };
  75. for (auto& interface : exposed_interfaces) {
  76. auto gen = generator.fork();
  77. if (interface.is_namespace)
  78. add_namespace(gen, interface.namespace_class);
  79. else
  80. add_interface(gen, interface.prototype_class, interface.constructor_class, lookup_legacy_constructor(interface));
  81. }
  82. // FIXME: Special case WebAssembly. We should convert WASM to use IDL.
  83. {
  84. auto gen = generator.fork();
  85. add_interface(gen, "WebAssemblyTablePrototype"sv, "WebAssemblyTableConstructor"sv, {});
  86. }
  87. generator.append(R"~~~(
  88. }
  89. )~~~");
  90. auto generated_forward_path = LexicalPath(output_path).append("Forward.h"sv).string();
  91. auto generated_forward_file = TRY(Core::File::open(generated_forward_path, Core::File::OpenMode::Write));
  92. TRY(generated_forward_file->write_until_depleted(generator.as_string_view().bytes()));
  93. return {};
  94. }
  95. static ErrorOr<void> generate_intrinsic_definitions(StringView output_path, Vector<IDL::Interface&>& exposed_interfaces)
  96. {
  97. StringBuilder builder;
  98. SourceGenerator generator(builder);
  99. generator.append(R"~~~(
  100. #include <LibJS/Heap/DeferGC.h>
  101. #include <LibJS/Runtime/Object.h>
  102. #include <LibWeb/Bindings/Intrinsics.h>)~~~");
  103. for (auto& interface : exposed_interfaces) {
  104. auto gen = generator.fork();
  105. gen.set("namespace_class", interface.namespace_class);
  106. gen.set("prototype_class", interface.prototype_class);
  107. gen.set("constructor_class", interface.constructor_class);
  108. if (interface.is_namespace) {
  109. gen.append(R"~~~(
  110. #include <LibWeb/Bindings/@namespace_class@.h>)~~~");
  111. } else {
  112. gen.append(R"~~~(
  113. #include <LibWeb/Bindings/@constructor_class@.h>
  114. #include <LibWeb/Bindings/@prototype_class@.h>)~~~");
  115. if (auto const& legacy_constructor = lookup_legacy_constructor(interface); legacy_constructor.has_value()) {
  116. gen.set("legacy_constructor_class", legacy_constructor->constructor_class);
  117. gen.append(R"~~~(
  118. #include <LibWeb/Bindings/@legacy_constructor_class@.h>)~~~");
  119. }
  120. }
  121. }
  122. // FIXME: Special case WebAssembly. We should convert WASM to use IDL.
  123. generator.append(R"~~~(
  124. #include <LibWeb/WebAssembly/WebAssemblyTableConstructor.h>
  125. #include <LibWeb/WebAssembly/WebAssemblyTablePrototype.h>)~~~");
  126. generator.append(R"~~~(
  127. namespace Web::Bindings {
  128. )~~~");
  129. auto add_namespace = [&](SourceGenerator& gen, StringView name, StringView namespace_class) {
  130. gen.set("interface_name", name);
  131. gen.set("namespace_class", namespace_class);
  132. gen.append(R"~~~(
  133. template<>
  134. void Intrinsics::create_web_namespace<@namespace_class@>(JS::Realm& realm)
  135. {
  136. auto namespace_object = heap().allocate<@namespace_class@>(realm, realm).release_allocated_value_but_fixme_should_propagate_errors();
  137. m_namespaces.set("@interface_name@"sv, namespace_object);
  138. }
  139. )~~~");
  140. };
  141. auto add_interface = [&](SourceGenerator& gen, StringView name, StringView prototype_class, StringView constructor_class, Optional<LegacyConstructor> const& legacy_constructor) {
  142. gen.set("interface_name", name);
  143. gen.set("prototype_class", prototype_class);
  144. gen.set("constructor_class", constructor_class);
  145. gen.append(R"~~~(
  146. template<>
  147. void Intrinsics::create_web_prototype_and_constructor<@prototype_class@>(JS::Realm& realm)
  148. {
  149. auto& vm = realm.vm();
  150. auto prototype = heap().allocate<@prototype_class@>(realm, realm).release_allocated_value_but_fixme_should_propagate_errors();
  151. m_prototypes.set("@interface_name@"sv, prototype);
  152. auto constructor = heap().allocate<@constructor_class@>(realm, realm).release_allocated_value_but_fixme_should_propagate_errors();
  153. m_constructors.set("@interface_name@"sv, constructor);
  154. prototype->define_direct_property(vm.names.constructor, constructor.ptr(), JS::Attribute::Writable | JS::Attribute::Configurable);
  155. constructor->define_direct_property(vm.names.name, JS::PrimitiveString::create(vm, "@interface_name@"sv).release_allocated_value_but_fixme_should_propagate_errors(), JS::Attribute::Configurable);
  156. )~~~");
  157. if (legacy_constructor.has_value()) {
  158. gen.set("legacy_interface_name", legacy_constructor->name);
  159. gen.set("legacy_constructor_class", legacy_constructor->constructor_class);
  160. gen.append(R"~~~(
  161. auto legacy_constructor = heap().allocate<@legacy_constructor_class@>(realm, realm).release_allocated_value_but_fixme_should_propagate_errors();
  162. m_constructors.set("@legacy_interface_name@"sv, legacy_constructor);
  163. legacy_constructor->define_direct_property(vm.names.name, JS::PrimitiveString::create(vm, "@legacy_interface_name@"sv).release_allocated_value_but_fixme_should_propagate_errors(), JS::Attribute::Configurable);)~~~");
  164. }
  165. gen.append(R"~~~(
  166. }
  167. )~~~");
  168. };
  169. for (auto& interface : exposed_interfaces) {
  170. auto gen = generator.fork();
  171. if (interface.is_namespace)
  172. add_namespace(gen, interface.name, interface.namespace_class);
  173. else
  174. add_interface(gen, interface.namespaced_name, interface.prototype_class, interface.constructor_class, lookup_legacy_constructor(interface));
  175. }
  176. // FIXME: Special case WebAssembly. We should convert WASM to use IDL.
  177. {
  178. auto gen = generator.fork();
  179. add_interface(gen, "WebAssembly.Table"sv, "WebAssemblyTablePrototype"sv, "WebAssemblyTableConstructor"sv, {});
  180. }
  181. generator.append(R"~~~(
  182. }
  183. )~~~");
  184. auto generated_intrinsics_path = LexicalPath(output_path).append("IntrinsicDefinitions.cpp"sv).string();
  185. auto generated_intrinsics_file = TRY(Core::File::open(generated_intrinsics_path, Core::File::OpenMode::Write));
  186. TRY(generated_intrinsics_file->write_until_depleted(generator.as_string_view().bytes()));
  187. return {};
  188. }
  189. static ErrorOr<void> generate_exposed_interface_header(StringView class_name, StringView output_path)
  190. {
  191. StringBuilder builder;
  192. SourceGenerator generator(builder);
  193. generator.set("global_object_snake_name", DeprecatedString(class_name).to_snakecase());
  194. generator.append(R"~~~(
  195. #pragma once
  196. #include <LibJS/Forward.h>
  197. namespace Web::Bindings {
  198. void add_@global_object_snake_name@_exposed_interfaces(JS::Object&);
  199. }
  200. )~~~");
  201. auto generated_header_path = LexicalPath(output_path).append(DeprecatedString::formatted("{}ExposedInterfaces.h", class_name)).string();
  202. auto generated_header_file = TRY(Core::File::open(generated_header_path, Core::File::OpenMode::Write));
  203. TRY(generated_header_file->write_until_depleted(generator.as_string_view().bytes()));
  204. return {};
  205. }
  206. static ErrorOr<void> generate_exposed_interface_implementation(StringView class_name, StringView output_path, Vector<IDL::Interface&>& exposed_interfaces)
  207. {
  208. StringBuilder builder;
  209. SourceGenerator generator(builder);
  210. generator.set("global_object_name", class_name);
  211. generator.set("global_object_snake_name", DeprecatedString(class_name).to_snakecase());
  212. generator.append(R"~~~(
  213. #include <LibJS/Runtime/Object.h>
  214. #include <LibWeb/Bindings/Intrinsics.h>
  215. #include <LibWeb/Bindings/@global_object_name@ExposedInterfaces.h>
  216. )~~~");
  217. for (auto& interface : exposed_interfaces) {
  218. auto gen = generator.fork();
  219. gen.set("namespace_class", interface.namespace_class);
  220. gen.set("prototype_class", interface.prototype_class);
  221. gen.set("constructor_class", interface.constructor_class);
  222. if (interface.is_namespace) {
  223. gen.append(R"~~~(#include <LibWeb/Bindings/@namespace_class@.h>
  224. )~~~");
  225. } else {
  226. gen.append(R"~~~(#include <LibWeb/Bindings/@constructor_class@.h>
  227. #include <LibWeb/Bindings/@prototype_class@.h>
  228. )~~~");
  229. if (auto const& legacy_constructor = lookup_legacy_constructor(interface); legacy_constructor.has_value()) {
  230. gen.set("legacy_constructor_class", legacy_constructor->constructor_class);
  231. gen.append(R"~~~(#include <LibWeb/Bindings/@legacy_constructor_class@.h>
  232. )~~~");
  233. }
  234. }
  235. }
  236. generator.append(R"~~~(
  237. namespace Web::Bindings {
  238. void add_@global_object_snake_name@_exposed_interfaces(JS::Object& global)
  239. {
  240. static constexpr u8 attr = JS::Attribute::Writable | JS::Attribute::Configurable;
  241. )~~~");
  242. auto add_interface = [](SourceGenerator& gen, StringView name, StringView prototype_class, Optional<LegacyConstructor> const& legacy_constructor) {
  243. gen.set("interface_name", name);
  244. gen.set("prototype_class", prototype_class);
  245. gen.append(R"~~~(
  246. global.define_intrinsic_accessor("@interface_name@", attr, [](auto& realm) -> JS::Value { return &ensure_web_constructor<@prototype_class@>(realm, "@interface_name@"sv); });)~~~");
  247. if (legacy_constructor.has_value()) {
  248. gen.set("legacy_interface_name", legacy_constructor->name);
  249. gen.append(R"~~~(
  250. global.define_intrinsic_accessor("@legacy_interface_name@", attr, [](auto& realm) -> JS::Value { return &ensure_web_constructor<@prototype_class@>(realm, "@legacy_interface_name@"sv); });)~~~");
  251. }
  252. };
  253. auto add_namespace = [](SourceGenerator& gen, StringView name, StringView namespace_class) {
  254. gen.set("interface_name", name);
  255. gen.set("namespace_class", namespace_class);
  256. gen.append(R"~~~(
  257. global.define_intrinsic_accessor("@interface_name@", attr, [](auto& realm) -> JS::Value { return &ensure_web_namespace<@namespace_class@>(realm, "@interface_name@"sv); });)~~~");
  258. };
  259. for (auto& interface : exposed_interfaces) {
  260. auto gen = generator.fork();
  261. if (interface.is_namespace)
  262. add_namespace(gen, interface.name, interface.namespace_class);
  263. else
  264. add_interface(gen, interface.namespaced_name, interface.prototype_class, lookup_legacy_constructor(interface));
  265. }
  266. generator.append(R"~~~(
  267. }
  268. }
  269. )~~~");
  270. auto generated_implementation_path = LexicalPath(output_path).append(DeprecatedString::formatted("{}ExposedInterfaces.cpp", class_name)).string();
  271. auto generated_implementation_file = TRY(Core::File::open(generated_implementation_path, Core::File::OpenMode::Write));
  272. TRY(generated_implementation_file->write_until_depleted(generator.as_string_view().bytes()));
  273. return {};
  274. }
  275. ErrorOr<int> serenity_main(Main::Arguments arguments)
  276. {
  277. Core::ArgsParser args_parser;
  278. StringView output_path;
  279. StringView base_path;
  280. Vector<DeprecatedString> paths;
  281. args_parser.add_option(output_path, "Path to output generated files into", "output-path", 'o', "output-path");
  282. args_parser.add_option(base_path, "Path to root of IDL file tree", "base-path", 'b', "base-path");
  283. args_parser.add_positional_argument(paths, "Paths of every IDL file that could be Exposed", "paths");
  284. args_parser.parse(arguments);
  285. VERIFY(!paths.is_empty());
  286. VERIFY(!base_path.is_empty());
  287. const LexicalPath lexical_base(base_path);
  288. // Read in all IDL files, we must own the storage for all of these for the lifetime of the program
  289. Vector<DeprecatedString> file_contents;
  290. for (DeprecatedString const& path : paths) {
  291. auto file_or_error = Core::File::open(path, Core::File::OpenMode::Read);
  292. if (file_or_error.is_error()) {
  293. s_error_string = DeprecatedString::formatted("Unable to open file {}", path);
  294. return Error::from_string_view(s_error_string);
  295. }
  296. auto file = file_or_error.release_value();
  297. auto string = MUST(file->read_until_eof());
  298. file_contents.append(DeprecatedString(ReadonlyBytes(string)));
  299. }
  300. VERIFY(paths.size() == file_contents.size());
  301. Vector<IDL::Parser> parsers;
  302. Vector<IDL::Interface&> intrinsics;
  303. Vector<IDL::Interface&> window_exposed;
  304. Vector<IDL::Interface&> dedicated_worker_exposed;
  305. Vector<IDL::Interface&> shared_worker_exposed;
  306. // TODO: service_worker_exposed
  307. for (size_t i = 0; i < paths.size(); ++i) {
  308. IDL::Parser parser(paths[i], file_contents[i], lexical_base.string());
  309. TRY(add_to_interface_sets(parser.parse(), intrinsics, window_exposed, dedicated_worker_exposed, shared_worker_exposed));
  310. parsers.append(move(parser));
  311. }
  312. TRY(generate_forwarding_header(output_path, intrinsics));
  313. TRY(generate_intrinsic_definitions(output_path, intrinsics));
  314. TRY(generate_exposed_interface_header("Window"sv, output_path));
  315. TRY(generate_exposed_interface_header("DedicatedWorker"sv, output_path));
  316. TRY(generate_exposed_interface_header("SharedWorker"sv, output_path));
  317. // TODO: ServiceWorkerExposed.h
  318. TRY(generate_exposed_interface_implementation("Window"sv, output_path, window_exposed));
  319. TRY(generate_exposed_interface_implementation("DedicatedWorker"sv, output_path, dedicated_worker_exposed));
  320. TRY(generate_exposed_interface_implementation("SharedWorker"sv, output_path, shared_worker_exposed));
  321. // TODO: ServiceWorkerExposed.cpp
  322. return 0;
  323. }
  324. enum ExposedTo {
  325. Nobody = 0x0,
  326. DedicatedWorker = 0x1,
  327. SharedWorker = 0x2,
  328. ServiceWorker = 0x4,
  329. AudioWorklet = 0x8,
  330. Window = 0x10,
  331. AllWorkers = 0xF, // FIXME: Is "AudioWorklet" a Worker? We'll assume it is for now
  332. All = 0x1F,
  333. };
  334. AK_ENUM_BITWISE_OPERATORS(ExposedTo);
  335. static ErrorOr<ExposedTo> parse_exposure_set(IDL::Interface& interface)
  336. {
  337. // NOTE: This roughly follows the definitions of https://webidl.spec.whatwg.org/#Exposed
  338. // It does not remotely interpret all the abstract operations therein though.
  339. auto maybe_exposed = interface.extended_attributes.get("Exposed");
  340. if (!maybe_exposed.has_value()) {
  341. s_error_string = DeprecatedString::formatted("Interface {} is missing extended attribute Exposed", interface.name);
  342. return Error::from_string_view(s_error_string);
  343. }
  344. auto exposed = maybe_exposed.value().trim_whitespace();
  345. if (exposed == "*"sv)
  346. return ExposedTo::All;
  347. if (exposed == "Window"sv)
  348. return ExposedTo::Window;
  349. if (exposed == "Worker"sv)
  350. return ExposedTo::AllWorkers;
  351. if (exposed == "AudioWorklet"sv)
  352. return ExposedTo::AudioWorklet;
  353. if (exposed[0] == '(') {
  354. ExposedTo whom = Nobody;
  355. for (StringView candidate : exposed.substring_view(1, exposed.length() - 1).split_view(',')) {
  356. candidate = candidate.trim_whitespace();
  357. if (candidate == "Window"sv) {
  358. whom |= ExposedTo::Window;
  359. } else if (candidate == "Worker"sv) {
  360. whom |= ExposedTo::AllWorkers;
  361. } else if (candidate == "DedicatedWorker"sv) {
  362. whom |= ExposedTo::DedicatedWorker;
  363. } else if (candidate == "SharedWorker"sv) {
  364. whom |= ExposedTo::SharedWorker;
  365. } else if (candidate == "ServiceWorker"sv) {
  366. whom |= ExposedTo::ServiceWorker;
  367. } else if (candidate == "AudioWorklet"sv) {
  368. whom |= ExposedTo::AudioWorklet;
  369. } else {
  370. s_error_string = DeprecatedString::formatted("Unknown Exposed attribute candidate {} in {} in {}", candidate, exposed, interface.name);
  371. return Error::from_string_view(s_error_string);
  372. }
  373. }
  374. if (whom == ExposedTo::Nobody) {
  375. s_error_string = DeprecatedString::formatted("Unknown Exposed attribute {} in {}", exposed, interface.name);
  376. return Error::from_string_view(s_error_string);
  377. }
  378. return whom;
  379. }
  380. s_error_string = DeprecatedString::formatted("Unknown Exposed attribute {} in {}", exposed, interface.name);
  381. return Error::from_string_view(s_error_string);
  382. }
  383. ErrorOr<void> add_to_interface_sets(IDL::Interface& interface, Vector<IDL::Interface&>& intrinsics, Vector<IDL::Interface&>& window_exposed, Vector<IDL::Interface&>& dedicated_worker_exposed, Vector<IDL::Interface&>& shared_worker_exposed)
  384. {
  385. // TODO: Add service worker exposed and audio worklet exposed
  386. auto whom = TRY(parse_exposure_set(interface));
  387. VERIFY(whom != ExposedTo::Nobody);
  388. if ((whom & ExposedTo::Window) || (whom & ExposedTo::DedicatedWorker) || (whom & ExposedTo::SharedWorker))
  389. intrinsics.append(interface);
  390. if (whom & ExposedTo::Window)
  391. window_exposed.append(interface);
  392. if (whom & ExposedTo::DedicatedWorker)
  393. dedicated_worker_exposed.append(interface);
  394. if (whom & ExposedTo::SharedWorker)
  395. shared_worker_exposed.append(interface);
  396. return {};
  397. }