GenerateWindowOrWorkerInterfaces.cpp 19 KB

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