GenerateTimeZoneData.cpp 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870
  1. /*
  2. * Copyright (c) 2022, Tim Flynn <trflynn89@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include "../LibUnicode/GeneratorUtil.h" // FIXME: Move this somewhere common.
  7. #include <AK/ByteString.h>
  8. #include <AK/DateConstants.h>
  9. #include <AK/Error.h>
  10. #include <AK/Format.h>
  11. #include <AK/HashMap.h>
  12. #include <AK/SourceGenerator.h>
  13. #include <AK/StringBuilder.h>
  14. #include <AK/Vector.h>
  15. #include <LibCore/ArgsParser.h>
  16. #include <LibTimeZone/TimeZone.h>
  17. namespace {
  18. struct DateTime {
  19. u16 year { 0 };
  20. Optional<u8> month;
  21. Optional<u8> day;
  22. Optional<u8> last_weekday;
  23. Optional<u8> after_weekday;
  24. Optional<u8> before_weekday;
  25. Optional<u8> hour;
  26. Optional<u8> minute;
  27. Optional<u8> second;
  28. };
  29. struct TimeZoneOffset {
  30. i64 offset { 0 };
  31. Optional<DateTime> until;
  32. Optional<ByteString> dst_rule;
  33. Optional<i32> dst_rule_index;
  34. i64 dst_offset { 0 };
  35. size_t standard_format { 0 };
  36. size_t daylight_format { 0 };
  37. };
  38. struct DaylightSavingsOffset {
  39. i64 offset { 0 };
  40. u16 year_from { 0 };
  41. Optional<u16> year_to;
  42. DateTime in_effect;
  43. size_t format { 0 };
  44. };
  45. struct TimeZoneData {
  46. UniqueStringStorage unique_strings;
  47. HashMap<ByteString, Vector<TimeZoneOffset>> time_zones;
  48. Vector<ByteString> time_zone_names;
  49. Vector<Alias> time_zone_aliases;
  50. HashMap<ByteString, Vector<DaylightSavingsOffset>> dst_offsets;
  51. Vector<ByteString> dst_offset_names;
  52. HashMap<ByteString, TimeZone::Location> time_zone_coordinates;
  53. HashMap<ByteString, Vector<size_t>> time_zone_regions;
  54. Vector<ByteString> time_zone_region_names;
  55. Vector<TimeZone::TimeZoneIdentifier> time_zones_and_links;
  56. };
  57. }
  58. template<>
  59. struct AK::Formatter<DateTime> : Formatter<FormatString> {
  60. ErrorOr<void> format(FormatBuilder& builder, DateTime const& date_time)
  61. {
  62. return Formatter<FormatString>::format(builder,
  63. "{{ {}, {}, {}, {}, {}, {}, {}, {}, {} }}"sv,
  64. date_time.year,
  65. date_time.month.value_or(1),
  66. date_time.day.value_or(1),
  67. date_time.last_weekday.value_or(0),
  68. date_time.after_weekday.value_or(0),
  69. date_time.before_weekday.value_or(0),
  70. date_time.hour.value_or(0),
  71. date_time.minute.value_or(0),
  72. date_time.second.value_or(0));
  73. }
  74. };
  75. template<>
  76. struct AK::Formatter<TimeZoneOffset> : Formatter<FormatString> {
  77. ErrorOr<void> format(FormatBuilder& builder, TimeZoneOffset const& time_zone_offset)
  78. {
  79. return Formatter<FormatString>::format(builder,
  80. "{{ {}, {}, {}, {}, {}, {}, {} }}"sv,
  81. time_zone_offset.offset,
  82. time_zone_offset.until.value_or({}),
  83. time_zone_offset.until.has_value(),
  84. time_zone_offset.dst_rule_index.value_or(-1),
  85. time_zone_offset.dst_offset,
  86. time_zone_offset.standard_format,
  87. time_zone_offset.daylight_format);
  88. }
  89. };
  90. template<>
  91. struct AK::Formatter<DaylightSavingsOffset> : Formatter<FormatString> {
  92. ErrorOr<void> format(FormatBuilder& builder, DaylightSavingsOffset const& dst_offset)
  93. {
  94. auto format_time = [&](auto year) {
  95. return ByteString::formatted("AK::UnixDateTime::from_unix_time_parts({}, 1, 1, 0, 0, 0, 0)", year);
  96. };
  97. static ByteString max_year_as_time("max_year_as_time"sv);
  98. return Formatter<FormatString>::format(builder,
  99. "{{ {}, {}, {}, {}, {} }}"sv,
  100. dst_offset.offset,
  101. format_time(dst_offset.year_from),
  102. dst_offset.year_to.has_value()
  103. ? format_time(*dst_offset.year_to + 1)
  104. : max_year_as_time,
  105. dst_offset.in_effect,
  106. dst_offset.format);
  107. }
  108. };
  109. template<>
  110. struct AK::Formatter<TimeZone::TimeZoneIdentifier> : Formatter<FormatString> {
  111. ErrorOr<void> format(FormatBuilder& builder, TimeZone::TimeZoneIdentifier const& time_zone)
  112. {
  113. return Formatter<FormatString>::format(builder,
  114. "{{ \"{}\"sv, IsLink::{} }}"sv,
  115. time_zone.name,
  116. time_zone.is_link == TimeZone::IsLink::Yes ? "Yes"sv : "No"sv);
  117. }
  118. };
  119. template<>
  120. struct AK::Formatter<TimeZone::Coordinate> : Formatter<FormatString> {
  121. ErrorOr<void> format(FormatBuilder& builder, TimeZone::Coordinate const& coordinate)
  122. {
  123. return Formatter<FormatString>::format(builder,
  124. "{{ {}, {}, {} }}"sv,
  125. coordinate.degrees,
  126. coordinate.minutes,
  127. coordinate.seconds);
  128. }
  129. };
  130. template<>
  131. struct AK::Formatter<TimeZone::Location> : Formatter<FormatString> {
  132. ErrorOr<void> format(FormatBuilder& builder, TimeZone::Location const& location)
  133. {
  134. return Formatter<FormatString>::format(builder,
  135. "{{ {}, {} }}"sv,
  136. location.latitude,
  137. location.longitude);
  138. }
  139. };
  140. static Optional<DateTime> parse_date_time(ReadonlySpan<StringView> segments)
  141. {
  142. auto comment_index = find_index(segments.begin(), segments.end(), "#"sv);
  143. if (comment_index != segments.size())
  144. segments = segments.slice(0, comment_index);
  145. if (segments.is_empty())
  146. return {};
  147. DateTime date_time {};
  148. date_time.year = segments[0].to_number<unsigned>().value();
  149. if (segments.size() > 1)
  150. date_time.month = find_index(short_month_names.begin(), short_month_names.end(), segments[1]) + 1;
  151. if (segments.size() > 2) {
  152. if (segments[2].starts_with("last"sv)) {
  153. auto weekday = segments[2].substring_view("last"sv.length());
  154. date_time.last_weekday = find_index(short_day_names.begin(), short_day_names.end(), weekday);
  155. } else if (auto index = segments[2].find(">="sv); index.has_value()) {
  156. auto weekday = segments[2].substring_view(0, *index);
  157. date_time.after_weekday = find_index(short_day_names.begin(), short_day_names.end(), weekday);
  158. auto day = segments[2].substring_view(*index + ">="sv.length());
  159. date_time.day = day.to_number<unsigned>().value();
  160. } else if (auto index = segments[2].find("<="sv); index.has_value()) {
  161. auto weekday = segments[2].substring_view(0, *index);
  162. date_time.before_weekday = find_index(short_day_names.begin(), short_day_names.end(), weekday);
  163. auto day = segments[2].substring_view(*index + "<="sv.length());
  164. date_time.day = day.to_number<unsigned>().value();
  165. } else {
  166. date_time.day = segments[2].to_number<unsigned>().value();
  167. }
  168. }
  169. if (segments.size() > 3) {
  170. // FIXME: Some times end with a letter, e.g. "2:00u" and "2:00s". Figure out what this means and handle it.
  171. auto time_segments = segments[3].split_view(':');
  172. date_time.hour = time_segments[0].to_number<int>().value();
  173. date_time.minute = time_segments.size() > 1 ? time_segments[1].substring_view(0, 2).to_number<unsigned>().value() : 0;
  174. date_time.second = time_segments.size() > 2 ? time_segments[2].substring_view(0, 2).to_number<unsigned>().value() : 0;
  175. }
  176. return date_time;
  177. }
  178. static i64 parse_time_offset(StringView segment)
  179. {
  180. auto segments = segment.split_view(':');
  181. i64 hours = segments[0].to_number<int>().value();
  182. i64 minutes = segments.size() > 1 ? segments[1].to_number<unsigned>().value() : 0;
  183. i64 seconds = segments.size() > 2 ? segments[2].to_number<unsigned>().value() : 0;
  184. i64 sign = ((hours < 0) || (segments[0] == "-0"sv)) ? -1 : 1;
  185. return (hours * 3600) + sign * ((minutes * 60) + seconds);
  186. }
  187. static void parse_dst_rule(StringView segment, TimeZoneOffset& time_zone)
  188. {
  189. if (segment.contains(':'))
  190. time_zone.dst_offset = parse_time_offset(segment);
  191. else if (segment != "-"sv)
  192. time_zone.dst_rule = segment;
  193. }
  194. static void parse_format(StringView format, TimeZoneData& time_zone_data, TimeZoneOffset& time_zone)
  195. {
  196. auto formats = format.replace("%s"sv, "{}"sv, ReplaceMode::FirstOnly).split('/');
  197. VERIFY(formats.size() <= 2);
  198. time_zone.standard_format = time_zone_data.unique_strings.ensure(formats[0]);
  199. if (formats.size() == 2)
  200. time_zone.daylight_format = time_zone_data.unique_strings.ensure(formats[1]);
  201. else
  202. time_zone.daylight_format = time_zone.standard_format;
  203. }
  204. static Vector<TimeZoneOffset>& parse_zone(StringView zone_line, TimeZoneData& time_zone_data)
  205. {
  206. auto segments = zone_line.split_view_if([](char ch) { return (ch == '\t') || (ch == ' '); });
  207. // "Zone" NAME STDOFF RULES FORMAT [UNTIL]
  208. VERIFY(segments[0] == "Zone"sv);
  209. auto name = segments[1];
  210. TimeZoneOffset time_zone {};
  211. time_zone.offset = parse_time_offset(segments[2]);
  212. parse_dst_rule(segments[3], time_zone);
  213. parse_format(segments[4], time_zone_data, time_zone);
  214. if (segments.size() > 5)
  215. time_zone.until = parse_date_time(segments.span().slice(5));
  216. auto& time_zones = time_zone_data.time_zones.ensure(name);
  217. time_zones.append(move(time_zone));
  218. if (!time_zone_data.time_zone_names.contains_slow(name)) {
  219. time_zone_data.time_zone_names.append(name);
  220. time_zone_data.time_zones_and_links.append({ time_zone_data.time_zone_names.last(), TimeZone::IsLink::No });
  221. }
  222. return time_zones;
  223. }
  224. static void parse_zone_continuation(StringView zone_line, TimeZoneData& time_zone_data, Vector<TimeZoneOffset>& time_zones)
  225. {
  226. auto segments = zone_line.split_view_if([](char ch) { return (ch == '\t') || (ch == ' '); });
  227. // STDOFF RULES FORMAT [UNTIL]
  228. TimeZoneOffset time_zone {};
  229. time_zone.offset = parse_time_offset(segments[0]);
  230. parse_dst_rule(segments[1], time_zone);
  231. parse_format(segments[2], time_zone_data, time_zone);
  232. if (segments.size() > 3)
  233. time_zone.until = parse_date_time(segments.span().slice(3));
  234. time_zones.append(move(time_zone));
  235. }
  236. static void parse_link(StringView link_line, TimeZoneData& time_zone_data)
  237. {
  238. auto segments = link_line.split_view_if([](char ch) { return (ch == '\t') || (ch == ' '); });
  239. // Link TARGET LINK-NAME
  240. VERIFY(segments[0] == "Link"sv);
  241. auto target = segments[1];
  242. auto alias = segments[2];
  243. time_zone_data.time_zone_aliases.append({ target, alias });
  244. time_zone_data.time_zones_and_links.append({ time_zone_data.time_zone_aliases.last().alias, TimeZone::IsLink::Yes });
  245. }
  246. static void parse_rule(StringView rule_line, TimeZoneData& time_zone_data)
  247. {
  248. auto segments = rule_line.split_view_if([](char ch) { return (ch == '\t') || (ch == ' '); });
  249. // Rule NAME FROM TO TYPE IN ON AT SAVE LETTER/S
  250. VERIFY(segments[0] == "Rule"sv);
  251. auto name = segments[1];
  252. DaylightSavingsOffset dst_offset {};
  253. dst_offset.offset = parse_time_offset(segments[8]);
  254. dst_offset.year_from = segments[2].to_number<unsigned>().value();
  255. if (segments[3] == "only")
  256. dst_offset.year_to = dst_offset.year_from;
  257. else if (segments[3] != "max"sv)
  258. dst_offset.year_to = segments[3].to_number<unsigned>().value();
  259. auto in_effect = Array { "0"sv, segments[5], segments[6], segments[7] };
  260. dst_offset.in_effect = parse_date_time(in_effect).release_value();
  261. if (segments[9] != "-"sv)
  262. dst_offset.format = time_zone_data.unique_strings.ensure(segments[9]);
  263. auto& dst_offsets = time_zone_data.dst_offsets.ensure(name);
  264. dst_offsets.append(move(dst_offset));
  265. if (!time_zone_data.dst_offset_names.contains_slow(name))
  266. time_zone_data.dst_offset_names.append(name);
  267. }
  268. static ErrorOr<void> parse_time_zones(StringView time_zone_path, TimeZoneData& time_zone_data)
  269. {
  270. // For reference, the man page for `zic` has the best documentation of the TZDB file format.
  271. auto file = TRY(open_file(time_zone_path, Core::File::OpenMode::Read));
  272. Array<u8, 1024> buffer {};
  273. Vector<TimeZoneOffset>* last_parsed_zone = nullptr;
  274. while (TRY(file->can_read_line())) {
  275. auto line = TRY(file->read_line(buffer));
  276. if (line.is_empty() || line.trim_whitespace(TrimMode::Left).starts_with('#'))
  277. continue;
  278. if (line.starts_with("Zone"sv)) {
  279. last_parsed_zone = &parse_zone(line, time_zone_data);
  280. } else if (line.starts_with('\t')) {
  281. VERIFY(last_parsed_zone != nullptr);
  282. parse_zone_continuation(line, time_zone_data, *last_parsed_zone);
  283. } else {
  284. last_parsed_zone = nullptr;
  285. if (line.starts_with("Link"sv))
  286. parse_link(line, time_zone_data);
  287. else if (line.starts_with("Rule"sv))
  288. parse_rule(line, time_zone_data);
  289. }
  290. }
  291. return {};
  292. }
  293. static ErrorOr<void> parse_time_zone_coordinates(Core::InputBufferedFile& file, TimeZoneData& time_zone_data)
  294. {
  295. auto parse_coordinate = [](auto coordinate) {
  296. VERIFY(coordinate.substring_view(0, 1).is_one_of("+"sv, "-"sv));
  297. TimeZone::Coordinate parsed {};
  298. if (coordinate.length() == 5) {
  299. // ±DDMM
  300. parsed.degrees = coordinate.substring_view(0, 3).template to_number<int>().value();
  301. parsed.minutes = coordinate.substring_view(3).template to_number<int>().value();
  302. } else if (coordinate.length() == 6) {
  303. // ±DDDMM
  304. parsed.degrees = coordinate.substring_view(0, 4).template to_number<int>().value();
  305. parsed.minutes = coordinate.substring_view(4).template to_number<int>().value();
  306. } else if (coordinate.length() == 7) {
  307. // ±DDMMSS
  308. parsed.degrees = coordinate.substring_view(0, 3).template to_number<int>().value();
  309. parsed.minutes = coordinate.substring_view(3, 2).template to_number<int>().value();
  310. parsed.seconds = coordinate.substring_view(5).template to_number<int>().value();
  311. } else if (coordinate.length() == 8) {
  312. // ±DDDDMMSS
  313. parsed.degrees = coordinate.substring_view(0, 4).template to_number<int>().value();
  314. parsed.minutes = coordinate.substring_view(4, 2).template to_number<int>().value();
  315. parsed.seconds = coordinate.substring_view(6).template to_number<int>().value();
  316. } else {
  317. VERIFY_NOT_REACHED();
  318. }
  319. return parsed;
  320. };
  321. Array<u8, 1024> buffer {};
  322. while (TRY(file.can_read_line())) {
  323. auto line = TRY(file.read_line(buffer));
  324. if (line.is_empty() || line.trim_whitespace(TrimMode::Left).starts_with('#'))
  325. continue;
  326. auto segments = line.split_view('\t');
  327. auto regions = segments[0];
  328. auto coordinates = segments[1];
  329. auto zone = segments[2];
  330. VERIFY(time_zone_data.time_zones.contains(zone));
  331. auto index = coordinates.find_any_of("+-"sv, StringView::SearchDirection::Backward).value();
  332. auto latitude = parse_coordinate(coordinates.substring_view(0, index));
  333. auto longitude = parse_coordinate(coordinates.substring_view(index));
  334. time_zone_data.time_zone_coordinates.set(zone, { latitude, longitude });
  335. TRY(regions.for_each_split_view(',', SplitBehavior::Nothing, [&](auto region) -> ErrorOr<void> {
  336. auto index = time_zone_data.unique_strings.ensure(zone);
  337. TRY(time_zone_data.time_zone_regions.ensure(region).try_append(index));
  338. if (!time_zone_data.time_zone_region_names.contains_slow(region))
  339. TRY(time_zone_data.time_zone_region_names.try_append(region));
  340. return {};
  341. }));
  342. }
  343. return {};
  344. }
  345. static void set_dst_rule_indices(TimeZoneData& time_zone_data)
  346. {
  347. for (auto& time_zone : time_zone_data.time_zones) {
  348. for (auto& time_zone_offset : time_zone.value) {
  349. if (!time_zone_offset.dst_rule.has_value())
  350. continue;
  351. auto dst_rule_index = time_zone_data.dst_offset_names.find_first_index(*time_zone_offset.dst_rule);
  352. time_zone_offset.dst_rule_index = static_cast<i32>(dst_rule_index.value());
  353. }
  354. }
  355. }
  356. static ByteString format_identifier(StringView owner, ByteString identifier)
  357. {
  358. constexpr auto gmt_time_zones = Array { "Etc/GMT"sv, "GMT"sv };
  359. for (auto gmt_time_zone : gmt_time_zones) {
  360. if (identifier.starts_with(gmt_time_zone)) {
  361. auto offset = identifier.substring_view(gmt_time_zone.length());
  362. if (offset.starts_with('+'))
  363. identifier = ByteString::formatted("{}_Ahead_{}", gmt_time_zone, offset.substring_view(1));
  364. else if (offset.starts_with('-'))
  365. identifier = ByteString::formatted("{}_Behind_{}", gmt_time_zone, offset.substring_view(1));
  366. }
  367. }
  368. identifier = identifier.replace("-"sv, "_"sv, ReplaceMode::All);
  369. identifier = identifier.replace("/"sv, "_"sv, ReplaceMode::All);
  370. if (all_of(identifier, is_ascii_digit))
  371. return ByteString::formatted("{}_{}", owner[0], identifier);
  372. if (is_ascii_lower_alpha(identifier[0]))
  373. return ByteString::formatted("{:c}{}", to_ascii_uppercase(identifier[0]), identifier.substring_view(1));
  374. return identifier;
  375. }
  376. static ErrorOr<void> generate_time_zone_data_header(Core::InputBufferedFile& file, TimeZoneData& time_zone_data)
  377. {
  378. StringBuilder builder;
  379. SourceGenerator generator { builder };
  380. generator.append(R"~~~(
  381. #pragma once
  382. #include <AK/Types.h>
  383. namespace TimeZone {
  384. )~~~");
  385. generate_enum(generator, format_identifier, "TimeZone"sv, {}, time_zone_data.time_zone_names, time_zone_data.time_zone_aliases);
  386. generate_enum(generator, format_identifier, "DaylightSavingsRule"sv, {}, time_zone_data.dst_offset_names);
  387. generate_enum(generator, format_identifier, "Region"sv, {}, time_zone_data.time_zone_region_names);
  388. generator.append(R"~~~(
  389. }
  390. )~~~");
  391. TRY(file.write_until_depleted(generator.as_string_view().bytes()));
  392. return {};
  393. }
  394. static ErrorOr<void> generate_time_zone_data_implementation(Core::InputBufferedFile& file, TimeZoneData& time_zone_data)
  395. {
  396. StringBuilder builder;
  397. SourceGenerator generator { builder };
  398. generator.set("string_index_type"sv, time_zone_data.unique_strings.type_that_fits());
  399. set_dst_rule_indices(time_zone_data);
  400. generator.append(R"~~~(
  401. #include <AK/Array.h>
  402. #include <AK/BinarySearch.h>
  403. #include <AK/Optional.h>
  404. #include <AK/Span.h>
  405. #include <AK/NumericLimits.h>
  406. #include <AK/StringView.h>
  407. #include <AK/Time.h>
  408. #include <LibTimeZone/TimeZone.h>
  409. #include <LibTimeZone/TimeZoneData.h>
  410. namespace TimeZone {
  411. static constexpr auto max_year_as_time = AK::UnixDateTime::from_unix_time_parts(NumericLimits<u16>::max(), 1, 1, 0, 0, 0, 0);
  412. struct DateTime {
  413. AK::UnixDateTime time_since_epoch() const
  414. {
  415. // FIXME: This implementation does not take last_weekday, after_weekday, or before_weekday into account.
  416. return AK::UnixDateTime::from_unix_time_parts(year, month, day, hour, minute, second, 0);
  417. }
  418. u16 year { 0 };
  419. u8 month { 1 };
  420. u8 day { 1 };
  421. u8 last_weekday { 0 };
  422. u8 after_weekday { 0 };
  423. u8 before_weekday { 0 };
  424. u8 hour { 0 };
  425. u8 minute { 0 };
  426. u8 second { 0 };
  427. };
  428. struct TimeZoneOffset {
  429. i64 offset { 0 };
  430. DateTime until {};
  431. bool has_until { false };
  432. i32 dst_rule { -1 };
  433. i64 dst_offset { 0 };
  434. @string_index_type@ standard_format { 0 };
  435. @string_index_type@ daylight_format { 0 };
  436. };
  437. struct DaylightSavingsOffset {
  438. AK::UnixDateTime time_in_effect(AK::UnixDateTime time) const
  439. {
  440. auto in_effect = this->in_effect;
  441. in_effect.year = seconds_since_epoch_to_year(time.seconds_since_epoch());
  442. return in_effect.time_since_epoch();
  443. }
  444. i64 offset { 0 };
  445. AK::UnixDateTime year_from {};
  446. AK::UnixDateTime year_to {};
  447. DateTime in_effect {};
  448. @string_index_type@ format { 0 };
  449. };
  450. )~~~");
  451. time_zone_data.unique_strings.generate(generator);
  452. auto append_offsets = [&](auto const& name, auto type, auto const& offsets) {
  453. generator.set("name", name);
  454. generator.set("type", type);
  455. generator.set("size", ByteString::number(offsets.size()));
  456. generator.append(R"~~~(
  457. static constexpr Array<@type@, @size@> @name@ { {
  458. )~~~");
  459. for (auto const& offset : offsets)
  460. generator.append(ByteString::formatted(" {},\n", offset));
  461. generator.append("} };\n");
  462. };
  463. generate_mapping(generator, time_zone_data.time_zone_names, "TimeZoneOffset"sv, "s_time_zone_offsets"sv, "s_time_zone_offsets_{}"sv, format_identifier,
  464. [&](auto const& name, auto const& value) {
  465. auto const& time_zone_offsets = time_zone_data.time_zones.find(value)->value;
  466. append_offsets(name, "TimeZoneOffset"sv, time_zone_offsets);
  467. });
  468. generate_mapping(generator, time_zone_data.dst_offset_names, "DaylightSavingsOffset"sv, "s_dst_offsets"sv, "s_dst_offsets_{}"sv, format_identifier,
  469. [&](auto const& name, auto const& value) {
  470. auto const& dst_offsets = time_zone_data.dst_offsets.find(value)->value;
  471. append_offsets(name, "DaylightSavingsOffset"sv, dst_offsets);
  472. });
  473. generate_mapping(generator, time_zone_data.time_zone_region_names, time_zone_data.unique_strings.type_that_fits(), "s_regional_time_zones"sv, "s_regional_time_zones_{}"sv, format_identifier,
  474. [&](auto const& name, auto const& value) {
  475. auto const& time_zones = time_zone_data.time_zone_regions.find(value)->value;
  476. generator.set("name", name);
  477. generator.set("size", ByteString::number(time_zones.size()));
  478. generator.append(R"~~~(
  479. static constexpr Array<@string_index_type@, @size@> @name@ { {)~~~");
  480. bool first = true;
  481. for (auto const& time_zone : time_zones) {
  482. generator.append(first ? " "sv : ", "sv);
  483. generator.append(ByteString::number(time_zone));
  484. first = false;
  485. }
  486. generator.append(" } };");
  487. });
  488. generator.set("size", ByteString::number(time_zone_data.time_zone_names.size()));
  489. generator.append(R"~~~(
  490. static constexpr Array<Location, @size@> s_time_zone_locations { {
  491. )~~~");
  492. for (auto const& time_zone : time_zone_data.time_zone_names) {
  493. auto location = time_zone_data.time_zone_coordinates.get(time_zone).value_or({});
  494. generator.append(ByteString::formatted(" {},\n", location));
  495. }
  496. generator.append("} };\n");
  497. auto append_string_conversions = [&](StringView enum_title, StringView enum_snake, auto const& values, Vector<Alias> const& aliases = {}) -> ErrorOr<void> {
  498. HashValueMap<ByteString> hashes;
  499. TRY(hashes.try_ensure_capacity(values.size()));
  500. auto hash = [](auto const& value) {
  501. return CaseInsensitiveASCIIStringViewTraits::hash(value);
  502. };
  503. for (auto const& value : values)
  504. hashes.set(hash(value), format_identifier(enum_title, value));
  505. for (auto const& alias : aliases)
  506. hashes.set(hash(alias.alias), format_identifier(enum_title, alias.alias));
  507. ValueFromStringOptions options {};
  508. options.sensitivity = CaseSensitivity::CaseInsensitive;
  509. generate_value_from_string(generator, "{}_from_string"sv, enum_title, enum_snake, move(hashes), options);
  510. generate_value_to_string(generator, "{}_to_string"sv, enum_title, enum_snake, format_identifier, values);
  511. return {};
  512. };
  513. TRY(append_string_conversions("TimeZone"sv, "time_zone"sv, time_zone_data.time_zone_names, time_zone_data.time_zone_aliases));
  514. TRY(append_string_conversions("DaylightSavingsRule"sv, "daylight_savings_rule"sv, time_zone_data.dst_offset_names));
  515. TRY(append_string_conversions("Region"sv, "region"sv, time_zone_data.time_zone_region_names));
  516. generator.append(R"~~~(
  517. static Array<DaylightSavingsOffset const*, 2> find_dst_offsets(TimeZoneOffset const& time_zone_offset, AK::UnixDateTime time)
  518. {
  519. auto const& dst_rules = s_dst_offsets[time_zone_offset.dst_rule];
  520. DaylightSavingsOffset const* standard_offset = nullptr;
  521. DaylightSavingsOffset const* daylight_offset = nullptr;
  522. DaylightSavingsOffset const* last_offset = nullptr;
  523. auto preferred_rule = [&](auto* current_offset, auto& new_offset) {
  524. if (!current_offset)
  525. return &new_offset;
  526. auto new_time_in_effect = new_offset.time_in_effect(time);
  527. return (time >= new_time_in_effect) ? &new_offset : current_offset;
  528. };
  529. for (size_t index = 0; (index < dst_rules.size()) && (!standard_offset || !daylight_offset); ++index) {
  530. auto const& dst_rule = dst_rules[index];
  531. if (last_offset == nullptr)
  532. last_offset = &dst_rule;
  533. else if (dst_rule.time_in_effect(dst_rule.year_to) > last_offset->time_in_effect(last_offset->year_to))
  534. last_offset = &dst_rule;
  535. if ((time < dst_rule.year_from) || (time >= dst_rule.year_to))
  536. continue;
  537. if (dst_rule.offset == 0)
  538. standard_offset = preferred_rule(standard_offset, dst_rule);
  539. else
  540. daylight_offset = preferred_rule(daylight_offset, dst_rule);
  541. }
  542. // If there isn't a standard or daylight rule in effect, fall back to the last rule given in the TZDB.
  543. if (!standard_offset) {
  544. VERIFY(last_offset != nullptr);
  545. standard_offset = last_offset;
  546. }
  547. return { standard_offset, daylight_offset ? daylight_offset : standard_offset };
  548. }
  549. static Offset get_active_dst_offset(TimeZoneOffset const& time_zone_offset, AK::UnixDateTime time)
  550. {
  551. auto offsets = find_dst_offsets(time_zone_offset, time);
  552. if (offsets[0] == offsets[1])
  553. return { offsets[0]->offset, InDST::No };
  554. auto standard_time_in_effect = offsets[0]->time_in_effect(time);
  555. auto daylight_time_in_effect = offsets[1]->time_in_effect(time);
  556. if (daylight_time_in_effect < standard_time_in_effect) {
  557. if ((time < daylight_time_in_effect) || (time >= standard_time_in_effect))
  558. return { offsets[0]->offset, InDST::No };
  559. } else {
  560. if ((time >= standard_time_in_effect) && (time < daylight_time_in_effect))
  561. return { offsets[0]->offset, InDST::No };
  562. }
  563. return { offsets[1]->offset, InDST::Yes };
  564. }
  565. static TimeZoneOffset const& find_time_zone_offset(TimeZone time_zone, AK::UnixDateTime time)
  566. {
  567. auto const& time_zone_offsets = s_time_zone_offsets[to_underlying(time_zone)];
  568. size_t index = 0;
  569. for (; index < time_zone_offsets.size(); ++index) {
  570. auto const& time_zone_offset = time_zone_offsets[index];
  571. if (!time_zone_offset.has_until || (time_zone_offset.until.time_since_epoch() > time))
  572. break;
  573. }
  574. VERIFY(index < time_zone_offsets.size());
  575. return time_zone_offsets[index];
  576. }
  577. Optional<Offset> get_time_zone_offset(TimeZone time_zone, AK::UnixDateTime time)
  578. {
  579. auto const& time_zone_offset = find_time_zone_offset(time_zone, time);
  580. Offset dst_offset {};
  581. if (time_zone_offset.dst_rule != -1) {
  582. dst_offset = get_active_dst_offset(time_zone_offset, time);
  583. } else {
  584. auto in_dst = time_zone_offset.dst_offset == 0 ? InDST::No : InDST::Yes;
  585. dst_offset = { time_zone_offset.dst_offset, in_dst };
  586. }
  587. dst_offset.seconds += time_zone_offset.offset;
  588. return dst_offset;
  589. }
  590. Optional<Array<NamedOffset, 2>> get_named_time_zone_offsets(TimeZone time_zone, AK::UnixDateTime time)
  591. {
  592. auto const& time_zone_offset = find_time_zone_offset(time_zone, time);
  593. Array<NamedOffset, 2> named_offsets;
  594. auto format_name = [](auto format, auto offset) -> ByteString {
  595. if (offset == 0)
  596. return decode_string(format).replace("{}"sv, ""sv, ReplaceMode::FirstOnly);
  597. return ByteString::formatted(decode_string(format), decode_string(offset));
  598. };
  599. auto set_named_offset = [&](auto& named_offset, auto dst_offset, auto in_dst, auto format, auto offset) {
  600. named_offset.seconds = time_zone_offset.offset + dst_offset;
  601. named_offset.in_dst = in_dst;
  602. named_offset.name = format_name(format, offset);
  603. };
  604. if (time_zone_offset.dst_rule != -1) {
  605. auto offsets = find_dst_offsets(time_zone_offset, time);
  606. auto in_dst = offsets[1]->offset == 0 ? InDST::No : InDST::Yes;
  607. set_named_offset(named_offsets[0], offsets[0]->offset, InDST::No, time_zone_offset.standard_format, offsets[0]->format);
  608. set_named_offset(named_offsets[1], offsets[1]->offset, in_dst, time_zone_offset.daylight_format, offsets[1]->format);
  609. } else {
  610. auto in_dst = time_zone_offset.dst_offset == 0 ? InDST::No : InDST::Yes;
  611. set_named_offset(named_offsets[0], time_zone_offset.dst_offset, in_dst, time_zone_offset.standard_format, 0);
  612. set_named_offset(named_offsets[1], time_zone_offset.dst_offset, in_dst, time_zone_offset.daylight_format, 0);
  613. }
  614. return named_offsets;
  615. }
  616. Optional<Location> get_time_zone_location(TimeZone time_zone)
  617. {
  618. auto is_valid_coordinate = [](auto const& coordinate) {
  619. return (coordinate.degrees != 0) || (coordinate.minutes != 0) || (coordinate.seconds != 0);
  620. };
  621. auto const& location = s_time_zone_locations[to_underlying(time_zone)];
  622. if (is_valid_coordinate(location.latitude) && is_valid_coordinate(location.longitude))
  623. return location;
  624. return {};
  625. }
  626. Vector<StringView> time_zones_in_region(StringView region)
  627. {
  628. auto region_value = region_from_string(region);
  629. if (!region_value.has_value())
  630. return {};
  631. auto region_index = to_underlying(*region_value);
  632. auto const& regional_time_zones = s_regional_time_zones[region_index];
  633. Vector<StringView> time_zones;
  634. time_zones.ensure_capacity(regional_time_zones.size());
  635. for (auto time_zone : regional_time_zones)
  636. time_zones.unchecked_append(decode_string(time_zone));
  637. return time_zones;
  638. }
  639. )~~~");
  640. quick_sort(time_zone_data.time_zones_and_links, [](auto const& lhs, auto const& rhs) {
  641. return lhs.name < rhs.name;
  642. });
  643. generator.set("time_zones_and_links_size", MUST(String::number(time_zone_data.time_zones_and_links.size())));
  644. generator.append(R"~~~(
  645. ReadonlySpan<TimeZoneIdentifier> all_time_zones()
  646. {
  647. static constexpr Array<TimeZoneIdentifier, @time_zones_and_links_size@> time_zones_and_links { {)~~~");
  648. bool first = true;
  649. for (auto const& zone : time_zone_data.time_zones_and_links) {
  650. generator.append(first ? " "sv : ", "sv);
  651. generator.append(MUST(String::formatted("{}", zone)));
  652. first = false;
  653. }
  654. generator.append(R"~~~( } };
  655. return time_zones_and_links.span();
  656. }
  657. }
  658. )~~~");
  659. TRY(file.write_until_depleted(generator.as_string_view().bytes()));
  660. return {};
  661. }
  662. ErrorOr<int> serenity_main(Main::Arguments arguments)
  663. {
  664. StringView generated_header_path;
  665. StringView generated_implementation_path;
  666. StringView time_zone_coordinates_path;
  667. Vector<StringView> time_zone_paths;
  668. Core::ArgsParser args_parser;
  669. args_parser.add_option(generated_header_path, "Path to the time zone data header file to generate", "generated-header-path", 'h', "generated-header-path");
  670. args_parser.add_option(generated_implementation_path, "Path to the time zone data implementation file to generate", "generated-implementation-path", 'c', "generated-implementation-path");
  671. args_parser.add_option(time_zone_coordinates_path, "Path to the time zone data coordinates file", "time-zone-coordinates-path", 'z', "time-zone-coordinates-path");
  672. args_parser.add_positional_argument(time_zone_paths, "Paths to the time zone database files", "time-zone-paths");
  673. args_parser.parse(arguments);
  674. auto generated_header_file = TRY(open_file(generated_header_path, Core::File::OpenMode::Write));
  675. auto generated_implementation_file = TRY(open_file(generated_implementation_path, Core::File::OpenMode::Write));
  676. auto time_zone_coordinates_file = TRY(open_file(time_zone_coordinates_path, Core::File::OpenMode::Read));
  677. TimeZoneData time_zone_data {};
  678. for (auto time_zone_path : time_zone_paths)
  679. TRY(parse_time_zones(time_zone_path, time_zone_data));
  680. TRY(parse_time_zone_coordinates(*time_zone_coordinates_file, time_zone_data));
  681. TRY(generate_time_zone_data_header(*generated_header_file, time_zone_data));
  682. TRY(generate_time_zone_data_implementation(*generated_implementation_file, time_zone_data));
  683. return 0;
  684. }