GenerateWindowOrWorkerInterfaces.cpp 19 KB

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