jcs.org
Serenity Operating System
1/*
2 * Copyright (c) 2021-2023, Tim Flynn <trflynn89@serenityos.org>
3 *
4 * SPDX-License-Identifier: BSD-2-Clause
5 */
6
7#include "../LibUnicode/GeneratorUtil.h" // FIXME: Move this somewhere common.
8#include <AK/AllOf.h>
9#include <AK/CharacterTypes.h>
10#include <AK/DeprecatedString.h>
11#include <AK/Error.h>
12#include <AK/Find.h>
13#include <AK/Format.h>
14#include <AK/GenericLexer.h>
15#include <AK/HashFunctions.h>
16#include <AK/HashMap.h>
17#include <AK/JsonObject.h>
18#include <AK/JsonParser.h>
19#include <AK/JsonValue.h>
20#include <AK/LexicalPath.h>
21#include <AK/SourceGenerator.h>
22#include <AK/StringBuilder.h>
23#include <AK/Traits.h>
24#include <AK/Utf8View.h>
25#include <LibCore/ArgsParser.h>
26#include <LibCore/DirIterator.h>
27#include <LibLocale/DateTimeFormat.h>
28#include <LibTimeZone/TimeZone.h>
29
30struct CalendarPattern : public Locale::CalendarPattern {
31 bool contains_only_date_fields() const
32 {
33 return !day_period.has_value() && !hour.has_value() && !minute.has_value() && !second.has_value() && !fractional_second_digits.has_value() && !time_zone_name.has_value();
34 }
35
36 bool contains_only_time_fields() const
37 {
38 return !weekday.has_value() && !era.has_value() && !year.has_value() && !month.has_value() && !day.has_value();
39 }
40
41 unsigned hash() const
42 {
43 auto hash = pair_int_hash(pattern_index, pattern12_index);
44 hash = pair_int_hash(hash, skeleton_index);
45
46 auto hash_field = [&](auto const& field) {
47 if (field.has_value())
48 hash = pair_int_hash(hash, static_cast<u8>(*field));
49 else
50 hash = pair_int_hash(hash, -1);
51 };
52
53 hash_field(era);
54 hash_field(year);
55 hash_field(month);
56 hash_field(weekday);
57 hash_field(day);
58 hash_field(day_period);
59 hash_field(hour);
60 hash_field(minute);
61 hash_field(second);
62 hash_field(fractional_second_digits);
63 hash_field(time_zone_name);
64
65 return hash;
66 }
67
68 bool operator==(CalendarPattern const& other) const
69 {
70 return (skeleton_index == other.skeleton_index)
71 && (pattern_index == other.pattern_index)
72 && (pattern12_index == other.pattern12_index)
73 && (era == other.era)
74 && (year == other.year)
75 && (month == other.month)
76 && (weekday == other.weekday)
77 && (day == other.day)
78 && (day_period == other.day_period)
79 && (hour == other.hour)
80 && (minute == other.minute)
81 && (second == other.second)
82 && (fractional_second_digits == other.fractional_second_digits)
83 && (time_zone_name == other.time_zone_name);
84 }
85
86 size_t skeleton_index { 0 };
87 size_t pattern_index { 0 };
88 size_t pattern12_index { 0 };
89};
90
91template<>
92struct AK::Formatter<CalendarPattern> : Formatter<FormatString> {
93 ErrorOr<void> format(FormatBuilder& builder, CalendarPattern const& pattern)
94 {
95 auto field_to_i8 = [](auto const& field) -> i8 {
96 if (!field.has_value())
97 return -1;
98 return static_cast<i8>(*field);
99 };
100
101 return Formatter<FormatString>::format(builder,
102 "{{ {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {} }}"sv,
103 pattern.skeleton_index,
104 pattern.pattern_index,
105 pattern.pattern12_index,
106 field_to_i8(pattern.era),
107 field_to_i8(pattern.year),
108 field_to_i8(pattern.month),
109 field_to_i8(pattern.weekday),
110 field_to_i8(pattern.day),
111 field_to_i8(pattern.day_period),
112 field_to_i8(pattern.hour),
113 field_to_i8(pattern.minute),
114 field_to_i8(pattern.second),
115 field_to_i8(pattern.fractional_second_digits),
116 field_to_i8(pattern.time_zone_name));
117 }
118};
119
120template<>
121struct AK::Traits<CalendarPattern> : public GenericTraits<CalendarPattern> {
122 static unsigned hash(CalendarPattern const& c) { return c.hash(); }
123};
124
125struct CalendarRangePattern : public CalendarPattern {
126 unsigned hash() const
127 {
128 auto hash = CalendarPattern::hash();
129
130 if (field.has_value())
131 hash = pair_int_hash(hash, static_cast<u8>(*field));
132 hash = pair_int_hash(hash, start_range);
133 hash = pair_int_hash(hash, separator);
134 hash = pair_int_hash(hash, end_range);
135
136 return hash;
137 }
138
139 bool operator==(CalendarRangePattern const& other) const
140 {
141 if (!CalendarPattern::operator==(other))
142 return false;
143
144 return (field == other.field)
145 && (start_range == other.start_range)
146 && (separator == other.separator)
147 && (end_range == other.end_range);
148 }
149
150 Optional<Locale::CalendarRangePattern::Field> field {};
151 size_t start_range { 0 };
152 size_t separator { 0 };
153 size_t end_range { 0 };
154};
155
156template<>
157struct AK::Formatter<CalendarRangePattern> : Formatter<FormatString> {
158 ErrorOr<void> format(FormatBuilder& builder, CalendarRangePattern const& pattern)
159 {
160 auto field_to_i8 = [](auto const& field) -> i8 {
161 if (!field.has_value())
162 return -1;
163 return static_cast<i8>(*field);
164 };
165
166 return Formatter<FormatString>::format(builder,
167 "{{ {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {} }}"sv,
168 pattern.skeleton_index,
169 field_to_i8(pattern.field),
170 pattern.start_range,
171 pattern.separator,
172 pattern.end_range,
173 field_to_i8(pattern.era),
174 field_to_i8(pattern.year),
175 field_to_i8(pattern.month),
176 field_to_i8(pattern.weekday),
177 field_to_i8(pattern.day),
178 field_to_i8(pattern.day_period),
179 field_to_i8(pattern.hour),
180 field_to_i8(pattern.minute),
181 field_to_i8(pattern.second),
182 field_to_i8(pattern.fractional_second_digits),
183 field_to_i8(pattern.time_zone_name));
184 }
185};
186
187template<>
188struct AK::Traits<CalendarRangePattern> : public GenericTraits<CalendarRangePattern> {
189 static unsigned hash(CalendarRangePattern const& c) { return c.hash(); }
190};
191
192struct CalendarFormat {
193 unsigned hash() const
194 {
195 auto hash = pair_int_hash(full_format, long_format);
196 hash = pair_int_hash(hash, medium_format);
197 hash = pair_int_hash(hash, short_format);
198 return hash;
199 }
200
201 bool operator==(CalendarFormat const& other) const
202 {
203 return (full_format == other.full_format)
204 && (long_format == other.long_format)
205 && (medium_format == other.medium_format)
206 && (short_format == other.short_format);
207 }
208
209 size_t full_format { 0 };
210 size_t long_format { 0 };
211 size_t medium_format { 0 };
212 size_t short_format { 0 };
213};
214
215template<>
216struct AK::Formatter<CalendarFormat> : Formatter<FormatString> {
217 ErrorOr<void> format(FormatBuilder& builder, CalendarFormat const& pattern)
218 {
219 return Formatter<FormatString>::format(builder,
220 "{{ {}, {}, {}, {} }}"sv,
221 pattern.full_format,
222 pattern.long_format,
223 pattern.medium_format,
224 pattern.short_format);
225 }
226};
227
228template<>
229struct AK::Traits<CalendarFormat> : public GenericTraits<CalendarFormat> {
230 static unsigned hash(CalendarFormat const& c) { return c.hash(); }
231};
232
233using SymbolList = Vector<size_t>;
234
235struct CalendarSymbols {
236 unsigned hash() const
237 {
238 auto hash = pair_int_hash(narrow_symbols, short_symbols);
239 hash = pair_int_hash(hash, long_symbols);
240 return hash;
241 }
242
243 bool operator==(CalendarSymbols const& other) const
244 {
245 return (narrow_symbols == other.narrow_symbols)
246 && (short_symbols == other.short_symbols)
247 && (long_symbols == other.long_symbols);
248 }
249
250 size_t narrow_symbols { 0 };
251 size_t short_symbols { 0 };
252 size_t long_symbols { 0 };
253};
254
255template<>
256struct AK::Formatter<CalendarSymbols> : Formatter<FormatString> {
257 ErrorOr<void> format(FormatBuilder& builder, CalendarSymbols const& symbols)
258 {
259 return Formatter<FormatString>::format(builder,
260 "{{ {}, {}, {} }}"sv,
261 symbols.narrow_symbols,
262 symbols.short_symbols,
263 symbols.long_symbols);
264 }
265};
266
267template<>
268struct AK::Traits<CalendarSymbols> : public GenericTraits<CalendarSymbols> {
269 static unsigned hash(CalendarSymbols const& c) { return c.hash(); }
270};
271
272using CalendarPatternList = Vector<size_t>;
273using CalendarRangePatternList = Vector<size_t>;
274using CalendarSymbolsList = Vector<size_t>;
275
276struct Calendar {
277 unsigned hash() const
278 {
279 auto hash = int_hash(date_formats);
280 hash = pair_int_hash(hash, time_formats);
281 hash = pair_int_hash(hash, date_time_formats);
282 hash = pair_int_hash(hash, available_formats);
283 hash = pair_int_hash(hash, default_range_format);
284 hash = pair_int_hash(hash, range_formats);
285 hash = pair_int_hash(hash, range12_formats);
286 hash = pair_int_hash(hash, symbols);
287 return hash;
288 }
289
290 bool operator==(Calendar const& other) const
291 {
292 return (date_formats == other.date_formats)
293 && (time_formats == other.time_formats)
294 && (date_time_formats == other.date_time_formats)
295 && (available_formats == other.available_formats)
296 && (default_range_format == other.default_range_format)
297 && (range_formats == other.range_formats)
298 && (range12_formats == other.range12_formats)
299 && (symbols == other.symbols);
300 }
301
302 size_t date_formats { 0 };
303 size_t time_formats { 0 };
304 size_t date_time_formats { 0 };
305 size_t available_formats { 0 };
306
307 size_t default_range_format { 0 };
308 size_t range_formats { 0 };
309 size_t range12_formats { 0 };
310
311 size_t symbols { 0 };
312};
313
314template<>
315struct AK::Formatter<Calendar> : Formatter<FormatString> {
316 ErrorOr<void> format(FormatBuilder& builder, Calendar const& calendar)
317 {
318 return Formatter<FormatString>::format(builder,
319 "{{ {}, {}, {}, {}, {}, {}, {}, {} }}"sv,
320 calendar.date_formats,
321 calendar.time_formats,
322 calendar.date_time_formats,
323 calendar.available_formats,
324 calendar.default_range_format,
325 calendar.range_formats,
326 calendar.range12_formats,
327 calendar.symbols);
328 }
329};
330
331template<>
332struct AK::Traits<Calendar> : public GenericTraits<Calendar> {
333 static unsigned hash(Calendar const& c) { return c.hash(); }
334};
335
336struct TimeZoneNames {
337 unsigned hash() const
338 {
339 auto hash = pair_int_hash(short_standard_name, long_standard_name);
340 hash = pair_int_hash(hash, short_daylight_name);
341 hash = pair_int_hash(hash, long_daylight_name);
342 hash = pair_int_hash(hash, short_generic_name);
343 hash = pair_int_hash(hash, long_generic_name);
344
345 return hash;
346 }
347
348 bool operator==(TimeZoneNames const& other) const
349 {
350 return (short_standard_name == other.short_standard_name)
351 && (long_standard_name == other.long_standard_name)
352 && (short_daylight_name == other.short_daylight_name)
353 && (long_daylight_name == other.long_daylight_name)
354 && (short_generic_name == other.short_generic_name)
355 && (long_generic_name == other.long_generic_name);
356 }
357
358 size_t short_standard_name { 0 };
359 size_t long_standard_name { 0 };
360
361 size_t short_daylight_name { 0 };
362 size_t long_daylight_name { 0 };
363
364 size_t short_generic_name { 0 };
365 size_t long_generic_name { 0 };
366};
367
368template<>
369struct AK::Formatter<TimeZoneNames> : Formatter<FormatString> {
370 ErrorOr<void> format(FormatBuilder& builder, TimeZoneNames const& time_zone)
371 {
372 return Formatter<FormatString>::format(builder,
373 "{{ {}, {}, {}, {}, {}, {} }}"sv,
374 time_zone.short_standard_name,
375 time_zone.long_standard_name,
376 time_zone.short_daylight_name,
377 time_zone.long_daylight_name,
378 time_zone.short_generic_name,
379 time_zone.long_generic_name);
380 }
381};
382
383template<>
384struct AK::Traits<TimeZoneNames> : public GenericTraits<TimeZoneNames> {
385 static unsigned hash(TimeZoneNames const& t) { return t.hash(); }
386};
387
388struct TimeZoneFormat {
389 unsigned hash() const
390 {
391 auto hash = int_hash(symbol_ahead_sign);
392 hash = pair_int_hash(hash, symbol_ahead_separator);
393 hash = pair_int_hash(hash, symbol_behind_sign);
394 hash = pair_int_hash(hash, symbol_behind_separator);
395 hash = pair_int_hash(hash, gmt_format);
396 hash = pair_int_hash(hash, gmt_zero_format);
397 return hash;
398 }
399
400 bool operator==(TimeZoneFormat const& other) const
401 {
402 return (symbol_ahead_sign == other.symbol_ahead_sign)
403 && (symbol_ahead_separator == other.symbol_ahead_separator)
404 && (symbol_behind_sign == other.symbol_behind_sign)
405 && (symbol_behind_separator == other.symbol_behind_separator)
406 && (gmt_format == other.gmt_format)
407 && (gmt_zero_format == other.gmt_zero_format);
408 }
409
410 size_t symbol_ahead_sign { 0 };
411 size_t symbol_ahead_separator { 0 };
412
413 size_t symbol_behind_sign { 0 };
414 size_t symbol_behind_separator { 0 };
415
416 size_t gmt_format { 0 };
417 size_t gmt_zero_format { 0 };
418};
419
420template<>
421struct AK::Formatter<TimeZoneFormat> : Formatter<FormatString> {
422 ErrorOr<void> format(FormatBuilder& builder, TimeZoneFormat const& time_zone_format)
423 {
424 return Formatter<FormatString>::format(builder, "{{ {}, {}, {}, {}, {}, {} }}"sv,
425 time_zone_format.symbol_ahead_sign,
426 time_zone_format.symbol_ahead_separator,
427 time_zone_format.symbol_behind_sign,
428 time_zone_format.symbol_behind_separator,
429 time_zone_format.gmt_format,
430 time_zone_format.gmt_zero_format);
431 }
432};
433
434template<>
435struct AK::Traits<TimeZoneFormat> : public GenericTraits<TimeZoneFormat> {
436 static unsigned hash(TimeZoneFormat const& t) { return t.hash(); }
437};
438
439struct DayPeriod {
440 unsigned hash() const
441 {
442 auto hash = int_hash(static_cast<u8>(day_period));
443 hash = pair_int_hash(hash, begin);
444 hash = pair_int_hash(hash, end);
445 return hash;
446 }
447
448 bool operator==(DayPeriod const& other) const
449 {
450 return (day_period == other.day_period)
451 && (begin == other.begin)
452 && (end == other.end);
453 }
454
455 Locale::DayPeriod day_period {};
456 u8 begin { 0 };
457 u8 end { 0 };
458};
459
460template<>
461struct AK::Formatter<DayPeriod> : Formatter<FormatString> {
462 ErrorOr<void> format(FormatBuilder& builder, DayPeriod const& day_period)
463 {
464 return Formatter<FormatString>::format(builder,
465 "{{ {}, {}, {} }}"sv,
466 static_cast<u8>(day_period.day_period),
467 day_period.begin,
468 day_period.end);
469 }
470};
471
472template<>
473struct AK::Traits<DayPeriod> : public GenericTraits<DayPeriod> {
474 static unsigned hash(DayPeriod const& d) { return d.hash(); }
475};
476
477using TimeZoneNamesList = Vector<size_t>;
478using DayPeriodList = Vector<size_t>;
479using HourCycleList = Vector<Locale::HourCycle>;
480
481template<>
482struct AK::Formatter<Locale::HourCycle> : Formatter<FormatString> {
483 ErrorOr<void> format(FormatBuilder& builder, Locale::HourCycle hour_cycle)
484 {
485 return builder.put_u64(to_underlying(hour_cycle));
486 }
487};
488
489struct LocaleData {
490 HashMap<DeprecatedString, size_t> calendars;
491
492 size_t time_zones { 0 };
493 size_t time_zone_formats { 0 };
494
495 size_t day_periods { 0 };
496};
497
498struct CLDR {
499 UniqueStringStorage unique_strings;
500 UniqueStorage<CalendarPattern> unique_patterns;
501 UniqueStorage<CalendarPatternList> unique_pattern_lists;
502 UniqueStorage<CalendarRangePattern> unique_range_patterns;
503 UniqueStorage<CalendarRangePatternList> unique_range_pattern_lists;
504 UniqueStorage<CalendarFormat> unique_formats;
505 UniqueStorage<SymbolList> unique_symbol_lists;
506 UniqueStorage<CalendarSymbols> unique_calendar_symbols;
507 UniqueStorage<CalendarSymbolsList> unique_calendar_symbols_lists;
508 UniqueStorage<Calendar> unique_calendars;
509 UniqueStorage<TimeZoneNames> unique_time_zones;
510 UniqueStorage<TimeZoneNamesList> unique_time_zone_lists;
511 UniqueStorage<TimeZoneFormat> unique_time_zone_formats;
512 UniqueStorage<DayPeriod> unique_day_periods;
513 UniqueStorage<DayPeriodList> unique_day_period_lists;
514 UniqueStorage<HourCycleList> unique_hour_cycle_lists;
515
516 HashMap<DeprecatedString, LocaleData> locales;
517
518 HashMap<DeprecatedString, size_t> hour_cycles;
519 Vector<DeprecatedString> hour_cycle_regions;
520
521 HashMap<DeprecatedString, u8> minimum_days;
522 Vector<DeprecatedString> minimum_days_regions;
523
524 HashMap<DeprecatedString, Locale::Weekday> first_day;
525 Vector<DeprecatedString> first_day_regions;
526
527 HashMap<DeprecatedString, Locale::Weekday> weekend_start;
528 Vector<DeprecatedString> weekend_start_regions;
529
530 HashMap<DeprecatedString, Locale::Weekday> weekend_end;
531 Vector<DeprecatedString> weekend_end_regions;
532
533 HashMap<DeprecatedString, Vector<TimeZone::TimeZone>> meta_zones;
534 Vector<DeprecatedString> time_zones { "UTC"sv };
535
536 Vector<DeprecatedString> calendars;
537};
538
539static Optional<Locale::DayPeriod> day_period_from_string(StringView day_period)
540{
541 if (day_period == "am"sv)
542 return Locale::DayPeriod::AM;
543 if (day_period == "pm"sv)
544 return Locale::DayPeriod::PM;
545 if (day_period == "noon"sv)
546 return Locale::DayPeriod::Noon;
547 if (day_period == "morning1"sv)
548 return Locale::DayPeriod::Morning1;
549 if (day_period == "morning2"sv)
550 return Locale::DayPeriod::Morning2;
551 if (day_period == "afternoon1"sv)
552 return Locale::DayPeriod::Afternoon1;
553 if (day_period == "afternoon2"sv)
554 return Locale::DayPeriod::Afternoon2;
555 if (day_period == "evening1"sv)
556 return Locale::DayPeriod::Evening1;
557 if (day_period == "evening2"sv)
558 return Locale::DayPeriod::Evening2;
559 if (day_period == "night1"sv)
560 return Locale::DayPeriod::Night1;
561 if (day_period == "night2"sv)
562 return Locale::DayPeriod::Night2;
563 return {};
564}
565
566static ErrorOr<void> parse_hour_cycles(DeprecatedString core_path, CLDR& cldr)
567{
568 // https://unicode.org/reports/tr35/tr35-dates.html#Time_Data
569 LexicalPath time_data_path(move(core_path));
570 time_data_path = time_data_path.append("supplemental"sv);
571 time_data_path = time_data_path.append("timeData.json"sv);
572
573 auto time_data = TRY(read_json_file(time_data_path.string()));
574 auto const& supplemental_object = time_data.as_object().get_object("supplemental"sv).value();
575 auto const& time_data_object = supplemental_object.get_object("timeData"sv).value();
576
577 auto parse_hour_cycle = [](StringView hour_cycle) -> Optional<Locale::HourCycle> {
578 if (hour_cycle == "h"sv)
579 return Locale::HourCycle::H12;
580 if (hour_cycle == "H"sv)
581 return Locale::HourCycle::H23;
582 if (hour_cycle == "K"sv)
583 return Locale::HourCycle::H11;
584 if (hour_cycle == "k"sv)
585 return Locale::HourCycle::H24;
586 return {};
587 };
588
589 time_data_object.for_each_member([&](auto const& key, JsonValue const& value) {
590 auto allowed_hour_cycles_string = value.as_object().get_deprecated_string("_allowed"sv).value();
591 auto allowed_hour_cycles = allowed_hour_cycles_string.split_view(' ');
592
593 Vector<Locale::HourCycle> hour_cycles;
594
595 for (auto allowed_hour_cycle : allowed_hour_cycles) {
596 if (auto hour_cycle = parse_hour_cycle(allowed_hour_cycle); hour_cycle.has_value())
597 hour_cycles.append(*hour_cycle);
598 }
599
600 auto hour_cycles_index = cldr.unique_hour_cycle_lists.ensure(move(hour_cycles));
601 cldr.hour_cycles.set(key, hour_cycles_index);
602
603 if (!cldr.hour_cycle_regions.contains_slow(key))
604 cldr.hour_cycle_regions.append(key);
605 });
606
607 return {};
608}
609
610static ErrorOr<void> parse_week_data(DeprecatedString core_path, CLDR& cldr)
611{
612 // https://unicode.org/reports/tr35/tr35-dates.html#Week_Data
613 LexicalPath week_data_path(move(core_path));
614 week_data_path = week_data_path.append("supplemental"sv);
615 week_data_path = week_data_path.append("weekData.json"sv);
616
617 auto week_data = TRY(read_json_file(week_data_path.string()));
618 auto const& supplemental_object = week_data.as_object().get_object("supplemental"sv).value();
619 auto const& week_data_object = supplemental_object.get_object("weekData"sv).value();
620
621 auto parse_weekday = [](StringView day) -> Locale::Weekday {
622 if (day == "sun"sv)
623 return Locale::Weekday::Sunday;
624 if (day == "mon"sv)
625 return Locale::Weekday::Monday;
626 if (day == "tue"sv)
627 return Locale::Weekday::Tuesday;
628 if (day == "wed"sv)
629 return Locale::Weekday::Wednesday;
630 if (day == "thu"sv)
631 return Locale::Weekday::Thursday;
632 if (day == "fri"sv)
633 return Locale::Weekday::Friday;
634 if (day == "sat"sv)
635 return Locale::Weekday::Saturday;
636 VERIFY_NOT_REACHED();
637 };
638
639 auto parse_regional_weekdays = [&](auto const& region, auto const& weekday, auto& weekdays_map, auto& weekday_regions) {
640 if (region.ends_with("alt-variant"sv))
641 return;
642
643 weekdays_map.set(region, parse_weekday(weekday));
644
645 if (!weekday_regions.contains_slow(region))
646 weekday_regions.append(region);
647 };
648
649 auto const& minimum_days_object = week_data_object.get_object("minDays"sv).value();
650 auto const& first_day_object = week_data_object.get_object("firstDay"sv).value();
651 auto const& weekend_start_object = week_data_object.get_object("weekendStart"sv).value();
652 auto const& weekend_end_object = week_data_object.get_object("weekendEnd"sv).value();
653
654 minimum_days_object.for_each_member([&](auto const& region, auto const& value) {
655 auto minimum_days = value.as_string().template to_uint<u8>();
656 cldr.minimum_days.set(region, *minimum_days);
657
658 if (!cldr.minimum_days_regions.contains_slow(region))
659 cldr.minimum_days_regions.append(region);
660 });
661
662 first_day_object.for_each_member([&](auto const& region, auto const& value) {
663 parse_regional_weekdays(region, value.as_string(), cldr.first_day, cldr.first_day_regions);
664 });
665 weekend_start_object.for_each_member([&](auto const& region, auto const& value) {
666 parse_regional_weekdays(region, value.as_string(), cldr.weekend_start, cldr.weekend_start_regions);
667 });
668 weekend_end_object.for_each_member([&](auto const& region, auto const& value) {
669 parse_regional_weekdays(region, value.as_string(), cldr.weekend_end, cldr.weekend_end_regions);
670 });
671
672 return {};
673}
674
675static ErrorOr<void> parse_meta_zones(DeprecatedString core_path, CLDR& cldr)
676{
677 // https://unicode.org/reports/tr35/tr35-dates.html#Metazones
678 LexicalPath meta_zone_path(move(core_path));
679 meta_zone_path = meta_zone_path.append("supplemental"sv);
680 meta_zone_path = meta_zone_path.append("metaZones.json"sv);
681
682 auto meta_zone = TRY(read_json_file(meta_zone_path.string()));
683 auto const& supplemental_object = meta_zone.as_object().get_object("supplemental"sv).value();
684 auto const& meta_zone_object = supplemental_object.get_object("metaZones"sv).value();
685 auto const& meta_zone_array = meta_zone_object.get_array("metazones"sv).value();
686
687 meta_zone_array.for_each([&](JsonValue const& value) {
688 auto const& mapping = value.as_object().get_object("mapZone"sv).value();
689 auto const& meta_zone = mapping.get_deprecated_string("_other"sv).value();
690 auto const& golden_zone = mapping.get_deprecated_string("_type"sv).value();
691
692 if (auto time_zone = TimeZone::time_zone_from_string(golden_zone); time_zone.has_value()) {
693 auto& golden_zones = cldr.meta_zones.ensure(meta_zone);
694 golden_zones.append(*time_zone);
695 }
696 });
697
698 // UTC does not appear in metaZones.json. Define it for convenience so other parsers don't need to check for its existence.
699 if (auto time_zone = TimeZone::time_zone_from_string("UTC"sv); time_zone.has_value())
700 cldr.meta_zones.set("UTC"sv, { *time_zone });
701
702 return {};
703}
704
705static constexpr auto is_char(char ch)
706{
707 return [ch](auto c) { return c == ch; };
708}
709
710// For patterns that are 12-hour aware, we need to generate two patterns: one with the day period
711// (e.g. {ampm}) in the pattern, and one without the day period. We need to take care to remove
712// extra spaces around the day period. Some example expected removals:
713//
714// "{hour}:{minute} {ampm}" becomes "{hour}:{minute}" (remove the space before {ampm})
715// "{ampm} {hour}" becomes "{hour}" (remove the space after {ampm})
716// "{hour}:{minute} {ampm} {timeZoneName}" becomes "{hour}:{minute} {timeZoneName}" (remove one of the spaces around {ampm})
717static ErrorOr<String> remove_period_from_pattern(String pattern)
718{
719 auto is_surrounding_space = [&](auto code_point_iterator) {
720 if (code_point_iterator.done())
721 return false;
722
723 constexpr auto spaces = Array { static_cast<u32>(0x0020), 0x00a0, 0x2009, 0x202f };
724 return spaces.span().contains_slow(*code_point_iterator);
725 };
726
727 auto is_opening = [&](auto code_point_iterator) {
728 if (code_point_iterator.done())
729 return false;
730 return *code_point_iterator == '{';
731 };
732
733 auto is_closing = [&](auto code_point_iterator) {
734 if (code_point_iterator.done())
735 return false;
736 return *code_point_iterator == '}';
737 };
738
739 for (auto remove : AK::Array { "({ampm})"sv, "{ampm}"sv, "({dayPeriod})"sv, "{dayPeriod}"sv }) {
740 auto index = pattern.find_byte_offset(remove);
741 if (!index.has_value())
742 continue;
743
744 Utf8View utf8_pattern { pattern };
745 Utf8CodePointIterator before_removal;
746 Utf8CodePointIterator after_removal;
747
748 for (auto it = utf8_pattern.begin(); utf8_pattern.byte_offset_of(it) < *index; ++it)
749 before_removal = it;
750 if (auto it = utf8_pattern.iterator_at_byte_offset(*index + remove.length()); it != utf8_pattern.end())
751 after_removal = it;
752
753 auto pattern_view = pattern.bytes_as_string_view();
754
755 if (is_surrounding_space(before_removal) && !is_opening(after_removal)) {
756 pattern = TRY(String::formatted("{}{}",
757 pattern_view.substring_view(0, *index - before_removal.underlying_code_point_length_in_bytes()),
758 pattern_view.substring_view(*index + remove.length())));
759 } else if (is_surrounding_space(after_removal) && !is_closing(before_removal)) {
760 pattern = TRY(String::formatted("{}{}",
761 pattern_view.substring_view(0, *index),
762 pattern_view.substring_view(*index + remove.length() + after_removal.underlying_code_point_length_in_bytes())));
763 } else {
764 pattern = TRY(String::formatted("{}{}",
765 pattern_view.substring_view(0, *index),
766 pattern_view.substring_view(*index + remove.length())));
767 }
768 }
769
770 return pattern;
771}
772
773static ErrorOr<Optional<CalendarPattern>> parse_date_time_pattern_raw(DeprecatedString pattern, DeprecatedString skeleton, CLDR& cldr)
774{
775 // https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
776 using Locale::CalendarPatternStyle;
777
778 CalendarPattern format {};
779
780 if (!skeleton.is_empty())
781 format.skeleton_index = cldr.unique_strings.ensure(move(skeleton));
782
783 GenericLexer lexer { pattern };
784 StringBuilder builder;
785 bool hour12 { false };
786
787 while (!lexer.is_eof()) {
788 // Literal strings enclosed by quotes are to be appended to the pattern as-is without further
789 // processing (this just avoids conflicts with the patterns below).
790 if (lexer.next_is(is_quote)) {
791 builder.append(lexer.consume_quoted_string());
792 continue;
793 }
794
795 auto starting_char = lexer.peek();
796 auto segment = lexer.consume_while([&](char ch) { return ch == starting_char; });
797
798 // Era
799 if (all_of(segment, is_char('G'))) {
800 builder.append("{era}"sv);
801
802 if (segment.length() <= 3)
803 format.era = CalendarPatternStyle::Short;
804 else if (segment.length() == 4)
805 format.era = CalendarPatternStyle::Long;
806 else
807 format.era = CalendarPatternStyle::Narrow;
808 }
809
810 // Year
811 else if (all_of(segment, is_any_of("yYuUr"sv))) {
812 builder.append("{year}"sv);
813
814 if (segment.length() == 2)
815 format.year = CalendarPatternStyle::TwoDigit;
816 else
817 format.year = CalendarPatternStyle::Numeric;
818 }
819
820 // Quarter
821 else if (all_of(segment, is_any_of("qQ"sv))) {
822 // Intl.DateTimeFormat does not support quarter formatting, so drop these patterns.
823 return OptionalNone {};
824 }
825
826 // Month
827 else if (all_of(segment, is_any_of("ML"sv))) {
828 builder.append("{month}"sv);
829
830 if (segment.length() == 1)
831 format.month = CalendarPatternStyle::Numeric;
832 else if (segment.length() == 2)
833 format.month = CalendarPatternStyle::TwoDigit;
834 else if (segment.length() == 3)
835 format.month = CalendarPatternStyle::Short;
836 else if (segment.length() == 4)
837 format.month = CalendarPatternStyle::Long;
838 else if (segment.length() == 5)
839 format.month = CalendarPatternStyle::Narrow;
840 } else if (all_of(segment, is_char('l'))) {
841 // Using 'l' for month formatting is deprecated by TR-35, ensure it is not used.
842 return OptionalNone {};
843 }
844
845 // Week
846 else if (all_of(segment, is_any_of("wW"sv))) {
847 // Intl.DateTimeFormat does not support week formatting, so drop these patterns.
848 return OptionalNone {};
849 }
850
851 // Day
852 else if (all_of(segment, is_char('d'))) {
853 builder.append("{day}"sv);
854
855 if (segment.length() == 1)
856 format.day = CalendarPatternStyle::Numeric;
857 else
858 format.day = CalendarPatternStyle::TwoDigit;
859 } else if (all_of(segment, is_any_of("DFg"sv))) {
860 builder.append("{day}"sv);
861 format.day = CalendarPatternStyle::Numeric;
862 }
863
864 // Weekday
865 else if (all_of(segment, is_char('E'))) {
866 builder.append("{weekday}"sv);
867
868 if (segment.length() == 4)
869 format.weekday = CalendarPatternStyle::Long;
870 else if (segment.length() == 5)
871 format.weekday = CalendarPatternStyle::Narrow;
872 else
873 format.weekday = CalendarPatternStyle::Short;
874 } else if (all_of(segment, is_any_of("ec"sv))) {
875 builder.append("{weekday}"sv);
876
877 // TR-35 defines "e", "c", and "cc" as as numeric, and "ee" as 2-digit, but those
878 // pattern styles are not supported by Intl.DateTimeFormat.
879 if (segment.length() <= 2)
880 return OptionalNone {};
881
882 if (segment.length() == 4)
883 format.weekday = CalendarPatternStyle::Long;
884 else if (segment.length() == 5)
885 format.weekday = CalendarPatternStyle::Narrow;
886 else
887 format.weekday = CalendarPatternStyle::Short;
888 }
889
890 // Period
891 else if (all_of(segment, is_any_of("ab"sv))) {
892 builder.append("{ampm}"sv);
893 hour12 = true;
894 } else if (all_of(segment, is_char('B'))) {
895 builder.append("{dayPeriod}"sv);
896 hour12 = true;
897
898 if (segment.length() == 4)
899 format.day_period = CalendarPatternStyle::Long;
900 else if (segment.length() == 5)
901 format.day_period = CalendarPatternStyle::Narrow;
902 else
903 format.day_period = CalendarPatternStyle::Short;
904 }
905
906 // Hour
907 else if (all_of(segment, is_any_of("hHKk"sv))) {
908 builder.append("{hour}"sv);
909
910 if ((segment[0] == 'h') || (segment[0] == 'K'))
911 hour12 = true;
912
913 if (segment.length() == 1)
914 format.hour = CalendarPatternStyle::Numeric;
915 else
916 format.hour = CalendarPatternStyle::TwoDigit;
917 } else if (all_of(segment, is_any_of("jJC"sv))) {
918 // TR-35 indicates these should not be used.
919 return OptionalNone {};
920 }
921
922 // Minute
923 else if (all_of(segment, is_char('m'))) {
924 builder.append("{minute}"sv);
925
926 if (segment.length() == 1)
927 format.minute = CalendarPatternStyle::Numeric;
928 else
929 format.minute = CalendarPatternStyle::TwoDigit;
930 }
931
932 // Second
933 else if (all_of(segment, is_char('s'))) {
934 builder.append("{second}"sv);
935
936 if (segment.length() == 1)
937 format.second = CalendarPatternStyle::Numeric;
938 else
939 format.second = CalendarPatternStyle::TwoDigit;
940 } else if (all_of(segment, is_char('S'))) {
941 builder.append("{fractionalSecondDigits}"sv);
942
943 VERIFY(segment.length() <= 3);
944 format.fractional_second_digits = static_cast<u8>(segment.length());
945 } else if (all_of(segment, is_char('A'))) {
946 // Intl.DateTimeFormat does not support millisecond formatting, so drop these patterns.
947 return OptionalNone {};
948 }
949
950 // Zone
951 else if (all_of(segment, is_any_of("zV"sv))) {
952 builder.append("{timeZoneName}"sv);
953
954 if (segment.length() < 4)
955 format.time_zone_name = CalendarPatternStyle::Short;
956 else
957 format.time_zone_name = CalendarPatternStyle::Long;
958 } else if (all_of(segment, is_any_of("ZOXx"sv))) {
959 builder.append("{timeZoneName}"sv);
960
961 if (segment.length() < 4)
962 format.time_zone_name = CalendarPatternStyle::ShortOffset;
963 else
964 format.time_zone_name = CalendarPatternStyle::LongOffset;
965 } else if (all_of(segment, is_char('v'))) {
966 builder.append("{timeZoneName}"sv);
967
968 if (segment.length() < 4)
969 format.time_zone_name = CalendarPatternStyle::ShortGeneric;
970 else
971 format.time_zone_name = CalendarPatternStyle::LongGeneric;
972 }
973
974 // Non-patterns
975 else {
976 builder.append(segment);
977 }
978 }
979
980 auto parsed_pattern = TRY(builder.to_string());
981
982 if (hour12) {
983 format.pattern = TRY(remove_period_from_pattern(parsed_pattern));
984 format.pattern12 = move(parsed_pattern);
985 } else {
986 format.pattern = move(parsed_pattern);
987 }
988
989 return format;
990}
991
992static ErrorOr<Optional<size_t>> parse_date_time_pattern(DeprecatedString pattern, DeprecatedString skeleton, CLDR& cldr)
993{
994 auto format = TRY(parse_date_time_pattern_raw(move(pattern), move(skeleton), cldr));
995 if (!format.has_value())
996 return OptionalNone {};
997
998 format->pattern_index = cldr.unique_strings.ensure(format->pattern.to_deprecated_string());
999
1000 if (format->pattern12.has_value())
1001 format->pattern12_index = cldr.unique_strings.ensure(format->pattern12->to_deprecated_string());
1002
1003 return Optional<size_t> { cldr.unique_patterns.ensure(format.release_value()) };
1004}
1005
1006template<typename... Chars>
1007static constexpr bool char_is_one_of(char ch, Chars&&... chars)
1008{
1009 return ((ch == chars) || ...);
1010}
1011
1012static ErrorOr<void> parse_interval_patterns(Calendar& calendar, JsonObject const& interval_formats_object, CLDR& cldr)
1013{
1014 // https://unicode.org/reports/tr35/tr35-dates.html#intervalFormats
1015 CalendarRangePatternList range_formats {};
1016 CalendarRangePatternList range12_formats {};
1017
1018 auto name_of_field = [&](char field) {
1019 if (char_is_one_of(field, 'G'))
1020 return Locale::CalendarRangePattern::Field::Era;
1021 if (char_is_one_of(field, 'y', 'Y', 'u', 'U', 'r'))
1022 return Locale::CalendarRangePattern::Field::Year;
1023 if (char_is_one_of(field, 'M', 'L'))
1024 return Locale::CalendarRangePattern::Field::Month;
1025 if (char_is_one_of(field, 'd', 'D', 'F', 'g'))
1026 return Locale::CalendarRangePattern::Field::Day;
1027 if (char_is_one_of(field, 'a', 'b'))
1028 return Locale::CalendarRangePattern::Field::AmPm;
1029 if (char_is_one_of(field, 'B'))
1030 return Locale::CalendarRangePattern::Field::DayPeriod;
1031 if (char_is_one_of(field, 'h', 'H', 'K', 'k'))
1032 return Locale::CalendarRangePattern::Field::Hour;
1033 if (char_is_one_of(field, 'm'))
1034 return Locale::CalendarRangePattern::Field::Minute;
1035 if (char_is_one_of(field, 's'))
1036 return Locale::CalendarRangePattern::Field::Second;
1037 if (char_is_one_of(field, 'S'))
1038 return Locale::CalendarRangePattern::Field::FractionalSecondDigits;
1039
1040 VERIFY_NOT_REACHED();
1041 };
1042
1043 auto split_default_range_pattern = [&](auto skeleton, auto const& pattern) {
1044 auto start_range_end = pattern.find('}').value() + 1;
1045 auto end_range_begin = pattern.find_last('{').value();
1046
1047 auto start_range = pattern.substring_view(0, start_range_end);
1048 auto separator = pattern.substring_view(start_range_end, end_range_begin - start_range_end);
1049 auto end_range = pattern.substring_view(end_range_begin);
1050
1051 CalendarRangePattern format {};
1052 format.skeleton_index = cldr.unique_strings.ensure(skeleton);
1053 format.start_range = cldr.unique_strings.ensure(start_range);
1054 format.separator = cldr.unique_strings.ensure(separator);
1055 format.end_range = cldr.unique_strings.ensure(end_range);
1056
1057 return format;
1058 };
1059
1060 auto split_range_pattern = [&](auto skeleton, auto field, auto const& pattern, auto const& parsed_fields) {
1061 HashMap<StringView, size_t> partitions;
1062 StringView last_partition;
1063
1064 auto begin_index = pattern.find_byte_offset('{');
1065 size_t end_index = 0;
1066
1067 while (begin_index.has_value()) {
1068 end_index = pattern.find_byte_offset('}', *begin_index).value();
1069
1070 auto partition = pattern.bytes_as_string_view().substring_view(*begin_index, end_index - *begin_index);
1071 if (partitions.contains(partition))
1072 break;
1073
1074 partitions.set(partition, *begin_index);
1075 last_partition = partition;
1076
1077 begin_index = pattern.find_byte_offset('{', end_index + 1);
1078 }
1079
1080 VERIFY(begin_index.has_value() && !last_partition.is_empty());
1081 auto start_range_end = partitions.get(last_partition).value() + last_partition.length() + 1;
1082
1083 auto pattern_view = pattern.bytes_as_string_view();
1084 auto start_range = pattern_view.substring_view(0, start_range_end);
1085 auto separator = pattern_view.substring_view(start_range_end, *begin_index - start_range_end);
1086 auto end_range = pattern_view.substring_view(*begin_index);
1087
1088 CalendarRangePattern format {};
1089 format.skeleton_index = cldr.unique_strings.ensure(skeleton);
1090 format.field = field;
1091 format.start_range = cldr.unique_strings.ensure(start_range);
1092 format.separator = cldr.unique_strings.ensure(separator);
1093 format.end_range = cldr.unique_strings.ensure(end_range);
1094
1095 format.for_each_calendar_field_zipped_with(parsed_fields, [](auto& format_field, auto const& parsed_field, auto) {
1096 format_field = parsed_field;
1097 });
1098
1099 return format;
1100 };
1101
1102 TRY(interval_formats_object.try_for_each_member([&](auto const& skeleton, auto const& value) -> ErrorOr<void> {
1103 if (skeleton == "intervalFormatFallback"sv) {
1104 auto range_format = split_default_range_pattern(skeleton, value.as_string());
1105 calendar.default_range_format = cldr.unique_range_patterns.ensure(move(range_format));
1106 return {};
1107 }
1108
1109 TRY(value.as_object().try_for_each_member([&](auto const& field, auto const& pattern) -> ErrorOr<void> {
1110 if (field.ends_with("alt-variant"sv))
1111 return {};
1112
1113 VERIFY(field.length() == 1);
1114 auto name = name_of_field(field[0]);
1115
1116 auto format = TRY(parse_date_time_pattern_raw(pattern.as_string(), skeleton, cldr)).release_value();
1117
1118 auto range_format = split_range_pattern(skeleton, name, format.pattern, format);
1119 range_formats.append(cldr.unique_range_patterns.ensure(move(range_format)));
1120
1121 if (format.pattern12.has_value()) {
1122 auto range12_pattern = split_range_pattern(skeleton, name, *format.pattern12, format);
1123 range12_formats.append(cldr.unique_range_patterns.ensure(move(range12_pattern)));
1124 } else {
1125 range12_formats.append(range_formats.last());
1126 }
1127
1128 return {};
1129 }));
1130
1131 return {};
1132 }));
1133
1134 calendar.range_formats = cldr.unique_range_pattern_lists.ensure(move(range_formats));
1135 calendar.range12_formats = cldr.unique_range_pattern_lists.ensure(move(range12_formats));
1136
1137 return {};
1138}
1139
1140static ErrorOr<void> generate_default_patterns(CalendarPatternList& formats, CLDR& cldr)
1141{
1142 // For compatibility with ICU, we generate a list of default patterns for every locale:
1143 // https://github.com/unicode-org/icu/blob/release-71-1/icu4c/source/i18n/dtptngen.cpp#L1343-L1354=
1144 static constexpr auto default_patterns = Array { "G"sv, "y"sv, "M"sv, "E"sv, "D"sv, "F"sv, "d"sv, "a"sv, "B"sv, "H"sv, "mm"sv, "ss"sv, "SS"sv, "v"sv };
1145
1146 for (auto pattern : default_patterns) {
1147 auto index = TRY(parse_date_time_pattern(pattern, pattern, cldr));
1148 VERIFY(index.has_value());
1149
1150 if (!formats.contains_slow(*index))
1151 formats.append(*index);
1152 }
1153
1154 return {};
1155}
1156
1157static void generate_missing_patterns(Calendar& calendar, CalendarPatternList& formats, Vector<CalendarPattern> date_formats, Vector<CalendarPattern> time_formats, CLDR& cldr)
1158{
1159 // https://unicode.org/reports/tr35/tr35-dates.html#Missing_Skeleton_Fields
1160 auto replace_pattern = [&](auto format, auto time_format, auto date_format) {
1161 auto pattern = cldr.unique_strings.get(format);
1162 auto time_pattern = cldr.unique_strings.get(time_format);
1163 auto date_pattern = cldr.unique_strings.get(date_format);
1164
1165 auto new_pattern = pattern.replace("{0}"sv, time_pattern, ReplaceMode::FirstOnly).replace("{1}"sv, date_pattern, ReplaceMode::FirstOnly);
1166 return cldr.unique_strings.ensure(move(new_pattern));
1167 };
1168
1169 auto inject_fractional_second_digits = [&](auto format) {
1170 auto pattern = cldr.unique_strings.get(format);
1171
1172 auto new_pattern = pattern.replace("{second}"sv, "{second}{decimal}{fractionalSecondDigits}"sv, ReplaceMode::FirstOnly);
1173 return cldr.unique_strings.ensure(move(new_pattern));
1174 };
1175
1176 auto append_if_unique = [&](auto format) {
1177 auto format_index = cldr.unique_patterns.ensure(move(format));
1178
1179 if (!formats.contains_slow(format_index))
1180 formats.append(format_index);
1181 };
1182
1183 Vector<CalendarPattern> time_formats_with_fractional_second_digits;
1184
1185 for (auto const& format : date_formats)
1186 append_if_unique(format);
1187 for (auto const& format : time_formats) {
1188 append_if_unique(format);
1189
1190 if (format.second.has_value() && !format.fractional_second_digits.has_value()) {
1191 auto new_format = format;
1192 new_format.fractional_second_digits = 2;
1193
1194 new_format.pattern_index = inject_fractional_second_digits(new_format.pattern_index);
1195 if (new_format.pattern12_index != 0)
1196 new_format.pattern12_index = inject_fractional_second_digits(new_format.pattern12_index);
1197
1198 time_formats_with_fractional_second_digits.append(new_format);
1199 append_if_unique(move(new_format));
1200 }
1201 }
1202
1203 time_formats.extend(move(time_formats_with_fractional_second_digits));
1204
1205 for (auto const& date_format : date_formats) {
1206 auto const& date_time_formats = cldr.unique_formats.get(calendar.date_time_formats);
1207 size_t date_time_format_index = 0;
1208
1209 if (date_format.month == Locale::CalendarPatternStyle::Long) {
1210 if (date_format.weekday.has_value())
1211 date_time_format_index = date_time_formats.full_format;
1212 else
1213 date_time_format_index = date_time_formats.long_format;
1214 } else if (date_format.month == Locale::CalendarPatternStyle::Short) {
1215 date_time_format_index = date_time_formats.medium_format;
1216 } else {
1217 date_time_format_index = date_time_formats.short_format;
1218 }
1219
1220 for (auto const& time_format : time_formats) {
1221 auto format = cldr.unique_patterns.get(date_time_format_index);
1222
1223 if (time_format.pattern12_index != 0)
1224 format.pattern12_index = replace_pattern(format.pattern_index, time_format.pattern12_index, date_format.pattern_index);
1225 format.pattern_index = replace_pattern(format.pattern_index, time_format.pattern_index, date_format.pattern_index);
1226
1227 format.for_each_calendar_field_zipped_with(date_format, [](auto& field, auto const& date_field, auto) {
1228 if (date_field.has_value())
1229 field = date_field;
1230 });
1231 format.for_each_calendar_field_zipped_with(time_format, [](auto& field, auto const& time_field, auto) {
1232 if (time_field.has_value())
1233 field = time_field;
1234 });
1235
1236 append_if_unique(move(format));
1237 }
1238 }
1239}
1240
1241static void parse_calendar_symbols(Calendar& calendar, JsonObject const& calendar_object, CLDR& cldr)
1242{
1243 auto create_symbol_lists = [](size_t size) {
1244 SymbolList narrow_symbol_list;
1245 SymbolList short_symbol_list;
1246 SymbolList long_symbol_list;
1247
1248 narrow_symbol_list.resize(size);
1249 short_symbol_list.resize(size);
1250 long_symbol_list.resize(size);
1251
1252 return Array<SymbolList, 3> { {
1253 move(narrow_symbol_list),
1254 move(short_symbol_list),
1255 move(long_symbol_list),
1256 } };
1257 };
1258
1259 CalendarSymbolsList symbols_list {};
1260
1261 auto store_symbol_lists = [&](auto symbol, auto symbol_lists) {
1262 auto symbol_index = to_underlying(symbol);
1263 if (symbol_index >= symbols_list.size())
1264 symbols_list.resize(symbol_index + 1);
1265
1266 CalendarSymbols symbols {};
1267 symbols.narrow_symbols = cldr.unique_symbol_lists.ensure(move(symbol_lists[0]));
1268 symbols.short_symbols = cldr.unique_symbol_lists.ensure(move(symbol_lists[1]));
1269 symbols.long_symbols = cldr.unique_symbol_lists.ensure(move(symbol_lists[2]));
1270
1271 auto calendar_symbols_index = cldr.unique_calendar_symbols.ensure(move(symbols));
1272 symbols_list[symbol_index] = calendar_symbols_index;
1273 };
1274
1275 auto parse_era_symbols = [&](auto const& symbols_object) {
1276 auto const& narrow_symbols = symbols_object.get_object("eraNarrow"sv).value();
1277 auto const& short_symbols = symbols_object.get_object("eraAbbr"sv).value();
1278 auto const& long_symbols = symbols_object.get_object("eraNames"sv).value();
1279 auto symbol_lists = create_symbol_lists(2);
1280
1281 auto append_symbol = [&](auto& symbols, auto const& key, auto symbol) {
1282 if (auto key_index = key.to_uint(); key_index.has_value())
1283 symbols[*key_index] = cldr.unique_strings.ensure(move(symbol));
1284 };
1285
1286 narrow_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1287 append_symbol(symbol_lists[0], key, value.as_string());
1288 });
1289 short_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1290 append_symbol(symbol_lists[1], key, value.as_string());
1291 });
1292 long_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1293 append_symbol(symbol_lists[2], key, value.as_string());
1294 });
1295
1296 store_symbol_lists(Locale::CalendarSymbol::Era, move(symbol_lists));
1297 };
1298
1299 auto parse_month_symbols = [&](auto const& symbols_object) {
1300 auto const& narrow_symbols = symbols_object.get_object("narrow"sv).value();
1301 auto const& short_symbols = symbols_object.get_object("abbreviated"sv).value();
1302 auto const& long_symbols = symbols_object.get_object("wide"sv).value();
1303 auto symbol_lists = create_symbol_lists(12);
1304
1305 auto append_symbol = [&](auto& symbols, auto const& key, auto symbol) {
1306 auto key_index = key.to_uint().value() - 1;
1307 symbols[key_index] = cldr.unique_strings.ensure(move(symbol));
1308 };
1309
1310 narrow_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1311 append_symbol(symbol_lists[0], key, value.as_string());
1312 });
1313 short_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1314 append_symbol(symbol_lists[1], key, value.as_string());
1315 });
1316 long_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1317 append_symbol(symbol_lists[2], key, value.as_string());
1318 });
1319
1320 store_symbol_lists(Locale::CalendarSymbol::Month, move(symbol_lists));
1321 };
1322
1323 auto parse_weekday_symbols = [&](auto const& symbols_object) {
1324 auto const& narrow_symbols = symbols_object.get_object("narrow"sv).value();
1325 auto const& short_symbols = symbols_object.get_object("abbreviated"sv).value();
1326 auto const& long_symbols = symbols_object.get_object("wide"sv).value();
1327 auto symbol_lists = create_symbol_lists(7);
1328
1329 auto append_symbol = [&](auto& symbols, auto const& key, auto symbol) {
1330 if (key == "sun"sv)
1331 symbols[to_underlying(Locale::Weekday::Sunday)] = cldr.unique_strings.ensure(move(symbol));
1332 else if (key == "mon"sv)
1333 symbols[to_underlying(Locale::Weekday::Monday)] = cldr.unique_strings.ensure(move(symbol));
1334 else if (key == "tue"sv)
1335 symbols[to_underlying(Locale::Weekday::Tuesday)] = cldr.unique_strings.ensure(move(symbol));
1336 else if (key == "wed"sv)
1337 symbols[to_underlying(Locale::Weekday::Wednesday)] = cldr.unique_strings.ensure(move(symbol));
1338 else if (key == "thu"sv)
1339 symbols[to_underlying(Locale::Weekday::Thursday)] = cldr.unique_strings.ensure(move(symbol));
1340 else if (key == "fri"sv)
1341 symbols[to_underlying(Locale::Weekday::Friday)] = cldr.unique_strings.ensure(move(symbol));
1342 else if (key == "sat"sv)
1343 symbols[to_underlying(Locale::Weekday::Saturday)] = cldr.unique_strings.ensure(move(symbol));
1344 };
1345
1346 narrow_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1347 append_symbol(symbol_lists[0], key, value.as_string());
1348 });
1349 short_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1350 append_symbol(symbol_lists[1], key, value.as_string());
1351 });
1352 long_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1353 append_symbol(symbol_lists[2], key, value.as_string());
1354 });
1355
1356 store_symbol_lists(Locale::CalendarSymbol::Weekday, move(symbol_lists));
1357 };
1358
1359 auto parse_day_period_symbols = [&](auto const& symbols_object) {
1360 auto const& narrow_symbols = symbols_object.get_object("narrow"sv).value();
1361 auto const& short_symbols = symbols_object.get_object("abbreviated"sv).value();
1362 auto const& long_symbols = symbols_object.get_object("wide"sv).value();
1363 auto symbol_lists = create_symbol_lists(11);
1364
1365 auto append_symbol = [&](auto& symbols, auto const& key, auto symbol) {
1366 if (auto day_period = day_period_from_string(key); day_period.has_value())
1367 symbols[to_underlying(*day_period)] = cldr.unique_strings.ensure(move(symbol));
1368 };
1369
1370 narrow_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1371 append_symbol(symbol_lists[0], key, value.as_string());
1372 });
1373 short_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1374 append_symbol(symbol_lists[1], key, value.as_string());
1375 });
1376 long_symbols.for_each_member([&](auto const& key, JsonValue const& value) {
1377 append_symbol(symbol_lists[2], key, value.as_string());
1378 });
1379
1380 store_symbol_lists(Locale::CalendarSymbol::DayPeriod, move(symbol_lists));
1381 };
1382
1383 parse_era_symbols(calendar_object.get_object("eras"sv).value());
1384 parse_month_symbols(calendar_object.get_object("months"sv)->get_object("format"sv).value());
1385 parse_weekday_symbols(calendar_object.get_object("days"sv)->get_object("format"sv).value());
1386 parse_day_period_symbols(calendar_object.get_object("dayPeriods"sv)->get_object("format"sv).value());
1387
1388 calendar.symbols = cldr.unique_calendar_symbols_lists.ensure(move(symbols_list));
1389}
1390
1391static ErrorOr<void> parse_calendars(DeprecatedString locale_calendars_path, CLDR& cldr, LocaleData& locale)
1392{
1393 LexicalPath calendars_path(move(locale_calendars_path));
1394 if (!calendars_path.basename().starts_with("ca-"sv))
1395 return {};
1396
1397 auto calendars = TRY(read_json_file(calendars_path.string()));
1398 auto const& main_object = calendars.as_object().get_object("main"sv).value();
1399 auto const& locale_object = main_object.get_object(calendars_path.parent().basename()).value();
1400 auto const& dates_object = locale_object.get_object("dates"sv).value();
1401 auto const& calendars_object = dates_object.get_object("calendars"sv).value();
1402
1403 auto parse_patterns = [&](auto const& patterns_object, auto const& skeletons_object, Vector<CalendarPattern>* patterns) -> ErrorOr<size_t> {
1404 auto parse_pattern = [&](auto name) -> ErrorOr<size_t> {
1405 auto format = patterns_object.get_deprecated_string(name);
1406 auto skeleton = skeletons_object.get_deprecated_string(name);
1407
1408 auto format_index = TRY(parse_date_time_pattern(format.value(), skeleton.value_or(DeprecatedString::empty()), cldr)).value();
1409
1410 if (patterns)
1411 patterns->append(cldr.unique_patterns.get(format_index));
1412
1413 return format_index;
1414 };
1415
1416 CalendarFormat formats {};
1417 formats.full_format = TRY(parse_pattern("full"sv));
1418 formats.long_format = TRY(parse_pattern("long"sv));
1419 formats.medium_format = TRY(parse_pattern("medium"sv));
1420 formats.short_format = TRY(parse_pattern("short"sv));
1421
1422 return cldr.unique_formats.ensure(move(formats));
1423 };
1424
1425 TRY(calendars_object.try_for_each_member([&](auto const& calendar_name, JsonValue const& value) -> ErrorOr<void> {
1426 // The generic calendar is not a supported Unicode calendar key, so skip it:
1427 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/calendar#unicode_calendar_keys
1428 if (calendar_name == "generic"sv)
1429 return {};
1430
1431 Calendar calendar {};
1432 CalendarPatternList available_formats {};
1433
1434 if (!cldr.calendars.contains_slow(calendar_name))
1435 cldr.calendars.append(calendar_name);
1436
1437 Vector<CalendarPattern> date_formats;
1438 Vector<CalendarPattern> time_formats;
1439
1440 auto const& date_formats_object = value.as_object().get_object("dateFormats"sv).value();
1441 auto const& date_skeletons_object = value.as_object().get_object("dateSkeletons"sv).value();
1442 calendar.date_formats = TRY(parse_patterns(date_formats_object, date_skeletons_object, &date_formats));
1443
1444 auto const& time_formats_object = value.as_object().get_object("timeFormats"sv).value();
1445 auto const& time_skeletons_object = value.as_object().get_object("timeSkeletons"sv).value();
1446 calendar.time_formats = TRY(parse_patterns(time_formats_object, time_skeletons_object, &time_formats));
1447
1448 auto const& standard_date_time_formats_object = value.as_object().get_object("dateTimeFormats-atTime"sv)->get_object("standard"sv).value();
1449 calendar.date_time_formats = TRY(parse_patterns(standard_date_time_formats_object, JsonObject {}, nullptr));
1450
1451 auto const& date_time_formats_object = value.as_object().get_object("dateTimeFormats"sv).value();
1452 auto const& available_formats_object = date_time_formats_object.get_object("availableFormats"sv).value();
1453 TRY(available_formats_object.try_for_each_member([&](auto const& skeleton, JsonValue const& pattern) -> ErrorOr<void> {
1454 auto pattern_index = TRY(parse_date_time_pattern(pattern.as_string(), skeleton, cldr));
1455 if (!pattern_index.has_value())
1456 return {};
1457
1458 auto const& format = cldr.unique_patterns.get(*pattern_index);
1459 if (format.contains_only_date_fields())
1460 date_formats.append(format);
1461 else if (format.contains_only_time_fields())
1462 time_formats.append(format);
1463
1464 if (!available_formats.contains_slow(*pattern_index))
1465 available_formats.append(*pattern_index);
1466
1467 return {};
1468 }));
1469
1470 auto const& interval_formats_object = date_time_formats_object.get_object("intervalFormats"sv).value();
1471 TRY(parse_interval_patterns(calendar, interval_formats_object, cldr));
1472
1473 TRY(generate_default_patterns(available_formats, cldr));
1474 generate_missing_patterns(calendar, available_formats, move(date_formats), move(time_formats), cldr);
1475 parse_calendar_symbols(calendar, value.as_object(), cldr);
1476
1477 calendar.available_formats = cldr.unique_pattern_lists.ensure(move(available_formats));
1478 locale.calendars.set(calendar_name, cldr.unique_calendars.ensure(move(calendar)));
1479
1480 return {};
1481 }));
1482
1483 return {};
1484}
1485
1486static ErrorOr<void> parse_time_zone_names(DeprecatedString locale_time_zone_names_path, CLDR& cldr, LocaleData& locale)
1487{
1488 LexicalPath time_zone_names_path(move(locale_time_zone_names_path));
1489 time_zone_names_path = time_zone_names_path.append("timeZoneNames.json"sv);
1490
1491 auto time_zone_names = TRY(read_json_file(time_zone_names_path.string()));
1492 auto const& main_object = time_zone_names.as_object().get_object("main"sv).value();
1493 auto const& locale_object = main_object.get_object(time_zone_names_path.parent().basename()).value();
1494 auto const& dates_object = locale_object.get_object("dates"sv).value();
1495 auto const& time_zone_names_object = dates_object.get_object("timeZoneNames"sv).value();
1496 auto const& meta_zone_object = time_zone_names_object.get_object("metazone"sv);
1497 auto const& hour_format_string = time_zone_names_object.get_deprecated_string("hourFormat"sv).value();
1498 auto const& gmt_format_string = time_zone_names_object.get_deprecated_string("gmtFormat"sv).value();
1499 auto const& gmt_zero_format_string = time_zone_names_object.get_deprecated_string("gmtZeroFormat"sv).value();
1500
1501 if (!meta_zone_object.has_value())
1502 return {};
1503
1504 auto parse_name = [&](StringView type, JsonObject const& meta_zone_object, StringView key) -> Optional<size_t> {
1505 auto const& names = meta_zone_object.get_object(type);
1506 if (!names.has_value())
1507 return {};
1508
1509 auto const& name = names->get_deprecated_string(key);
1510 if (name.has_value())
1511 return cldr.unique_strings.ensure(name.value());
1512
1513 return {};
1514 };
1515
1516 auto parse_hour_format = [&](auto const& format, auto& time_zone_formats) {
1517 auto hour_formats = format.split_view(';');
1518
1519 auto hour_format_ahead_start = hour_formats[0].find('H').value();
1520 auto separator_ahead_start = hour_formats[0].find_last('H').value() + 1;
1521 auto separator_ahead_end = hour_formats[0].find('m').value();
1522
1523 auto hour_format_behind_start = hour_formats[1].find('H').value();
1524 auto separator_behind_start = hour_formats[1].find_last('H').value() + 1;
1525 auto separator_behind_end = hour_formats[1].find('m').value();
1526
1527 auto symbol_ahead_sign = hour_formats[0].substring_view(0, hour_format_ahead_start);
1528 auto symbol_ahead_separator = hour_formats[0].substring_view(separator_ahead_start, separator_ahead_end - separator_ahead_start);
1529
1530 auto symbol_behind_sign = hour_formats[1].substring_view(0, hour_format_behind_start);
1531 auto symbol_behind_separator = hour_formats[1].substring_view(separator_behind_start, separator_behind_end - separator_behind_start);
1532
1533 time_zone_formats.symbol_ahead_sign = cldr.unique_strings.ensure(symbol_ahead_sign);
1534 time_zone_formats.symbol_ahead_separator = cldr.unique_strings.ensure(symbol_ahead_separator);
1535 time_zone_formats.symbol_behind_sign = cldr.unique_strings.ensure(symbol_behind_sign);
1536 time_zone_formats.symbol_behind_separator = cldr.unique_strings.ensure(symbol_behind_separator);
1537 };
1538
1539 TimeZoneNamesList time_zones;
1540
1541 TimeZoneFormat time_zone_formats {};
1542 parse_hour_format(hour_format_string, time_zone_formats);
1543 time_zone_formats.gmt_format = cldr.unique_strings.ensure(gmt_format_string);
1544 time_zone_formats.gmt_zero_format = cldr.unique_strings.ensure(gmt_zero_format_string);
1545
1546 auto parse_time_zone = [&](StringView meta_zone, JsonObject const& meta_zone_object) {
1547 auto golden_zones = cldr.meta_zones.find(meta_zone);
1548 if (golden_zones == cldr.meta_zones.end())
1549 return;
1550
1551 TimeZoneNames time_zone_names {};
1552
1553 if (auto name = parse_name("long"sv, meta_zone_object, "standard"sv); name.has_value())
1554 time_zone_names.long_standard_name = name.value();
1555 if (auto name = parse_name("short"sv, meta_zone_object, "standard"sv); name.has_value())
1556 time_zone_names.short_standard_name = name.value();
1557
1558 if (auto name = parse_name("long"sv, meta_zone_object, "daylight"sv); name.has_value())
1559 time_zone_names.long_daylight_name = name.value();
1560 if (auto name = parse_name("short"sv, meta_zone_object, "daylight"sv); name.has_value())
1561 time_zone_names.short_daylight_name = name.value();
1562
1563 if (auto name = parse_name("long"sv, meta_zone_object, "generic"sv); name.has_value())
1564 time_zone_names.long_generic_name = name.value();
1565 if (auto name = parse_name("short"sv, meta_zone_object, "generic"sv); name.has_value())
1566 time_zone_names.short_generic_name = name.value();
1567
1568 auto time_zone_index = cldr.unique_time_zones.ensure(move(time_zone_names));
1569
1570 for (auto golden_zone : golden_zones->value) {
1571 auto time_zone = to_underlying(golden_zone);
1572 if (time_zone >= time_zones.size())
1573 time_zones.resize(time_zone + 1);
1574
1575 time_zones[time_zone] = time_zone_index;
1576 }
1577 };
1578
1579 meta_zone_object->for_each_member([&](auto const& meta_zone, JsonValue const& value) {
1580 parse_time_zone(meta_zone, value.as_object());
1581 });
1582
1583 // The long and short names for UTC are not under the "timeZoneNames/metazone" object, but are under "timeZoneNames/zone/Etc".
1584 auto const& zone_object = time_zone_names_object.get_object("zone"sv).value();
1585 auto const& etc_object = zone_object.get_object("Etc"sv).value();
1586 auto const& utc_object = etc_object.get_object("UTC"sv).value();
1587 parse_time_zone("UTC"sv, utc_object);
1588
1589 locale.time_zones = cldr.unique_time_zone_lists.ensure(move(time_zones));
1590 locale.time_zone_formats = cldr.unique_time_zone_formats.ensure(move(time_zone_formats));
1591
1592 return {};
1593}
1594
1595static ErrorOr<void> parse_day_periods(DeprecatedString core_path, CLDR& cldr)
1596{
1597 // https://unicode.org/reports/tr35/tr35-dates.html#Day_Period_Rule_Sets
1598 LexicalPath day_periods_path(move(core_path));
1599 day_periods_path = day_periods_path.append("supplemental"sv);
1600 day_periods_path = day_periods_path.append("dayPeriods.json"sv);
1601
1602 auto locale_day_periods = TRY(read_json_file(day_periods_path.string()));
1603 auto const& supplemental_object = locale_day_periods.as_object().get_object("supplemental"sv).value();
1604 auto const& day_periods_object = supplemental_object.get_object("dayPeriodRuleSet"sv).value();
1605
1606 auto parse_hour = [](auto const& time) {
1607 auto hour_end_index = time.find(':').value();
1608
1609 // The times are in the form "hours:minutes", but we only need the hour segment.
1610 // TR-35 explicitly states that minutes other than :00 must not be used.
1611 VERIFY(time.substring_view(hour_end_index) == ":00"sv);
1612
1613 auto hour = time.substring_view(0, hour_end_index);
1614 return hour.template to_uint<u8>().value();
1615 };
1616
1617 auto parse_day_period = [&](auto const& symbol, auto const& ranges) -> Optional<DayPeriod> {
1618 if (!ranges.has("_from"sv))
1619 return {};
1620
1621 auto day_period = day_period_from_string(symbol);
1622 if (!day_period.has_value())
1623 return {};
1624
1625 auto begin = parse_hour(ranges.get_deprecated_string("_from"sv).value());
1626 auto end = parse_hour(ranges.get_deprecated_string("_before"sv).value());
1627
1628 return DayPeriod { *day_period, begin, end };
1629 };
1630
1631 day_periods_object.for_each_member([&](auto const& language, JsonValue const& value) {
1632 auto locale = cldr.locales.find(language);
1633 if (locale == cldr.locales.end())
1634 return;
1635
1636 DayPeriodList day_periods;
1637
1638 value.as_object().for_each_member([&](auto const& symbol, JsonValue const& ranges) {
1639 if (auto day_period = parse_day_period(symbol, ranges.as_object()); day_period.has_value()) {
1640 auto day_period_index = cldr.unique_day_periods.ensure(day_period.release_value());
1641 day_periods.append(day_period_index);
1642 }
1643 });
1644
1645 locale->value.day_periods = cldr.unique_day_period_lists.ensure(move(day_periods));
1646 });
1647
1648 return {};
1649}
1650
1651static ErrorOr<void> parse_all_locales(DeprecatedString core_path, DeprecatedString dates_path, CLDR& cldr)
1652{
1653 TRY(parse_hour_cycles(core_path, cldr));
1654 TRY(parse_week_data(core_path, cldr));
1655 TRY(parse_meta_zones(core_path, cldr));
1656
1657 auto dates_iterator = TRY(path_to_dir_iterator(move(dates_path)));
1658
1659 auto remove_variants_from_path = [&](DeprecatedString path) -> ErrorOr<DeprecatedString> {
1660 auto parsed_locale = TRY(CanonicalLanguageID::parse(cldr.unique_strings, LexicalPath::basename(path)));
1661
1662 StringBuilder builder;
1663 builder.append(cldr.unique_strings.get(parsed_locale.language));
1664 if (auto script = cldr.unique_strings.get(parsed_locale.script); !script.is_empty())
1665 builder.appendff("-{}", script);
1666 if (auto region = cldr.unique_strings.get(parsed_locale.region); !region.is_empty())
1667 builder.appendff("-{}", region);
1668
1669 return builder.to_deprecated_string();
1670 };
1671
1672 while (dates_iterator.has_next()) {
1673 auto dates_path = TRY(next_path_from_dir_iterator(dates_iterator));
1674 auto calendars_iterator = TRY(path_to_dir_iterator(dates_path, {}));
1675
1676 auto language = TRY(remove_variants_from_path(dates_path));
1677 auto& locale = cldr.locales.ensure(language);
1678
1679 while (calendars_iterator.has_next()) {
1680 auto calendars_path = TRY(next_path_from_dir_iterator(calendars_iterator));
1681 TRY(parse_calendars(move(calendars_path), cldr, locale));
1682 }
1683
1684 TRY(parse_time_zone_names(move(dates_path), cldr, locale));
1685 }
1686
1687 TRY(parse_day_periods(move(core_path), cldr));
1688 return {};
1689}
1690
1691static DeprecatedString format_identifier(StringView owner, DeprecatedString identifier)
1692{
1693 identifier = identifier.replace("-"sv, "_"sv, ReplaceMode::All);
1694 identifier = identifier.replace("/"sv, "_"sv, ReplaceMode::All);
1695
1696 if (all_of(identifier, is_ascii_digit))
1697 return DeprecatedString::formatted("{}_{}", owner[0], identifier);
1698 if (is_ascii_lower_alpha(identifier[0]))
1699 return DeprecatedString::formatted("{:c}{}", to_ascii_uppercase(identifier[0]), identifier.substring_view(1));
1700 return identifier;
1701}
1702
1703static ErrorOr<void> generate_unicode_locale_header(Core::BufferedFile& file, CLDR& cldr)
1704{
1705 StringBuilder builder;
1706 SourceGenerator generator { builder };
1707
1708 generator.append(R"~~~(
1709#pragma once
1710
1711#include <AK/Types.h>
1712
1713namespace Locale {
1714)~~~");
1715
1716 generate_enum(generator, format_identifier, "Calendar"sv, {}, cldr.calendars);
1717 generate_enum(generator, format_identifier, "HourCycleRegion"sv, {}, cldr.hour_cycle_regions);
1718 generate_enum(generator, format_identifier, "MinimumDaysRegion"sv, {}, cldr.minimum_days_regions);
1719 generate_enum(generator, format_identifier, "FirstDayRegion"sv, {}, cldr.first_day_regions);
1720 generate_enum(generator, format_identifier, "WeekendStartRegion"sv, {}, cldr.weekend_start_regions);
1721 generate_enum(generator, format_identifier, "WeekendEndRegion"sv, {}, cldr.weekend_end_regions);
1722
1723 generator.append(R"~~~(
1724}
1725)~~~");
1726
1727 TRY(file.write_until_depleted(generator.as_string_view().bytes()));
1728 return {};
1729}
1730
1731static ErrorOr<void> generate_unicode_locale_implementation(Core::BufferedFile& file, CLDR& cldr)
1732{
1733 StringBuilder builder;
1734 SourceGenerator generator { builder };
1735 generator.set("string_index_type"sv, cldr.unique_strings.type_that_fits());
1736 generator.set("calendar_pattern_index_type"sv, cldr.unique_patterns.type_that_fits());
1737 generator.set("calendar_pattern_list_index_type"sv, cldr.unique_pattern_lists.type_that_fits());
1738 generator.set("calendar_range_pattern_index_type"sv, cldr.unique_range_patterns.type_that_fits());
1739 generator.set("calendar_range_pattern_list_index_type"sv, cldr.unique_range_pattern_lists.type_that_fits());
1740 generator.set("calendar_format_index_type"sv, cldr.unique_formats.type_that_fits());
1741 generator.set("symbol_list_index_type"sv, cldr.unique_symbol_lists.type_that_fits());
1742 generator.set("calendar_symbols_index_type"sv, cldr.unique_calendar_symbols.type_that_fits());
1743 generator.set("calendar_symbols_list_index_type"sv, cldr.unique_calendar_symbols_lists.type_that_fits());
1744 generator.set("calendar_index_type"sv, cldr.unique_calendars.type_that_fits());
1745 generator.set("time_zone_index_type"sv, cldr.unique_time_zones.type_that_fits());
1746 generator.set("time_zone_list_index_type"sv, cldr.unique_time_zone_lists.type_that_fits());
1747 generator.set("day_period_index_type"sv, cldr.unique_day_periods.type_that_fits());
1748 generator.set("day_period_list_index_type"sv, cldr.unique_day_period_lists.type_that_fits());
1749
1750 generator.append(R"~~~(
1751#include <AK/Array.h>
1752#include <AK/BinarySearch.h>
1753#include <AK/Error.h>
1754#include <AK/Optional.h>
1755#include <AK/String.h>
1756#include <AK/StringView.h>
1757#include <LibLocale/DateTimeFormat.h>
1758#include <LibLocale/DateTimeFormatData.h>
1759#include <LibLocale/Locale.h>
1760#include <LibLocale/LocaleData.h>
1761#include <LibTimeZone/TimeZone.h>
1762
1763namespace Locale {
1764)~~~");
1765
1766 cldr.unique_strings.generate(generator);
1767
1768 generator.append(R"~~~(
1769template <typename SourceType, typename TargetType>
1770static void convert_calendar_fields(SourceType const& source, TargetType& target)
1771{
1772 if (source.era != -1)
1773 target.era = static_cast<CalendarPatternStyle>(source.era);
1774 if (source.year != -1)
1775 target.year = static_cast<CalendarPatternStyle>(source.year);
1776 if (source.month != -1)
1777 target.month = static_cast<CalendarPatternStyle>(source.month);
1778 if (source.weekday != -1)
1779 target.weekday = static_cast<CalendarPatternStyle>(source.weekday);
1780 if (source.day != -1)
1781 target.day = static_cast<CalendarPatternStyle>(source.day);
1782 if (source.day_period != -1)
1783 target.day_period = static_cast<CalendarPatternStyle>(source.day_period);
1784 if (source.hour != -1)
1785 target.hour = static_cast<CalendarPatternStyle>(source.hour);
1786 if (source.minute != -1)
1787 target.minute = static_cast<CalendarPatternStyle>(source.minute);
1788 if (source.second != -1)
1789 target.second = static_cast<CalendarPatternStyle>(source.second);
1790 if (source.fractional_second_digits != -1)
1791 target.fractional_second_digits = static_cast<u8>(source.fractional_second_digits);
1792 if (source.time_zone_name != -1)
1793 target.time_zone_name = static_cast<CalendarPatternStyle>(source.time_zone_name);
1794}
1795
1796struct CalendarPatternImpl {
1797 ErrorOr<CalendarPattern> to_unicode_calendar_pattern() const {
1798 CalendarPattern calendar_pattern {};
1799
1800 calendar_pattern.skeleton = TRY(String::from_utf8(decode_string(skeleton)));
1801 calendar_pattern.pattern = TRY(String::from_utf8(decode_string(pattern)));
1802 if (pattern12 != 0)
1803 calendar_pattern.pattern12 = TRY(String::from_utf8(decode_string(pattern12)));
1804
1805 convert_calendar_fields(*this, calendar_pattern);
1806 return calendar_pattern;
1807 }
1808
1809 @string_index_type@ skeleton { 0 };
1810 @string_index_type@ pattern { 0 };
1811 @string_index_type@ pattern12 { 0 };
1812
1813 i8 era { -1 };
1814 i8 year { -1 };
1815 i8 month { -1 };
1816 i8 weekday { -1 };
1817 i8 day { -1 };
1818 i8 day_period { -1 };
1819 i8 hour { -1 };
1820 i8 minute { -1 };
1821 i8 second { -1 };
1822 i8 fractional_second_digits { -1 };
1823 i8 time_zone_name { -1 };
1824};
1825
1826struct CalendarRangePatternImpl {
1827 ErrorOr<CalendarRangePattern> to_unicode_calendar_range_pattern() const {
1828 CalendarRangePattern calendar_range_pattern {};
1829
1830 if (field != -1)
1831 calendar_range_pattern.field = static_cast<CalendarRangePattern::Field>(field);
1832 calendar_range_pattern.start_range = TRY(String::from_utf8(decode_string(start_range)));
1833 calendar_range_pattern.separator = decode_string(separator);
1834 calendar_range_pattern.end_range = TRY(String::from_utf8(decode_string(end_range)));
1835
1836 convert_calendar_fields(*this, calendar_range_pattern);
1837 return calendar_range_pattern;
1838 }
1839
1840 @string_index_type@ skeleton { 0 };
1841 i8 field { -1 };
1842 @string_index_type@ start_range { 0 };
1843 @string_index_type@ separator { 0 };
1844 @string_index_type@ end_range { 0 };
1845
1846 i8 era { -1 };
1847 i8 year { -1 };
1848 i8 month { -1 };
1849 i8 weekday { -1 };
1850 i8 day { -1 };
1851 i8 day_period { -1 };
1852 i8 hour { -1 };
1853 i8 minute { -1 };
1854 i8 second { -1 };
1855 i8 fractional_second_digits { -1 };
1856 i8 time_zone_name { -1 };
1857};
1858)~~~");
1859
1860 cldr.unique_patterns.generate(generator, "CalendarPatternImpl"sv, "s_calendar_patterns"sv, 10);
1861 cldr.unique_pattern_lists.generate(generator, cldr.unique_patterns.type_that_fits(), "s_calendar_pattern_lists"sv);
1862 cldr.unique_range_patterns.generate(generator, "CalendarRangePatternImpl"sv, "s_calendar_range_patterns"sv, 10);
1863 cldr.unique_range_pattern_lists.generate(generator, cldr.unique_range_patterns.type_that_fits(), "s_calendar_range_pattern_lists"sv);
1864
1865 generator.append(R"~~~(
1866struct CalendarFormatImpl {
1867 ErrorOr<CalendarFormat> to_unicode_calendar_format() const {
1868 CalendarFormat calendar_format {};
1869
1870 calendar_format.full_format = TRY(s_calendar_patterns[full_format].to_unicode_calendar_pattern());
1871 calendar_format.long_format = TRY(s_calendar_patterns[long_format].to_unicode_calendar_pattern());
1872 calendar_format.medium_format = TRY(s_calendar_patterns[medium_format].to_unicode_calendar_pattern());
1873 calendar_format.short_format = TRY(s_calendar_patterns[short_format].to_unicode_calendar_pattern());
1874
1875 return calendar_format;
1876 }
1877
1878 @calendar_pattern_index_type@ full_format { 0 };
1879 @calendar_pattern_index_type@ long_format { 0 };
1880 @calendar_pattern_index_type@ medium_format { 0 };
1881 @calendar_pattern_index_type@ short_format { 0 };
1882};
1883
1884struct CalendarSymbols {
1885 @symbol_list_index_type@ narrow_symbols { 0 };
1886 @symbol_list_index_type@ short_symbols { 0 };
1887 @symbol_list_index_type@ long_symbols { 0 };
1888};
1889
1890struct CalendarData {
1891 @calendar_format_index_type@ date_formats { 0 };
1892 @calendar_format_index_type@ time_formats { 0 };
1893 @calendar_format_index_type@ date_time_formats { 0 };
1894 @calendar_pattern_list_index_type@ available_formats { 0 };
1895
1896 @calendar_range_pattern_index_type@ default_range_format { 0 };
1897 @calendar_range_pattern_list_index_type@ range_formats { 0 };
1898 @calendar_range_pattern_list_index_type@ range12_formats { 0 };
1899
1900 @calendar_symbols_list_index_type@ symbols { 0 };
1901};
1902
1903struct TimeZoneNames {
1904 @string_index_type@ short_standard_name { 0 };
1905 @string_index_type@ long_standard_name { 0 };
1906
1907 @string_index_type@ short_daylight_name { 0 };
1908 @string_index_type@ long_daylight_name { 0 };
1909
1910 @string_index_type@ short_generic_name { 0 };
1911 @string_index_type@ long_generic_name { 0 };
1912};
1913
1914struct TimeZoneFormatImpl {
1915 TimeZoneFormat to_time_zone_format() const {
1916 TimeZoneFormat time_zone_format {};
1917
1918 time_zone_format.symbol_ahead_sign = decode_string(symbol_ahead_sign);
1919 time_zone_format.symbol_ahead_separator = decode_string(symbol_ahead_separator);
1920 time_zone_format.symbol_behind_sign = decode_string(symbol_behind_sign);
1921 time_zone_format.symbol_behind_separator = decode_string(symbol_behind_separator);
1922 time_zone_format.gmt_format = decode_string(gmt_format);
1923 time_zone_format.gmt_zero_format = decode_string(gmt_zero_format);
1924
1925 return time_zone_format;
1926 }
1927
1928 @string_index_type@ symbol_ahead_sign { 0 };
1929 @string_index_type@ symbol_ahead_separator { 0 };
1930
1931 @string_index_type@ symbol_behind_sign { 0 };
1932 @string_index_type@ symbol_behind_separator { 0 };
1933
1934 @string_index_type@ gmt_format { 0 };
1935 @string_index_type@ gmt_zero_format { 0 };
1936};
1937
1938struct DayPeriodData {
1939 u8 day_period { 0 };
1940 u8 begin { 0 };
1941 u8 end { 0 };
1942};
1943)~~~");
1944
1945 cldr.unique_formats.generate(generator, "CalendarFormatImpl"sv, "s_calendar_formats"sv, 10);
1946 cldr.unique_symbol_lists.generate(generator, cldr.unique_strings.type_that_fits(), "s_symbol_lists"sv);
1947 cldr.unique_calendar_symbols.generate(generator, "CalendarSymbols"sv, "s_calendar_symbols"sv, 10);
1948 cldr.unique_calendar_symbols_lists.generate(generator, cldr.unique_calendar_symbols.type_that_fits(), "s_calendar_symbol_lists"sv);
1949 cldr.unique_calendars.generate(generator, "CalendarData"sv, "s_calendars"sv, 10);
1950 cldr.unique_time_zones.generate(generator, "TimeZoneNames"sv, "s_time_zones"sv, 30);
1951 cldr.unique_time_zone_lists.generate(generator, cldr.unique_time_zones.type_that_fits(), "s_time_zone_lists"sv);
1952 cldr.unique_time_zone_formats.generate(generator, "TimeZoneFormatImpl"sv, "s_time_zone_formats"sv, 30);
1953 cldr.unique_day_periods.generate(generator, "DayPeriodData"sv, "s_day_periods"sv, 30);
1954 cldr.unique_day_period_lists.generate(generator, cldr.unique_day_periods.type_that_fits(), "s_day_period_lists"sv);
1955 cldr.unique_hour_cycle_lists.generate(generator, cldr.unique_hour_cycle_lists.type_that_fits(), "s_hour_cycle_lists"sv);
1956
1957 auto append_calendars = [&](DeprecatedString name, auto const& calendars) {
1958 generator.set("name", name);
1959 generator.set("size", DeprecatedString::number(calendars.size()));
1960
1961 generator.append(R"~~~(
1962static constexpr Array<@calendar_index_type@, @size@> @name@ { {)~~~");
1963
1964 bool first = true;
1965 for (auto const& calendar_key : cldr.calendars) {
1966 auto calendar = calendars.find(calendar_key)->value;
1967
1968 generator.append(first ? " "sv : ", "sv);
1969 generator.append(DeprecatedString::number(calendar));
1970 first = false;
1971 }
1972
1973 generator.append(" } };");
1974 };
1975
1976 auto append_mapping = [&](auto const& keys, auto const& map, auto type, auto name, auto mapping_getter) {
1977 generator.set("type", type);
1978 generator.set("name", name);
1979 generator.set("size", DeprecatedString::number(keys.size()));
1980
1981 generator.append(R"~~~(
1982static constexpr Array<@type@, @size@> @name@ { {)~~~");
1983
1984 bool first = true;
1985 for (auto const& key : keys) {
1986 auto const& value = map.find(key)->value;
1987 auto mapping = mapping_getter(value);
1988
1989 generator.append(first ? " "sv : ", "sv);
1990 generator.append(DeprecatedString::number(mapping));
1991 first = false;
1992 }
1993
1994 generator.append(" } };");
1995 };
1996
1997 auto locales = cldr.locales.keys();
1998 quick_sort(locales);
1999
2000 generate_mapping(generator, cldr.locales, cldr.unique_calendars.type_that_fits(), "s_locale_calendars"sv, "s_calendars_{}"sv, format_identifier, [&](auto const& name, auto const& value) { append_calendars(name, value.calendars); });
2001 append_mapping(locales, cldr.locales, cldr.unique_time_zones.type_that_fits(), "s_locale_time_zones"sv, [](auto const& locale) { return locale.time_zones; });
2002 append_mapping(locales, cldr.locales, cldr.unique_time_zone_formats.type_that_fits(), "s_locale_time_zone_formats"sv, [](auto const& locale) { return locale.time_zone_formats; });
2003 append_mapping(locales, cldr.locales, cldr.unique_day_periods.type_that_fits(), "s_locale_day_periods"sv, [](auto const& locale) { return locale.day_periods; });
2004 append_mapping(cldr.hour_cycle_regions, cldr.hour_cycles, cldr.unique_hour_cycle_lists.type_that_fits(), "s_hour_cycles"sv, [](auto const& hour_cycles) { return hour_cycles; });
2005 append_mapping(cldr.minimum_days_regions, cldr.minimum_days, "u8"sv, "s_minimum_days"sv, [](auto minimum_days) { return minimum_days; });
2006 append_mapping(cldr.first_day_regions, cldr.first_day, "u8"sv, "s_first_day"sv, [](auto first_day) { return to_underlying(first_day); });
2007 append_mapping(cldr.weekend_start_regions, cldr.weekend_start, "u8"sv, "s_weekend_start"sv, [](auto weekend_start) { return to_underlying(weekend_start); });
2008 append_mapping(cldr.weekend_end_regions, cldr.weekend_end, "u8"sv, "s_weekend_end"sv, [](auto weekend_end) { return to_underlying(weekend_end); });
2009 generator.append("\n");
2010
2011 auto append_from_string = [&](StringView enum_title, StringView enum_snake, auto const& values, Vector<Alias> const& aliases = {}) -> ErrorOr<void> {
2012 HashValueMap<DeprecatedString> hashes;
2013 TRY(hashes.try_ensure_capacity(values.size()));
2014
2015 for (auto const& value : values)
2016 hashes.set(value.hash(), format_identifier(enum_title, value));
2017 for (auto const& alias : aliases)
2018 hashes.set(alias.alias.hash(), format_identifier(enum_title, alias.alias));
2019
2020 generate_value_from_string(generator, "{}_from_string"sv, enum_title, enum_snake, move(hashes));
2021
2022 return {};
2023 };
2024
2025 TRY(append_from_string("HourCycleRegion"sv, "hour_cycle_region"sv, cldr.hour_cycle_regions));
2026 TRY(append_from_string("MinimumDaysRegion"sv, "minimum_days_region"sv, cldr.minimum_days_regions));
2027 TRY(append_from_string("FirstDayRegion"sv, "first_day_region"sv, cldr.first_day_regions));
2028 TRY(append_from_string("WeekendStartRegion"sv, "weekend_start_region"sv, cldr.weekend_start_regions));
2029 TRY(append_from_string("WeekendEndRegion"sv, "weekend_end_region"sv, cldr.weekend_end_regions));
2030
2031 generator.append(R"~~~(
2032static Optional<Calendar> keyword_to_calendar(KeywordCalendar keyword)
2033{
2034 switch (keyword) {)~~~");
2035
2036 for (auto const& calendar : cldr.calendars) {
2037 generator.set("name"sv, format_identifier({}, calendar));
2038 generator.append(R"~~~(
2039 case KeywordCalendar::@name@:
2040 return Calendar::@name@;)~~~");
2041 }
2042
2043 generator.append(R"~~~(
2044 default:
2045 return {};
2046 }
2047}
2048
2049ErrorOr<Vector<HourCycle>> get_regional_hour_cycles(StringView region)
2050{
2051 auto region_value = hour_cycle_region_from_string(region);
2052 if (!region_value.has_value())
2053 return Vector<HourCycle> {};
2054
2055 auto region_index = to_underlying(*region_value);
2056
2057 auto regional_hour_cycles_index = s_hour_cycles.at(region_index);
2058 auto const& regional_hour_cycles = s_hour_cycle_lists.at(regional_hour_cycles_index);
2059
2060 Vector<HourCycle> hour_cycles;
2061 TRY(hour_cycles.try_ensure_capacity(regional_hour_cycles.size()));
2062
2063 for (auto hour_cycle : regional_hour_cycles)
2064 hour_cycles.unchecked_append(static_cast<HourCycle>(hour_cycle));
2065
2066 return hour_cycles;
2067}
2068)~~~");
2069
2070 auto append_regional_lookup = [&](StringView return_type, StringView lookup_type) {
2071 generator.set("return_type", return_type);
2072 generator.set("lookup_type", lookup_type);
2073
2074 generator.append(R"~~~(
2075Optional<@return_type@> get_regional_@lookup_type@(StringView region)
2076{
2077 auto region_value = @lookup_type@_region_from_string(region);
2078 if (!region_value.has_value())
2079 return {};
2080
2081 auto region_index = to_underlying(*region_value);
2082 auto @lookup_type@ = s_@lookup_type@.at(region_index);
2083
2084 return static_cast<@return_type@>(@lookup_type@);
2085}
2086)~~~");
2087 };
2088
2089 append_regional_lookup("u8"sv, "minimum_days"sv);
2090 append_regional_lookup("Weekday"sv, "first_day"sv);
2091 append_regional_lookup("Weekday"sv, "weekend_start"sv);
2092 append_regional_lookup("Weekday"sv, "weekend_end"sv);
2093
2094 generator.append(R"~~~(
2095static ErrorOr<CalendarData const*> find_calendar_data(StringView locale, StringView calendar)
2096{
2097 auto locale_value = locale_from_string(locale);
2098 if (!locale_value.has_value())
2099 return nullptr;
2100
2101 auto locale_index = to_underlying(*locale_value) - 1; // Subtract 1 because 0 == Locale::None.
2102 auto const& calendar_indices = s_locale_calendars.at(locale_index);
2103
2104 auto lookup_calendar = [&](auto calendar_name) -> CalendarData const* {
2105 auto calendar_keyword = keyword_ca_from_string(calendar_name);
2106 if (!calendar_keyword.has_value())
2107 return nullptr;
2108
2109 auto calendar_value = keyword_to_calendar(*calendar_keyword);
2110 if (!calendar_value.has_value())
2111 return nullptr;
2112
2113 size_t calendar_index = to_underlying(*calendar_value);
2114 calendar_index = calendar_indices[calendar_index];
2115
2116 return &s_calendars[calendar_index];
2117 };
2118
2119 if (auto const* calendar_data = lookup_calendar(calendar))
2120 return calendar_data;
2121
2122 auto default_calendar = TRY(get_preferred_keyword_value_for_locale(locale, "ca"sv));
2123 if (!default_calendar.has_value())
2124 return nullptr;
2125
2126 return lookup_calendar(*default_calendar);
2127}
2128
2129ErrorOr<Optional<CalendarFormat>> get_calendar_date_format(StringView locale, StringView calendar)
2130{
2131 if (auto const* data = TRY(find_calendar_data(locale, calendar)); data != nullptr) {
2132 auto const& formats = s_calendar_formats.at(data->date_formats);
2133 return TRY(formats.to_unicode_calendar_format());
2134 }
2135 return OptionalNone {};
2136}
2137
2138ErrorOr<Optional<CalendarFormat>> get_calendar_time_format(StringView locale, StringView calendar)
2139{
2140 if (auto const* data = TRY(find_calendar_data(locale, calendar)); data != nullptr) {
2141 auto const& formats = s_calendar_formats.at(data->time_formats);
2142 return TRY(formats.to_unicode_calendar_format());
2143 }
2144 return OptionalNone {};
2145}
2146
2147ErrorOr<Optional<CalendarFormat>> get_calendar_date_time_format(StringView locale, StringView calendar)
2148{
2149 if (auto const* data = TRY(find_calendar_data(locale, calendar)); data != nullptr) {
2150 auto const& formats = s_calendar_formats.at(data->date_time_formats);
2151 return TRY(formats.to_unicode_calendar_format());
2152 }
2153 return OptionalNone {};
2154}
2155
2156ErrorOr<Vector<CalendarPattern>> get_calendar_available_formats(StringView locale, StringView calendar)
2157{
2158 Vector<CalendarPattern> result {};
2159
2160 if (auto const* data = TRY(find_calendar_data(locale, calendar)); data != nullptr) {
2161 auto const& available_formats = s_calendar_pattern_lists.at(data->available_formats);
2162 TRY(result.try_ensure_capacity(available_formats.size()));
2163
2164 for (auto const& format : available_formats)
2165 result.unchecked_append(TRY(s_calendar_patterns[format].to_unicode_calendar_pattern()));
2166 }
2167
2168 return result;
2169}
2170
2171ErrorOr<Optional<CalendarRangePattern>> get_calendar_default_range_format(StringView locale, StringView calendar)
2172{
2173 if (auto const* data = TRY(find_calendar_data(locale, calendar)); data != nullptr) {
2174 auto const& pattern = s_calendar_range_patterns[data->default_range_format];
2175 return TRY(pattern.to_unicode_calendar_range_pattern());
2176 }
2177
2178 return OptionalNone {};
2179}
2180
2181ErrorOr<Vector<CalendarRangePattern>> get_calendar_range_formats(StringView locale, StringView calendar, StringView skeleton)
2182{
2183 Vector<CalendarRangePattern> result {};
2184
2185 if (auto const* data = TRY(find_calendar_data(locale, calendar)); data != nullptr) {
2186 auto const& range_formats = s_calendar_range_pattern_lists.at(data->range_formats);
2187
2188 for (auto format : range_formats) {
2189 auto const& pattern = s_calendar_range_patterns[format];
2190
2191 if (skeleton == decode_string(pattern.skeleton))
2192 TRY(result.try_append(TRY(pattern.to_unicode_calendar_range_pattern())));
2193 }
2194 }
2195
2196 return result;
2197}
2198
2199ErrorOr<Vector<CalendarRangePattern>> get_calendar_range12_formats(StringView locale, StringView calendar, StringView skeleton)
2200{
2201 Vector<CalendarRangePattern> result {};
2202
2203 if (auto const* data = TRY(find_calendar_data(locale, calendar)); data != nullptr) {
2204 auto const& range12_formats = s_calendar_range_pattern_lists.at(data->range12_formats);
2205
2206 for (auto format : range12_formats) {
2207 auto const& pattern = s_calendar_range_patterns[format];
2208
2209 if (skeleton == decode_string(pattern.skeleton))
2210 TRY(result.try_append(TRY(pattern.to_unicode_calendar_range_pattern())));
2211 }
2212 }
2213
2214 return result;
2215}
2216
2217static ErrorOr<ReadonlySpan<@string_index_type@>> find_calendar_symbols(StringView locale, StringView calendar, CalendarSymbol symbol, CalendarPatternStyle style)
2218{
2219 if (auto const* data = TRY(find_calendar_data(locale, calendar)); data != nullptr) {
2220 auto const& symbols_list = s_calendar_symbol_lists[data->symbols];
2221 auto symbol_index = to_underlying(symbol);
2222
2223 auto calendar_symbols_index = symbols_list.at(symbol_index);
2224 auto const& symbols = s_calendar_symbols.at(calendar_symbols_index);
2225
2226 @symbol_list_index_type@ symbol_list_index = 0;
2227
2228 switch (style) {
2229 case CalendarPatternStyle::Narrow:
2230 symbol_list_index = symbols.narrow_symbols;
2231 break;
2232 case CalendarPatternStyle::Short:
2233 symbol_list_index = symbols.short_symbols;
2234 break;
2235 case CalendarPatternStyle::Long:
2236 symbol_list_index = symbols.long_symbols;
2237 break;
2238 default:
2239 VERIFY_NOT_REACHED();
2240 }
2241
2242 return s_symbol_lists.at(symbol_list_index);
2243 }
2244
2245 return ReadonlySpan<@string_index_type@> {};
2246}
2247
2248ErrorOr<Optional<StringView>> get_calendar_era_symbol(StringView locale, StringView calendar, CalendarPatternStyle style, Era value)
2249{
2250 auto symbols = TRY(find_calendar_symbols(locale, calendar, CalendarSymbol::Era, style));
2251
2252 if (auto value_index = to_underlying(value); value_index < symbols.size()) {
2253 if (auto symbol_index = symbols.at(value_index); symbol_index != 0)
2254 return Optional<StringView> { decode_string(symbol_index) };
2255 }
2256
2257 return OptionalNone {};
2258}
2259
2260ErrorOr<Optional<StringView>> get_calendar_month_symbol(StringView locale, StringView calendar, CalendarPatternStyle style, Month value)
2261{
2262 auto symbols = TRY(find_calendar_symbols(locale, calendar, CalendarSymbol::Month, style));
2263
2264 if (auto value_index = to_underlying(value); value_index < symbols.size()) {
2265 if (auto symbol_index = symbols.at(value_index); symbol_index != 0)
2266 return Optional<StringView> { decode_string(symbol_index) };
2267 }
2268
2269 return OptionalNone {};
2270}
2271
2272ErrorOr<Optional<StringView>> get_calendar_weekday_symbol(StringView locale, StringView calendar, CalendarPatternStyle style, Weekday value)
2273{
2274 auto symbols = TRY(find_calendar_symbols(locale, calendar, CalendarSymbol::Weekday, style));
2275
2276 if (auto value_index = to_underlying(value); value_index < symbols.size()) {
2277 if (auto symbol_index = symbols.at(value_index); symbol_index != 0)
2278 return Optional<StringView> { decode_string(symbol_index) };
2279 }
2280
2281 return OptionalNone {};
2282}
2283
2284ErrorOr<Optional<StringView>> get_calendar_day_period_symbol(StringView locale, StringView calendar, CalendarPatternStyle style, DayPeriod value)
2285{
2286 auto symbols = TRY(find_calendar_symbols(locale, calendar, CalendarSymbol::DayPeriod, style));
2287
2288 if (auto value_index = to_underlying(value); value_index < symbols.size()) {
2289 if (auto symbol_index = symbols.at(value_index); symbol_index != 0)
2290 return Optional<StringView> { decode_string(symbol_index) };
2291 }
2292
2293 return OptionalNone {};
2294}
2295
2296ErrorOr<Optional<StringView>> get_calendar_day_period_symbol_for_hour(StringView locale, StringView calendar, CalendarPatternStyle style, u8 hour)
2297{
2298 auto locale_value = locale_from_string(locale);
2299 if (!locale_value.has_value())
2300 return OptionalNone {};
2301
2302 auto locale_index = to_underlying(*locale_value) - 1; // Subtract 1 because 0 == Locale::None.
2303
2304 auto day_periods_index = s_locale_day_periods[locale_index];
2305 auto day_periods = s_day_period_lists[day_periods_index];
2306
2307 for (auto day_period_index : day_periods) {
2308 auto day_period = s_day_periods[day_period_index];
2309 bool hour_falls_within_day_period = false;
2310
2311 if (day_period.begin > day_period.end) {
2312 if (hour >= day_period.begin)
2313 hour_falls_within_day_period = true;
2314 else if (hour <= day_period.end)
2315 hour_falls_within_day_period = true;
2316 } else if ((day_period.begin <= hour) && (hour < day_period.end)) {
2317 hour_falls_within_day_period = true;
2318 }
2319
2320 if (hour_falls_within_day_period) {
2321 auto period = static_cast<DayPeriod>(day_period.day_period);
2322 return get_calendar_day_period_symbol(locale, calendar, style, period);
2323 }
2324 }
2325
2326 // Fallback to fixed periods if the locale does not have flexible day periods.
2327 // TR-35 states that the meaning of AM and PM does not change with locale.
2328 if (hour < 12)
2329 return get_calendar_day_period_symbol(locale, calendar, style, DayPeriod::AM);
2330 return get_calendar_day_period_symbol(locale, calendar, style, DayPeriod::PM);
2331}
2332
2333Optional<TimeZoneFormat> get_time_zone_format(StringView locale)
2334{
2335 auto locale_value = locale_from_string(locale);
2336 if (!locale_value.has_value())
2337 return {};
2338
2339 auto locale_index = to_underlying(*locale_value) - 1; // Subtract 1 because 0 == Locale::None.
2340 auto time_zone_format_index = s_locale_time_zone_formats.at(locale_index);
2341
2342 auto const& time_zone_format = s_time_zone_formats.at(time_zone_format_index);
2343 return time_zone_format.to_time_zone_format();
2344}
2345
2346static TimeZoneNames const* find_time_zone_names(StringView locale, StringView time_zone)
2347{
2348 auto locale_value = locale_from_string(locale);
2349 if (!locale_value.has_value())
2350 return nullptr;
2351
2352 auto time_zone_value = ::TimeZone::time_zone_from_string(time_zone);
2353 if (!time_zone_value.has_value())
2354 return nullptr;
2355
2356 auto locale_index = to_underlying(*locale_value) - 1; // Subtract 1 because 0 == Locale::None.
2357 size_t time_zone_index = to_underlying(*time_zone_value);
2358
2359 auto time_zone_list_index = s_locale_time_zones.at(locale_index);
2360 auto const& time_zone_list = s_time_zone_lists.at(time_zone_list_index);
2361 if (time_zone_list.size() <= time_zone_index)
2362 return nullptr;
2363
2364 time_zone_index = time_zone_list.at(time_zone_index);
2365 return &s_time_zones[time_zone_index];
2366}
2367
2368Optional<StringView> get_time_zone_name(StringView locale, StringView time_zone, CalendarPatternStyle style, TimeZone::InDST in_dst)
2369{
2370 if (auto const* data = find_time_zone_names(locale, time_zone); data != nullptr) {
2371 size_t name_index = 0;
2372
2373 switch (style) {
2374 case CalendarPatternStyle::Short:
2375 name_index = (in_dst == TimeZone::InDST::No) ? data->short_standard_name : data->short_daylight_name;
2376 break;
2377 case CalendarPatternStyle::Long:
2378 name_index = (in_dst == TimeZone::InDST::No) ? data->long_standard_name : data->long_daylight_name;
2379 break;
2380 case CalendarPatternStyle::ShortGeneric:
2381 name_index = data->short_generic_name;
2382 break;
2383 case CalendarPatternStyle::LongGeneric:
2384 name_index = data->long_generic_name;
2385 break;
2386 default:
2387 VERIFY_NOT_REACHED();
2388 }
2389
2390 if (name_index != 0)
2391 return decode_string(name_index);
2392 }
2393
2394 return {};
2395}
2396
2397}
2398)~~~");
2399
2400 TRY(file.write_until_depleted(generator.as_string_view().bytes()));
2401 return {};
2402}
2403
2404ErrorOr<int> serenity_main(Main::Arguments arguments)
2405{
2406 StringView generated_header_path;
2407 StringView generated_implementation_path;
2408 StringView core_path;
2409 StringView dates_path;
2410
2411 Core::ArgsParser args_parser;
2412 args_parser.add_option(generated_header_path, "Path to the Unicode locale header file to generate", "generated-header-path", 'h', "generated-header-path");
2413 args_parser.add_option(generated_implementation_path, "Path to the Unicode locale implementation file to generate", "generated-implementation-path", 'c', "generated-implementation-path");
2414 args_parser.add_option(core_path, "Path to cldr-core directory", "core-path", 'r', "core-path");
2415 args_parser.add_option(dates_path, "Path to cldr-dates directory", "dates-path", 'd', "dates-path");
2416 args_parser.parse(arguments);
2417
2418 auto generated_header_file = TRY(open_file(generated_header_path, Core::File::OpenMode::Write));
2419 auto generated_implementation_file = TRY(open_file(generated_implementation_path, Core::File::OpenMode::Write));
2420
2421 CLDR cldr;
2422 TRY(parse_all_locales(core_path, dates_path, cldr));
2423
2424 TRY(generate_unicode_locale_header(*generated_header_file, cldr));
2425 TRY(generate_unicode_locale_implementation(*generated_implementation_file, cldr));
2426
2427 return 0;
2428}