code.vuplus.com Git - vuplus_webkit/blob - Source/WebCore/platform/DateComponents.cpp

   1 /*
   2  * Copyright (C) 2009 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "DateComponents.h"
  33
  34 #include "PlatformString.h"
  35 #include <limits.h>
  36 #include <wtf/ASCIICType.h>
  37 #include <wtf/DateMath.h>
  38 #include <wtf/MathExtras.h>
  39
  40 using namespace std;
  41
  42 namespace WebCore {
  43
  44 // HTML5 uses ISO-8601 format with year >= 1. Gregorian calendar started in
  45 // 1582. However, we need to support 0001-01-01 in Gregorian calendar rule.
  46 static const int minimumYear = 1;
  47 // Date in ECMAScript can't represent dates later than 275760-09-13T00:00Z.
  48 // So, we have the same upper limit in HTML5 dates.
  49 static const int maximumYear = 275760;
  50 static const int maximumMonthInMaximumYear = 8; // This is September, since months are 0 based.
  51 static const int maximumDayInMaximumMonth = 13;
  52 static const int maximumWeekInMaximumYear = 37; // The week of 275760-09-13
  53
  54 static const int daysInMonth[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  55
  56 static bool isLeapYear(int year)
  57 {
  58     if (year % 4)
  59         return false;
  60     if (!(year % 400))
  61         return true;
  62     if (!(year % 100))
  63         return false;
  64     return true;
  65 }
  66
  67 // 'month' is 0-based.
  68 static int maxDayOfMonth(int year, int month)
  69 {
  70     if (month != 1) // February?
  71         return daysInMonth[month];
  72     return isLeapYear(year) ? 29 : 28;
  73 }
  74
  75 // 'month' is 0-based.
  76 static int dayOfWeek(int year, int month, int day)
  77 {
  78     int shiftedMonth = month + 2;
  79     // 2:January, 3:Feburuary, 4:March, ...
  80
  81     // Zeller's congruence
  82     if (shiftedMonth <= 3) {
  83         shiftedMonth += 12;
  84         year--;
  85     }
  86     // 4:March, ..., 14:January, 15:February
  87
  88     int highYear = year / 100;
  89     int lowYear = year % 100;
  90     // We add 6 to make the result Sunday-origin.
  91     int result = (day + 13 * shiftedMonth / 5 + lowYear + lowYear / 4 + highYear / 4 + 5 * highYear + 6) % 7;
  92     return result;
  93 }
  94
  95 int DateComponents::maxWeekNumberInYear() const
  96 {
  97     int day = dayOfWeek(m_year, 0, 1); // January 1.
  98     return day == Thursday || (day == Wednesday && isLeapYear(m_year)) ? 53 : 52;
  99 }
 100
 101 static unsigned countDigits(const UChar* src, unsigned length, unsigned start)
 102 {
 103     unsigned index = start;
 104     for (; index < length; ++index) {
 105         if (!isASCIIDigit(src[index]))
 106             break;
 107     }
 108     return index - start;
 109 }
 110
 111 // Very strict integer parser. Do not allow leading or trailing whitespace unlike charactersToIntStrict().
 112 static bool toInt(const UChar* src, unsigned length, unsigned parseStart, unsigned parseLength, int& out)
 113 {
 114     if (parseStart + parseLength > length || parseLength <= 0)
 115         return false;
 116     int value = 0;
 117     const UChar* current = src + parseStart;
 118     const UChar* end = current + parseLength;
 119
 120     // We don't need to handle negative numbers for ISO 8601.
 121     for (; current < end; ++current) {
 122         if (!isASCIIDigit(*current))
 123             return false;
 124         int digit = *current - '0';
 125         if (value > (INT_MAX - digit) / 10) // Check for overflow.
 126             return false;
 127         value = value * 10 + digit;
 128     }
 129     out = value;
 130     return true;
 131 }
 132
 133 bool DateComponents::parseYear(const UChar* src, unsigned length, unsigned start, unsigned& end)
 134 {
 135     unsigned digitsLength = countDigits(src, length, start);
 136     // Needs at least 4 digits according to the standard.
 137     if (digitsLength < 4)
 138         return false;
 139     int year;
 140     if (!toInt(src, length, start, digitsLength, year))
 141         return false;
 142     if (year < minimumYear || year > maximumYear)
 143         return false;
 144     m_year = year;
 145     end = start + digitsLength;
 146     return true;
 147 }
 148
 149 static bool withinHTMLDateLimits(int year, int month)
 150 {
 151     if (year < minimumYear)
 152         return false;
 153     if (year < maximumYear)
 154         return true;
 155     return month <= maximumMonthInMaximumYear;
 156 }
 157
 158 static bool withinHTMLDateLimits(int year, int month, int monthDay)
 159 {
 160     if (year < minimumYear)
 161         return false;
 162     if (year < maximumYear)
 163         return true;
 164     if (month < maximumMonthInMaximumYear)
 165         return true;
 166     return monthDay <= maximumDayInMaximumMonth;
 167 }
 168
 169 static bool withinHTMLDateLimits(int year, int month, int monthDay, int hour, int minute, int second, int millisecond)
 170 {
 171     if (year < minimumYear)
 172         return false;
 173     if (year < maximumYear)
 174         return true;
 175     if (month < maximumMonthInMaximumYear)
 176         return true;
 177     if (monthDay < maximumDayInMaximumMonth)
 178         return true;
 179     if (monthDay > maximumDayInMaximumMonth)
 180         return false;
 181     // (year, month, monthDay) = (maximumYear, maximumMonthInMaximumYear, maximumDayInMaximumMonth)
 182     return !hour && !minute && !second && !millisecond;
 183 }
 184
 185 bool DateComponents::addDay(int dayDiff)
 186 {
 187     ASSERT(m_monthDay);
 188
 189     int day = m_monthDay + dayDiff;
 190     if (day > maxDayOfMonth(m_year, m_month)) {
 191         day = m_monthDay;
 192         int year = m_year;
 193         int month = m_month;
 194         int maxDay = maxDayOfMonth(year, month);
 195         for (; dayDiff > 0; --dayDiff) {
 196             ++day;
 197             if (day > maxDay) {
 198                 day = 1;
 199                 ++month;
 200                 if (month >= 12) { // month is 0-origin.
 201                     month = 0;
 202                     ++year;
 203                 }
 204                 maxDay = maxDayOfMonth(year, month);
 205             }
 206         }
 207         if (!withinHTMLDateLimits(year, month, day))
 208             return false;
 209         m_year = year;
 210         m_month = month;
 211     } else if (day < 1) {
 212         int month = m_month;
 213         int year = m_year;
 214         day = m_monthDay;
 215         for (; dayDiff < 0; ++dayDiff) {
 216             --day;
 217             if (day < 1) {
 218                 --month;
 219                 if (month < 0) {
 220                     month = 11;
 221                     --year;
 222                 }
 223                 day = maxDayOfMonth(year, month);
 224             }
 225         }
 226         if (!withinHTMLDateLimits(year, month, day))
 227             return false;
 228         m_year = year;
 229         m_month = month;
 230     } else {
 231         if (!withinHTMLDateLimits(m_year, m_month, day))
 232             return false;
 233     }
 234     m_monthDay = day;
 235     return true;
 236 }
 237
 238 bool DateComponents::addMinute(int minute)
 239 {
 240     // This function is used to adjust timezone offset. So m_year, m_month,
 241     // m_monthDay have values between the lower and higher limits.
 242     ASSERT(withinHTMLDateLimits(m_year, m_month, m_monthDay));
 243
 244     int carry;
 245     // minute can be negative or greater than 59.
 246     minute += m_minute;
 247     if (minute > 59) {
 248         carry = minute / 60;
 249         minute = minute % 60;
 250     } else if (m_minute < 0) {
 251         carry = (59 - m_minute) / 60;
 252         minute += carry * 60;
 253         carry = -carry;
 254         ASSERT(minute >= 0 && minute <= 59);
 255     } else {
 256         if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, m_hour, minute, m_second, m_millisecond))
 257             return false;
 258         m_minute = minute;
 259         return true;
 260     }
 261
 262     int hour = m_hour + carry;
 263     if (hour > 23) {
 264         carry = hour / 24;
 265         hour = hour % 24;
 266     } else if (hour < 0) {
 267         carry = (23 - hour) / 24;
 268         hour += carry * 24;
 269         carry = -carry;
 270         ASSERT(hour >= 0 && hour <= 23);
 271     } else {
 272         if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, hour, minute, m_second, m_millisecond))
 273             return false;
 274         m_minute = minute;
 275         m_hour = hour;
 276         return true;
 277     }
 278     if (!addDay(carry))
 279         return false;
 280     if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, hour, minute, m_second, m_millisecond))
 281         return false;
 282     m_minute = minute;
 283     m_hour = hour;
 284     return true;
 285 }
 286
 287 // Parses a timezone part, and adjust year, month, monthDay, hour, minute, second, millisecond.
 288 bool DateComponents::parseTimeZone(const UChar* src, unsigned length, unsigned start, unsigned& end)
 289 {
 290     if (start >= length)
 291         return false;
 292     unsigned index = start;
 293     if (src[index] == 'Z') {
 294         end = index + 1;
 295         return true;
 296     }
 297
 298     bool minus;
 299     if (src[index] == '+')
 300         minus = false;
 301     else if (src[index] == '-')
 302         minus = true;
 303     else
 304         return false;
 305     ++index;
 306
 307     int hour;
 308     int minute;
 309     if (!toInt(src, length, index, 2, hour) || hour < 0 || hour > 23)
 310         return false;
 311     index += 2;
 312
 313     if (index >= length || src[index] != ':')
 314         return false;
 315     ++index;
 316
 317     if (!toInt(src, length, index, 2, minute) || minute < 0 || minute > 59)
 318         return false;
 319     index += 2;
 320
 321     if (minus) {
 322         hour = -hour;
 323         minute = -minute;
 324     }
 325
 326     // Subtract the timezone offset.
 327     if (!addMinute(-(hour * 60 + minute)))
 328         return false;
 329     end = index;
 330     return true;
 331 }
 332
 333 bool DateComponents::parseMonth(const UChar* src, unsigned length, unsigned start, unsigned& end)
 334 {
 335     ASSERT(src);
 336     unsigned index;
 337     if (!parseYear(src, length, start, index))
 338         return false;
 339     if (index >= length || src[index] != '-')
 340         return false;
 341     ++index;
 342
 343     int month;
 344     if (!toInt(src, length, index, 2, month) || month < 1 || month > 12)
 345         return false;
 346     --month;
 347     if (!withinHTMLDateLimits(m_year, month))
 348         return false;
 349     m_month = month;
 350     end = index + 2;
 351     m_type = Month;
 352     return true;
 353 }
 354
 355 bool DateComponents::parseDate(const UChar* src, unsigned length, unsigned start, unsigned& end)
 356 {
 357     ASSERT(src);
 358     unsigned index;
 359     if (!parseMonth(src, length, start, index))
 360         return false;
 361     // '-' and 2-digits are needed.
 362     if (index + 2 >= length)
 363         return false;
 364     if (src[index] != '-')
 365         return false;
 366     ++index;
 367
 368     int day;
 369     if (!toInt(src, length, index, 2, day) || day < 1 || day > maxDayOfMonth(m_year, m_month))
 370         return false;
 371     if (!withinHTMLDateLimits(m_year, m_month, day))
 372         return false;
 373     m_monthDay = day;
 374     end = index + 2;
 375     m_type = Date;
 376     return true;
 377 }
 378
 379 bool DateComponents::parseWeek(const UChar* src, unsigned length, unsigned start, unsigned& end)
 380 {
 381     ASSERT(src);
 382     unsigned index;
 383     if (!parseYear(src, length, start, index))
 384         return false;
 385
 386     // 4 characters ('-' 'W' digit digit) are needed.
 387     if (index + 3 >= length)
 388         return false;
 389     if (src[index] != '-')
 390         return false;
 391     ++index;
 392     if (src[index] != 'W')
 393         return false;
 394     ++index;
 395
 396     int week;
 397     if (!toInt(src, length, index, 2, week) || week < 1 || week > maxWeekNumberInYear())
 398         return false;
 399     if (m_year == maximumYear && week > maximumWeekInMaximumYear)
 400         return false;
 401     m_week = week;
 402     end = index + 2;
 403     m_type = Week;
 404     return true;
 405 }
 406
 407 bool DateComponents::parseTime(const UChar* src, unsigned length, unsigned start, unsigned& end)
 408 {
 409     ASSERT(src);
 410     int hour;
 411     if (!toInt(src, length, start, 2, hour) || hour < 0 || hour > 23)
 412         return false;
 413     unsigned index = start + 2;
 414     if (index >= length)
 415         return false;
 416     if (src[index] != ':')
 417         return false;
 418     ++index;
 419
 420     int minute;
 421     if (!toInt(src, length, index, 2, minute) || minute < 0 || minute > 59)
 422         return false;
 423     index += 2;
 424
 425     int second = 0;
 426     int millisecond = 0;
 427     // Optional second part.
 428     // Do not return with false because the part is optional.
 429     if (index + 2 < length && src[index] == ':') {
 430         if (toInt(src, length, index + 1, 2, second) && second >= 0 && second <= 59) {
 431             index += 3;
 432
 433             // Optional fractional second part.
 434             if (index < length && src[index] == '.') {
 435                 unsigned digitsLength = countDigits(src, length, index + 1);
 436                 if (digitsLength >  0) {
 437                     ++index;
 438                     bool ok;
 439                     if (digitsLength == 1) {
 440                         ok = toInt(src, length, index, 1, millisecond);
 441                         millisecond *= 100;
 442                     } else if (digitsLength == 2) {
 443                         ok = toInt(src, length, index, 2, millisecond);
 444                         millisecond *= 10;
 445                     } else // digitsLength >= 3
 446                         ok = toInt(src, length, index, 3, millisecond);
 447                     ASSERT_UNUSED(ok, ok);
 448                     index += digitsLength;
 449                 }
 450             }
 451         }
 452     }
 453     m_hour = hour;
 454     m_minute = minute;
 455     m_second = second;
 456     m_millisecond = millisecond;
 457     end = index;
 458     m_type = Time;
 459     return true;
 460 }
 461
 462 bool DateComponents::parseDateTimeLocal(const UChar* src, unsigned length, unsigned start, unsigned& end)
 463 {
 464     ASSERT(src);
 465     unsigned index;
 466     if (!parseDate(src, length, start, index))
 467         return false;
 468     if (index >= length)
 469         return false;
 470     if (src[index] != 'T')
 471         return false;
 472     ++index;
 473     if (!parseTime(src, length, index, end))
 474         return false;
 475     if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, m_hour, m_minute, m_second, m_millisecond))
 476         return false;
 477     m_type = DateTimeLocal;
 478     return true;
 479 }
 480
 481 bool DateComponents::parseDateTime(const UChar* src, unsigned length, unsigned start, unsigned& end)
 482 {
 483     ASSERT(src);
 484     unsigned index;
 485     if (!parseDate(src, length, start, index))
 486         return false;
 487     if (index >= length)
 488         return false;
 489     if (src[index] != 'T')
 490         return false;
 491     ++index;
 492     if (!parseTime(src, length, index, index))
 493         return false;
 494     if (!parseTimeZone(src, length, index, end))
 495         return false;
 496     if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, m_hour, m_minute, m_second, m_millisecond))
 497         return false;
 498     m_type = DateTime;
 499     return true;
 500 }
 501
 502 static inline double positiveFmod(double value, double divider)
 503 {
 504     double remainder = fmod(value, divider);
 505     return remainder < 0 ? remainder + divider : remainder;
 506 }
 507
 508 void DateComponents::setMillisecondsSinceMidnightInternal(double msInDay)
 509 {
 510     ASSERT(msInDay >= 0 && msInDay < msPerDay);
 511     m_millisecond = static_cast<int>(fmod(msInDay, msPerSecond));
 512     double value = floor(msInDay / msPerSecond);
 513     m_second = static_cast<int>(fmod(value, secondsPerMinute));
 514     value = floor(value / secondsPerMinute);
 515     m_minute = static_cast<int>(fmod(value, minutesPerHour));
 516     m_hour = static_cast<int>(value / minutesPerHour);
 517 }
 518
 519 bool DateComponents::setMillisecondsSinceEpochForDateInternal(double ms)
 520 {
 521     m_year = msToYear(ms);
 522     int yearDay = dayInYear(ms, m_year);
 523     m_month = monthFromDayInYear(yearDay, isLeapYear(m_year));
 524     m_monthDay = dayInMonthFromDayInYear(yearDay, isLeapYear(m_year));
 525     return true;
 526 }
 527
 528 bool DateComponents::setMillisecondsSinceEpochForDate(double ms)
 529 {
 530     m_type = Invalid;
 531     if (!isfinite(ms))
 532         return false;
 533     if (!setMillisecondsSinceEpochForDateInternal(round(ms)))
 534         return false;
 535     if (!withinHTMLDateLimits(m_year, m_month, m_monthDay))
 536         return false;
 537     m_type = Date;
 538     return true;
 539 }
 540
 541 bool DateComponents::setMillisecondsSinceEpochForDateTime(double ms)
 542 {
 543     m_type = Invalid;
 544     if (!isfinite(ms))
 545         return false;
 546     ms = round(ms);
 547     setMillisecondsSinceMidnightInternal(positiveFmod(ms, msPerDay));
 548     if (!setMillisecondsSinceEpochForDateInternal(ms))
 549         return false;
 550     if (!withinHTMLDateLimits(m_year, m_month, m_monthDay, m_hour, m_minute, m_second, m_millisecond))
 551         return false;
 552     m_type = DateTime;
 553     return true;
 554 }
 555
 556 bool DateComponents::setMillisecondsSinceEpochForDateTimeLocal(double ms)
 557 {
 558     // Internal representation of DateTimeLocal is the same as DateTime except m_type.
 559     if (!setMillisecondsSinceEpochForDateTime(ms))
 560         return false;
 561     m_type = DateTimeLocal;
 562     return true;
 563 }
 564
 565 bool DateComponents::setMillisecondsSinceEpochForMonth(double ms)
 566 {
 567     m_type = Invalid;
 568     if (!isfinite(ms))
 569         return false;
 570     if (!setMillisecondsSinceEpochForDateInternal(round(ms)))
 571         return false;
 572     if (!withinHTMLDateLimits(m_year, m_month))
 573         return false;
 574     m_type = Month;
 575     return true;
 576 }
 577
 578 bool DateComponents::setMillisecondsSinceMidnight(double ms)
 579 {
 580     m_type = Invalid;
 581     if (!isfinite(ms))
 582         return false;
 583     setMillisecondsSinceMidnightInternal(positiveFmod(round(ms), msPerDay));
 584     m_type = Time;
 585     return true;
 586 }
 587
 588 bool DateComponents::setMonthsSinceEpoch(double months)
 589 {
 590     if (!isfinite(months))
 591         return false;
 592     months = round(months);
 593     double doubleMonth = positiveFmod(months, 12);
 594     double doubleYear = 1970 + (months - doubleMonth) / 12;
 595     if (doubleYear < minimumYear || maximumYear < doubleYear)
 596         return false;
 597     int year = static_cast<int>(doubleYear);
 598     int month = static_cast<int>(doubleMonth);
 599     if (!withinHTMLDateLimits(year, month))
 600         return false;
 601     m_year = year;
 602     m_month = month;
 603     m_type = Month;
 604     return true;
 605 }
 606
 607 // Offset from January 1st to Monday of the ISO 8601's first week.
 608 //   ex. If January 1st is Friday, such Monday is 3 days later. Returns 3.
 609 static int offsetTo1stWeekStart(int year)
 610 {
 611     int offsetTo1stWeekStart = 1 - dayOfWeek(year, 0, 1);
 612     if (offsetTo1stWeekStart <= -4)
 613         offsetTo1stWeekStart += 7;
 614     return offsetTo1stWeekStart;
 615 }
 616
 617 bool DateComponents::setMillisecondsSinceEpochForWeek(double ms)
 618 {
 619     m_type = Invalid;
 620     if (!isfinite(ms))
 621         return false;
 622     ms = round(ms);
 623
 624     m_year = msToYear(ms);
 625     if (m_year < minimumYear || m_year > maximumYear)
 626         return false;
 627
 628     int yearDay = dayInYear(ms, m_year);
 629     int offset = offsetTo1stWeekStart(m_year);
 630     if (yearDay < offset) {
 631         // The day belongs to the last week of the previous year.
 632         m_year--;
 633         if (m_year <= minimumYear)
 634             return false;
 635         m_week = maxWeekNumberInYear();
 636     } else {
 637         m_week = ((yearDay - offset) / 7) + 1;
 638         if (m_week > maxWeekNumberInYear()) {
 639             m_year++;
 640             m_week = 1;
 641         }
 642         if (m_year > maximumYear || (m_year == maximumYear && m_week > maximumWeekInMaximumYear))
 643             return false;
 644     }
 645     m_type = Week;
 646     return true;
 647 }
 648
 649 double DateComponents::millisecondsSinceEpochForTime() const
 650 {
 651     ASSERT(m_type == Time || m_type == DateTime || m_type == DateTimeLocal);
 652     return ((m_hour * minutesPerHour + m_minute) * secondsPerMinute + m_second) * msPerSecond + m_millisecond;
 653 }
 654
 655 double DateComponents::millisecondsSinceEpoch() const
 656 {
 657     switch (m_type) {
 658     case Date:
 659         return dateToDaysFrom1970(m_year, m_month, m_monthDay) * msPerDay;
 660     case DateTime:
 661     case DateTimeLocal:
 662         return dateToDaysFrom1970(m_year, m_month, m_monthDay) * msPerDay + millisecondsSinceEpochForTime();
 663     case Month:
 664         return dateToDaysFrom1970(m_year, m_month, 1) * msPerDay;
 665     case Time:
 666         return millisecondsSinceEpochForTime();
 667     case Week:
 668         return (dateToDaysFrom1970(m_year, 0, 1) + offsetTo1stWeekStart(m_year) + (m_week - 1) * 7) * msPerDay;
 669     case Invalid:
 670         break;
 671     }
 672     ASSERT_NOT_REACHED();
 673     return invalidMilliseconds();
 674 }
 675
 676 double DateComponents::monthsSinceEpoch() const
 677 {
 678     ASSERT(m_type == Month);
 679     return (m_year - 1970) * 12 + m_month;
 680 }
 681
 682 String DateComponents::toStringForTime(SecondFormat format) const
 683 {
 684     ASSERT(m_type == DateTime || m_type == DateTimeLocal || m_type == Time);
 685     SecondFormat effectiveFormat = format;
 686     if (m_millisecond)
 687         effectiveFormat = Millisecond;
 688     else if (format == None && m_second)
 689         effectiveFormat = Second;
 690
 691     switch (effectiveFormat) {
 692     default:
 693         ASSERT_NOT_REACHED();
 694         // Fallback to None.
 695     case None:
 696         return String::format("%02d:%02d", m_hour, m_minute);
 697     case Second:
 698         return String::format("%02d:%02d:%02d", m_hour, m_minute, m_second);
 699     case Millisecond:
 700         return String::format("%02d:%02d:%02d.%03d", m_hour, m_minute, m_second, m_millisecond);
 701     }
 702 }
 703
 704 String DateComponents::toString(SecondFormat format) const
 705 {
 706     switch (m_type) {
 707     case Date:
 708         return String::format("%04d-%02d-%02d", m_year, m_month + 1, m_monthDay);
 709     case DateTime:
 710         return String::format("%04d-%02d-%02dT", m_year, m_month + 1, m_monthDay)
 711             + toStringForTime(format) + String("Z");
 712     case DateTimeLocal:
 713         return String::format("%04d-%02d-%02dT", m_year, m_month + 1, m_monthDay)
 714             + toStringForTime(format);
 715     case Month:
 716         return String::format("%04d-%02d", m_year, m_month + 1);
 717     case Time:
 718         return toStringForTime(format);
 719     case Week:
 720         return String::format("%04d-W%02d", m_year, m_week);
 721     case Invalid:
 722         break;
 723     }
 724     ASSERT_NOT_REACHED();
 725     return String("(Invalid DateComponents)");
 726 }
 727
 728 } // namespace WebCore