GenerateUnicodeDateTimeFormat.cpp 97 KB

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