1// Copyright (C) 2016 and later: Unicode, Inc. and others. 2// License & terms of use: http://www.unicode.org/copyright.html 3/* 4******************************************************************************* 5* Copyright (C) 2003-2009,2012,2016 International Business Machines Corporation and 6* others. All Rights Reserved. 7******************************************************************************* 8* 9* File JAPANCAL.CPP 10* 11* Modification History: 12* 05/16/2003 srl copied from buddhcal.cpp 13* 14*/ 15 16#include "unicode/utypes.h" 17 18#if !UCONFIG_NO_FORMATTING 19 20#include "cmemory.h" 21#include "japancal.h" 22#include "unicode/gregocal.h" 23#include "umutex.h" 24#include "uassert.h" 25 26//#define U_DEBUG_JCAL 27 28#ifdef U_DEBUG_JCAL 29#include <stdio.h> 30#endif 31 32U_NAMESPACE_BEGIN 33 34UOBJECT_DEFINE_RTTI_IMPLEMENTATION(JapaneseCalendar) 35 36// Gregorian date of each emperor's ascension 37// Years are AD, months are 1-based. 38static const struct { 39 int16_t year; 40 int8_t month; 41 int8_t day; 42} kEraInfo[] = { 43 // Year Month Day 44 { 645, 6, 19 }, // Taika 0 45 { 650, 2, 15 }, // Hakuchi 1 46 { 672, 1, 1 }, // Hakuho 2 47 { 686, 7, 20 }, // Shucho 3 48 { 701, 3, 21 }, // Taiho 4 49 { 704, 5, 10 }, // Keiun 5 50 { 708, 1, 11 }, // Wado 6 51 { 715, 9, 2 }, // Reiki 7 52 { 717, 11, 17 }, // Yoro 8 53 { 724, 2, 4 }, // Jinki 9 54 { 729, 8, 5 }, // Tempyo 10 55 { 749, 4, 14 }, // Tempyo-kampo 11 56 { 749, 7, 2 }, // Tempyo-shoho 12 57 { 757, 8, 18 }, // Tempyo-hoji 13 58 { 765, 1, 7 }, // Tempho-jingo 14 59 { 767, 8, 16 }, // Jingo-keiun 15 60 { 770, 10, 1 }, // Hoki 16 61 { 781, 1, 1 }, // Ten-o 17 62 { 782, 8, 19 }, // Enryaku 18 63 { 806, 5, 18 }, // Daido 19 64 { 810, 9, 19 }, // Konin 20 65 { 824, 1, 5 }, // Tencho 66 { 834, 1, 3 }, // Showa 67 { 848, 6, 13 }, // Kajo 68 { 851, 4, 28 }, // Ninju 69 { 854, 11, 30 }, // Saiko 70 { 857, 2, 21 }, // Tennan 71 { 859, 4, 15 }, // Jogan 72 { 877, 4, 16 }, // Genkei 73 { 885, 2, 21 }, // Ninna 74 { 889, 4, 27 }, // Kampyo 30 75 { 898, 4, 26 }, // Shotai 76 { 901, 7, 15 }, // Engi 77 { 923, 4, 11 }, // Encho 78 { 931, 4, 26 }, // Shohei 79 { 938, 5, 22 }, // Tengyo 80 { 947, 4, 22 }, // Tenryaku 81 { 957, 10, 27 }, // Tentoku 82 { 961, 2, 16 }, // Owa 83 { 964, 7, 10 }, // Koho 84 { 968, 8, 13 }, // Anna 40 85 { 970, 3, 25 }, // Tenroku 86 { 973, 12, 20 }, // Ten-en 87 { 976, 7, 13 }, // Jogen 88 { 978, 11, 29 }, // Tengen 89 { 983, 4, 15 }, // Eikan 90 { 985, 4, 27 }, // Kanna 91 { 987, 4, 5 }, // Ei-en 92 { 989, 8, 8 }, // Eiso 93 { 990, 11, 7 }, // Shoryaku 94 { 995, 2, 22 }, // Chotoku 50 95 { 999, 1, 13 }, // Choho 96 { 1004, 7, 20 }, // Kanko 97 { 1012, 12, 25 }, // Chowa 98 { 1017, 4, 23 }, // Kannin 99 { 1021, 2, 2 }, // Jian 100 { 1024, 7, 13 }, // Manju 101 { 1028, 7, 25 }, // Chogen 102 { 1037, 4, 21 }, // Choryaku 103 { 1040, 11, 10 }, // Chokyu 104 { 1044, 11, 24 }, // Kantoku 60 105 { 1046, 4, 14 }, // Eisho 106 { 1053, 1, 11 }, // Tengi 107 { 1058, 8, 29 }, // Kohei 108 { 1065, 8, 2 }, // Jiryaku 109 { 1069, 4, 13 }, // Enkyu 110 { 1074, 8, 23 }, // Shoho 111 { 1077, 11, 17 }, // Shoryaku 112 { 1081, 2, 10 }, // Eiho 113 { 1084, 2, 7 }, // Otoku 114 { 1087, 4, 7 }, // Kanji 70 115 { 1094, 12, 15 }, // Kaho 116 { 1096, 12, 17 }, // Eicho 117 { 1097, 11, 21 }, // Shotoku 118 { 1099, 8, 28 }, // Kowa 119 { 1104, 2, 10 }, // Choji 120 { 1106, 4, 9 }, // Kasho 121 { 1108, 8, 3 }, // Tennin 122 { 1110, 7, 13 }, // Ten-ei 123 { 1113, 7, 13 }, // Eikyu 124 { 1118, 4, 3 }, // Gen-ei 80 125 { 1120, 4, 10 }, // Hoan 126 { 1124, 4, 3 }, // Tenji 127 { 1126, 1, 22 }, // Daiji 128 { 1131, 1, 29 }, // Tensho 129 { 1132, 8, 11 }, // Chosho 130 { 1135, 4, 27 }, // Hoen 131 { 1141, 7, 10 }, // Eiji 132 { 1142, 4, 28 }, // Koji 133 { 1144, 2, 23 }, // Tenyo 134 { 1145, 7, 22 }, // Kyuan 90 135 { 1151, 1, 26 }, // Ninpei 136 { 1154, 10, 28 }, // Kyuju 137 { 1156, 4, 27 }, // Hogen 138 { 1159, 4, 20 }, // Heiji 139 { 1160, 1, 10 }, // Eiryaku 140 { 1161, 9, 4 }, // Oho 141 { 1163, 3, 29 }, // Chokan 142 { 1165, 6, 5 }, // Eiman 143 { 1166, 8, 27 }, // Nin-an 144 { 1169, 4, 8 }, // Kao 100 145 { 1171, 4, 21 }, // Shoan 146 { 1175, 7, 28 }, // Angen 147 { 1177, 8, 4 }, // Jisho 148 { 1181, 7, 14 }, // Yowa 149 { 1182, 5, 27 }, // Juei 150 { 1184, 4, 16 }, // Genryuku 151 { 1185, 8, 14 }, // Bunji 152 { 1190, 4, 11 }, // Kenkyu 153 { 1199, 4, 27 }, // Shoji 154 { 1201, 2, 13 }, // Kennin 110 155 { 1204, 2, 20 }, // Genkyu 156 { 1206, 4, 27 }, // Ken-ei 157 { 1207, 10, 25 }, // Shogen 158 { 1211, 3, 9 }, // Kenryaku 159 { 1213, 12, 6 }, // Kenpo 160 { 1219, 4, 12 }, // Shokyu 161 { 1222, 4, 13 }, // Joo 162 { 1224, 11, 20 }, // Gennin 163 { 1225, 4, 20 }, // Karoku 164 { 1227, 12, 10 }, // Antei 120 165 { 1229, 3, 5 }, // Kanki 166 { 1232, 4, 2 }, // Joei 167 { 1233, 4, 15 }, // Tempuku 168 { 1234, 11, 5 }, // Bunryaku 169 { 1235, 9, 19 }, // Katei 170 { 1238, 11, 23 }, // Ryakunin 171 { 1239, 2, 7 }, // En-o 172 { 1240, 7, 16 }, // Ninji 173 { 1243, 2, 26 }, // Kangen 174 { 1247, 2, 28 }, // Hoji 130 175 { 1249, 3, 18 }, // Kencho 176 { 1256, 10, 5 }, // Kogen 177 { 1257, 3, 14 }, // Shoka 178 { 1259, 3, 26 }, // Shogen 179 { 1260, 4, 13 }, // Bun-o 180 { 1261, 2, 20 }, // Kocho 181 { 1264, 2, 28 }, // Bun-ei 182 { 1275, 4, 25 }, // Kenji 183 { 1278, 2, 29 }, // Koan 184 { 1288, 4, 28 }, // Shoo 140 185 { 1293, 8, 55 }, // Einin 186 { 1299, 4, 25 }, // Shoan 187 { 1302, 11, 21 }, // Kengen 188 { 1303, 8, 5 }, // Kagen 189 { 1306, 12, 14 }, // Tokuji 190 { 1308, 10, 9 }, // Enkei 191 { 1311, 4, 28 }, // Ocho 192 { 1312, 3, 20 }, // Showa 193 { 1317, 2, 3 }, // Bunpo 194 { 1319, 4, 28 }, // Geno 150 195 { 1321, 2, 23 }, // Genkyo 196 { 1324, 12, 9 }, // Shochu 197 { 1326, 4, 26 }, // Kareki 198 { 1329, 8, 29 }, // Gentoku 199 { 1331, 8, 9 }, // Genko 200 { 1334, 1, 29 }, // Kemmu 201 { 1336, 2, 29 }, // Engen 202 { 1340, 4, 28 }, // Kokoku 203 { 1346, 12, 8 }, // Shohei 204 { 1370, 7, 24 }, // Kentoku 160 205 { 1372, 4, 1 }, // Bunch\u0169 206 { 1375, 5, 27 }, // Tenju 207 { 1379, 3, 22 }, // Koryaku 208 { 1381, 2, 10 }, // Kowa 209 { 1384, 4, 28 }, // Gench\u0169 210 { 1384, 2, 27 }, // Meitoku 211 { 1387, 8, 23 }, // Kakei 212 { 1389, 2, 9 }, // Koo 213 { 1390, 3, 26 }, // Meitoku 214 { 1394, 7, 5 }, // Oei 170 215 { 1428, 4, 27 }, // Shocho 216 { 1429, 9, 5 }, // Eikyo 217 { 1441, 2, 17 }, // Kakitsu 218 { 1444, 2, 5 }, // Bun-an 219 { 1449, 7, 28 }, // Hotoku 220 { 1452, 7, 25 }, // Kyotoku 221 { 1455, 7, 25 }, // Kosho 222 { 1457, 9, 28 }, // Choroku 223 { 1460, 12, 21 }, // Kansho 224 { 1466, 2, 28 }, // Bunsho 180 225 { 1467, 3, 3 }, // Onin 226 { 1469, 4, 28 }, // Bunmei 227 { 1487, 7, 29 }, // Chokyo 228 { 1489, 8, 21 }, // Entoku 229 { 1492, 7, 19 }, // Meio 230 { 1501, 2, 29 }, // Bunki 231 { 1504, 2, 30 }, // Eisho 232 { 1521, 8, 23 }, // Taiei 233 { 1528, 8, 20 }, // Kyoroku 234 { 1532, 7, 29 }, // Tenmon 190 235 { 1555, 10, 23 }, // Koji 236 { 1558, 2, 28 }, // Eiroku 237 { 1570, 4, 23 }, // Genki 238 { 1573, 7, 28 }, // Tensho 239 { 1592, 12, 8 }, // Bunroku 240 { 1596, 10, 27 }, // Keicho 241 { 1615, 7, 13 }, // Genwa 242 { 1624, 2, 30 }, // Kan-ei 243 { 1644, 12, 16 }, // Shoho 244 { 1648, 2, 15 }, // Keian 200 245 { 1652, 9, 18 }, // Shoo 246 { 1655, 4, 13 }, // Meiryaku 247 { 1658, 7, 23 }, // Manji 248 { 1661, 4, 25 }, // Kanbun 249 { 1673, 9, 21 }, // Enpo 250 { 1681, 9, 29 }, // Tenwa 251 { 1684, 2, 21 }, // Jokyo 252 { 1688, 9, 30 }, // Genroku 253 { 1704, 3, 13 }, // Hoei 254 { 1711, 4, 25 }, // Shotoku 210 255 { 1716, 6, 22 }, // Kyoho 256 { 1736, 4, 28 }, // Genbun 257 { 1741, 2, 27 }, // Kanpo 258 { 1744, 2, 21 }, // Enkyo 259 { 1748, 7, 12 }, // Kan-en 260 { 1751, 10, 27 }, // Horyaku 261 { 1764, 6, 2 }, // Meiwa 262 { 1772, 11, 16 }, // An-ei 263 { 1781, 4, 2 }, // Tenmei 264 { 1789, 1, 25 }, // Kansei 220 265 { 1801, 2, 5 }, // Kyowa 266 { 1804, 2, 11 }, // Bunka 267 { 1818, 4, 22 }, // Bunsei 268 { 1830, 12, 10 }, // Tenpo 269 { 1844, 12, 2 }, // Koka 270 { 1848, 2, 28 }, // Kaei 271 { 1854, 11, 27 }, // Ansei 272 { 1860, 3, 18 }, // Man-en 273 { 1861, 2, 19 }, // Bunkyu 274 { 1864, 2, 20 }, // Genji 230 275 { 1865, 4, 7 }, // Keio 231 276 { 1868, 9, 8 }, // Meiji 232 277 { 1912, 7, 30 }, // Taisho 233 278 { 1926, 12, 25 }, // Showa 234 279 { 1989, 1, 8 } // Heisei 235 280}; 281 282#define kEraCount UPRV_LENGTHOF(kEraInfo) 283 284/** 285 * The current era, for reference. 286 */ 287static const int32_t kCurrentEra = (kEraCount-1); // int32_t to match the calendar field type 288 289static const int32_t kGregorianEpoch = 1970; // used as the default value of EXTENDED_YEAR 290 291/* Some platforms don't like to export constants, like old Palm OS and some z/OS configurations. */ 292uint32_t JapaneseCalendar::getCurrentEra() { 293 return kCurrentEra; 294} 295 296JapaneseCalendar::JapaneseCalendar(const Locale& aLocale, UErrorCode& success) 297: GregorianCalendar(aLocale, success) 298{ 299 setTimeInMillis(getNow(), success); // Call this again now that the vtable is set up properly. 300} 301 302JapaneseCalendar::~JapaneseCalendar() 303{ 304} 305 306JapaneseCalendar::JapaneseCalendar(const JapaneseCalendar& source) 307: GregorianCalendar(source) 308{ 309} 310 311JapaneseCalendar& JapaneseCalendar::operator= ( const JapaneseCalendar& right) 312{ 313 GregorianCalendar::operator=(right); 314 return *this; 315} 316 317Calendar* JapaneseCalendar::clone(void) const 318{ 319 return new JapaneseCalendar(*this); 320} 321 322const char *JapaneseCalendar::getType() const 323{ 324 return "japanese"; 325} 326 327int32_t JapaneseCalendar::getDefaultMonthInYear(int32_t eyear) 328{ 329 int32_t era = internalGetEra(); 330 // TODO do we assume we can trust 'era'? What if it is denormalized? 331 332 int32_t month = 0; 333 334 // Find out if we are at the edge of an era 335 336 if(eyear == kEraInfo[era].year) { 337 // Yes, we're in the first year of this era. 338 return kEraInfo[era].month-1; 339 } 340 341 return month; 342} 343 344int32_t JapaneseCalendar::getDefaultDayInMonth(int32_t eyear, int32_t month) 345{ 346 int32_t era = internalGetEra(); 347 int32_t day = 1; 348 349 if(eyear == kEraInfo[era].year) { 350 if(month == (kEraInfo[era].month-1)) { 351 return kEraInfo[era].day; 352 } 353 } 354 355 return day; 356} 357 358 359int32_t JapaneseCalendar::internalGetEra() const 360{ 361 return internalGet(UCAL_ERA, kCurrentEra); 362} 363 364int32_t JapaneseCalendar::handleGetExtendedYear() 365{ 366 // EXTENDED_YEAR in JapaneseCalendar is a Gregorian year 367 // The default value of EXTENDED_YEAR is 1970 (Showa 45) 368 int32_t year; 369 370 if (newerField(UCAL_EXTENDED_YEAR, UCAL_YEAR) == UCAL_EXTENDED_YEAR && 371 newerField(UCAL_EXTENDED_YEAR, UCAL_ERA) == UCAL_EXTENDED_YEAR) { 372 year = internalGet(UCAL_EXTENDED_YEAR, kGregorianEpoch); 373 } else { 374 // Subtract one because year starts at 1 375 year = internalGet(UCAL_YEAR) + kEraInfo[internalGetEra()].year - 1; 376 } 377 return year; 378} 379 380 381void JapaneseCalendar::handleComputeFields(int32_t julianDay, UErrorCode& status) 382{ 383 //Calendar::timeToFields(theTime, quick, status); 384 GregorianCalendar::handleComputeFields(julianDay, status); 385 int32_t year = internalGet(UCAL_EXTENDED_YEAR); // Gregorian year 386 387 int32_t low = 0; 388 389 // Short circuit for recent years. Most modern computations will 390 // occur in the current era and won't require the binary search. 391 // Note that if the year is == the current era year, then we use 392 // the binary search to handle the month/dom comparison. 393#ifdef U_DEBUG_JCAL 394 fprintf(stderr, "== %d \n", year); 395#endif 396 397 if (year > kEraInfo[kCurrentEra].year) { 398 low = kCurrentEra; 399#ifdef U_DEBUG_JCAL 400 fprintf(stderr, " low=%d (special)\n", low); 401#endif 402 } else { 403 // Binary search 404 int32_t high = kEraCount; 405 406#ifdef U_DEBUG_JCAL 407 fprintf(stderr, " high=%d\n", high); 408#endif 409 while (low < high - 1) { 410 int32_t i = (low + high) / 2; 411 int32_t diff = year - kEraInfo[i].year; 412 413#ifdef U_DEBUG_JCAL 414 fprintf(stderr, " d=%d low=%d, high=%d. Considering %d:M%d D%d Y%d. { we are ?:M%d D%d Y%d }\n", 415 diff,low, high, i, kEraInfo[i].month-1, kEraInfo[i].day, kEraInfo[i].year, internalGet(UCAL_MONTH), internalGet(UCAL_DATE),year); 416#endif 417 418 // If years are the same, then compare the months, and if those 419 // are the same, compare days of month. In the ERAS array 420 // months are 1-based for easier maintenance. 421 if (diff == 0) { 422 diff = internalGet(UCAL_MONTH) - (kEraInfo[i].month - 1); 423#ifdef U_DEBUG_JCAL 424 fprintf(stderr, "diff now %d (M) = %d - %d - 1\n", diff, internalGet(UCAL_MONTH), kEraInfo[i].month); 425#endif 426 if (diff == 0) { 427 diff = internalGet(UCAL_DATE) - kEraInfo[i].day; 428#ifdef U_DEBUG_JCAL 429 fprintf(stderr, "diff now %d (D)\n", diff); 430#endif 431 } 432 } 433 if (diff >= 0) { 434 low = i; 435 } else { 436 high = i; 437 } 438#ifdef U_DEBUG_JCAL 439 fprintf(stderr, ". low=%d, high=%d, i=%d, diff=%d.. %d\n", low, high, i, diff, year); 440#endif 441 442 } 443 } 444 445#ifdef U_DEBUG_JCAL 446 fprintf(stderr, " low[era]=%d,.. %d\n", low, year); 447#endif 448 // Now we've found the last era that starts before this date, so 449 // adjust the year to count from the start of that era. Note that 450 // all dates before the first era will fall into the first era by 451 // the algorithm. 452 453 internalSet(UCAL_ERA, low); 454 internalSet(UCAL_YEAR, year - kEraInfo[low].year + 1); 455#ifdef U_DEBUG_JCAL 456 fprintf(stderr, " Set ERA=%d, year=%d\n", low, year-kEraInfo[low].year+1); 457#endif 458 459} 460 461/* 462Disable pivoting 463*/ 464UBool JapaneseCalendar::haveDefaultCentury() const 465{ 466 return FALSE; 467} 468 469UDate JapaneseCalendar::defaultCenturyStart() const 470{ 471 return 0;// WRONG 472} 473 474int32_t JapaneseCalendar::defaultCenturyStartYear() const 475{ 476 return 0; 477} 478 479int32_t JapaneseCalendar::handleGetLimit(UCalendarDateFields field, ELimitType limitType) const 480{ 481 switch(field) { 482 case UCAL_ERA: 483 if (limitType == UCAL_LIMIT_MINIMUM || limitType == UCAL_LIMIT_GREATEST_MINIMUM) { 484 return 0; 485 } 486 return kCurrentEra; 487 case UCAL_YEAR: 488 { 489 switch (limitType) { 490 case UCAL_LIMIT_MINIMUM: 491 case UCAL_LIMIT_GREATEST_MINIMUM: 492 return 1; 493 case UCAL_LIMIT_LEAST_MAXIMUM: 494 return 1; 495 case UCAL_LIMIT_COUNT: //added to avoid warning 496 case UCAL_LIMIT_MAXIMUM: 497 return GregorianCalendar::handleGetLimit(UCAL_YEAR, UCAL_LIMIT_MAXIMUM) - kEraInfo[kCurrentEra].year; 498 default: 499 return 1; // Error condition, invalid limitType 500 } 501 } 502 default: 503 return GregorianCalendar::handleGetLimit(field,limitType); 504 } 505} 506 507int32_t JapaneseCalendar::getActualMaximum(UCalendarDateFields field, UErrorCode& status) const { 508 if (field == UCAL_YEAR) { 509 int32_t era = get(UCAL_ERA, status); 510 if (U_FAILURE(status)) { 511 return 0; // error case... any value 512 } 513 if (era == kCurrentEra) { 514 // TODO: Investigate what value should be used here - revisit after 4.0. 515 return handleGetLimit(UCAL_YEAR, UCAL_LIMIT_MAXIMUM); 516 } else { 517 int32_t nextEraYear = kEraInfo[era + 1].year; 518 int32_t nextEraMonth = kEraInfo[era + 1].month; 519 int32_t nextEraDate = kEraInfo[era + 1].day; 520 521 int32_t maxYear = nextEraYear - kEraInfo[era].year + 1; // 1-base 522 if (nextEraMonth == 1 && nextEraDate == 1) { 523 // Subtract 1, because the next era starts at Jan 1 524 maxYear--; 525 } 526 return maxYear; 527 } 528 } 529 return GregorianCalendar::getActualMaximum(field, status); 530} 531 532U_NAMESPACE_END 533 534#endif 535