Changeset 50359 in webkit for trunk/JavaScriptCore


Ignore:
Timestamp:
Oct 30, 2009, 3:23:31 PM (16 years ago)
Author:
[email protected]
Message:

​https://bugs.webkit.org/show_bug.cgi?id=30942
Use pointers instead of copies to pass GregorianDateTime objects around.

Patch by Geoffrey Garen <​[email protected]> on 2009-10-29
Reviewed by Darin Adler.

SunSpider reports a shocking 4.5% speedup on date-format-xparb, and 1.3%
speedup on date-format-tofte.

  • runtime/DateInstance.cpp:

(JSC::DateInstance::gregorianDateTime):

  • runtime/DateInstance.h:
  • runtime/DatePrototype.cpp:

(JSC::formatLocaleDate):
(JSC::dateProtoFuncToString):
(JSC::dateProtoFuncToUTCString):
(JSC::dateProtoFuncToISOString):
(JSC::dateProtoFuncToDateString):
(JSC::dateProtoFuncToTimeString):
(JSC::dateProtoFuncGetFullYear):
(JSC::dateProtoFuncGetUTCFullYear):
(JSC::dateProtoFuncToGMTString):
(JSC::dateProtoFuncGetMonth):
(JSC::dateProtoFuncGetUTCMonth):
(JSC::dateProtoFuncGetDate):
(JSC::dateProtoFuncGetUTCDate):
(JSC::dateProtoFuncGetDay):
(JSC::dateProtoFuncGetUTCDay):
(JSC::dateProtoFuncGetHours):
(JSC::dateProtoFuncGetUTCHours):
(JSC::dateProtoFuncGetMinutes):
(JSC::dateProtoFuncGetUTCMinutes):
(JSC::dateProtoFuncGetSeconds):
(JSC::dateProtoFuncGetUTCSeconds):
(JSC::dateProtoFuncGetTimezoneOffset):
(JSC::setNewValueFromTimeArgs):
(JSC::setNewValueFromDateArgs):
(JSC::dateProtoFuncSetYear):
(JSC::dateProtoFuncGetYear): Renamed getGregorianDateTime to gregorianDateTime,
since it no longer has an out parameter. Uses 0 to indicate invalid dates.

Location:
trunk/JavaScriptCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r50324 r50359  
     12009-10-29  Geoffrey Garen  <[email protected]>
     2
     3        Reviewed by Darin Adler.
     4
     5        https://bugs.webkit.org/show_bug.cgi?id=30942
     6        Use pointers instead of copies to pass GregorianDateTime objects around.
     7       
     8        SunSpider reports a shocking 4.5% speedup on date-format-xparb, and 1.3%
     9        speedup on date-format-tofte.
     10
     11        * runtime/DateInstance.cpp:
     12        (JSC::DateInstance::gregorianDateTime):
     13        * runtime/DateInstance.h:
     14        * runtime/DatePrototype.cpp:
     15        (JSC::formatLocaleDate):
     16        (JSC::dateProtoFuncToString):
     17        (JSC::dateProtoFuncToUTCString):
     18        (JSC::dateProtoFuncToISOString):
     19        (JSC::dateProtoFuncToDateString):
     20        (JSC::dateProtoFuncToTimeString):
     21        (JSC::dateProtoFuncGetFullYear):
     22        (JSC::dateProtoFuncGetUTCFullYear):
     23        (JSC::dateProtoFuncToGMTString):
     24        (JSC::dateProtoFuncGetMonth):
     25        (JSC::dateProtoFuncGetUTCMonth):
     26        (JSC::dateProtoFuncGetDate):
     27        (JSC::dateProtoFuncGetUTCDate):
     28        (JSC::dateProtoFuncGetDay):
     29        (JSC::dateProtoFuncGetUTCDay):
     30        (JSC::dateProtoFuncGetHours):
     31        (JSC::dateProtoFuncGetUTCHours):
     32        (JSC::dateProtoFuncGetMinutes):
     33        (JSC::dateProtoFuncGetUTCMinutes):
     34        (JSC::dateProtoFuncGetSeconds):
     35        (JSC::dateProtoFuncGetUTCSeconds):
     36        (JSC::dateProtoFuncGetTimezoneOffset):
     37        (JSC::setNewValueFromTimeArgs):
     38        (JSC::setNewValueFromDateArgs):
     39        (JSC::dateProtoFuncSetYear):
     40        (JSC::dateProtoFuncGetYear): Renamed getGregorianDateTime to gregorianDateTime,
     41        since it no longer has an out parameter. Uses 0 to indicate invalid dates.
     42
    1432009-10-30  Zoltan Horvath  <[email protected]>
    244

  • trunk/JavaScriptCore/runtime/DateInstance.cpp

    r50183 r50359  
    4747}
    4848
    49 bool DateInstance::getGregorianDateTime(ExecState* exec, bool outputIsUTC, GregorianDateTime& t) const
     49const GregorianDateTime* DateInstance::gregorianDateTime(ExecState* exec, bool outputIsUTC) const
    5050{
    5151    double milli = internalNumber();
    5252    if (isnan(milli))
    53         return false;
     53        return 0;
    5454
    5555    if (!m_data)
    … …  
    5858    if (outputIsUTC) {
    5959        if (m_data->m_gregorianDateTimeUTCCachedForMS != milli) {
    60             WTF::msToGregorianDateTime(internalNumber(), true, m_data->m_cachedGregorianDateTimeUTC);
     60            msToGregorianDateTime(internalNumber(), true, m_data->m_cachedGregorianDateTimeUTC);
    6161            m_data->m_gregorianDateTimeUTCCachedForMS = milli;
    6262        }
    63         t.copyFrom(m_data->m_cachedGregorianDateTimeUTC);
    64     } else {
    65         if (m_data->m_gregorianDateTimeCachedForMS != milli) {
    66             WTF::msToGregorianDateTime(internalNumber(), false, m_data->m_cachedGregorianDateTime);
    67             m_data->m_gregorianDateTimeCachedForMS = milli;
    68         }
    69         t.copyFrom(m_data->m_cachedGregorianDateTime);
     63        return &m_data->m_cachedGregorianDateTimeUTC;
    7064    }
    7165
    72     return true;
     66    if (m_data->m_gregorianDateTimeCachedForMS != milli) {
     67        msToGregorianDateTime(internalNumber(), false, m_data->m_cachedGregorianDateTime);
     68        m_data->m_gregorianDateTimeCachedForMS = milli;
     69    }
     70    return &m_data->m_cachedGregorianDateTime;
    7371}
    7472

  • trunk/JavaScriptCore/runtime/DateInstance.h

    r50183 r50359  
    3939        static JS_EXPORTDATA const ClassInfo info;
    4040
    41         bool getGregorianDateTime(ExecState*, bool outputIsUTC, WTF::GregorianDateTime&) const;
     41        const WTF::GregorianDateTime* gregorianDateTime(ExecState*, bool outputIsUTC) const;
    4242
    4343        static PassRefPtr<Structure> createStructure(JSValue prototype)

  • trunk/JavaScriptCore/runtime/DatePrototype.cpp

    r50183 r50359  
    254254static JSCell* formatLocaleDate(ExecState* exec, DateInstance* dateObject, double, LocaleDateTimeFormat format, const ArgList&)
    255255{
    256     GregorianDateTime gregorianDateTime;
    257     const bool outputIsUTC = false;
    258     if (!dateObject->getGregorianDateTime(exec, outputIsUTC, gregorianDateTime))
     256    const bool outputIsUTC = false;
     257    const GregorianDateTime* gregorianDateTime = dateObject->gregorianDateTime(exec, outputIsUTC);
     258    if (!gregorianDateTime)
    259259        return jsNontrivialString(exec, "Invalid Date");
    260260    return formatLocaleDate(exec, gregorianDateTime, format);
    … …  
    425425    DateInstance* thisDateObj = asDateInstance(thisValue);
    426426
    427     GregorianDateTime t;
    428     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
     427    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     428    if (!gregorianDateTime)
    429429        return jsNontrivialString(exec, "Invalid Date");
    430     return jsNontrivialString(exec, formatDate(t) + " " + formatTime(t, outputIsUTC));
     430    return jsNontrivialString(exec, formatDate(*gregorianDateTime) + " " + formatTime(*gregorianDateTime, outputIsUTC));
    431431}
    432432
    … …  
    440440    DateInstance* thisDateObj = asDateInstance(thisValue);
    441441
    442     GregorianDateTime t;
    443     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
     442    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     443    if (!gregorianDateTime)
    444444        return jsNontrivialString(exec, "Invalid Date");
    445     return jsNontrivialString(exec, formatDateUTCVariant(t) + " " + formatTime(t, outputIsUTC));
     445    return jsNontrivialString(exec, formatDateUTCVariant(*gregorianDateTime) + " " + formatTime(*gregorianDateTime, outputIsUTC));
    446446}
    447447
    … …  
    455455    DateInstance* thisDateObj = asDateInstance(thisValue);
    456456   
    457     GregorianDateTime t;
    458     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
     457    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     458    if (!gregorianDateTime)
    459459        return jsNontrivialString(exec, "Invalid Date");
    460460    // Maximum amount of space we need in buffer: 6 (max. digits in year) + 2 * 5 (2 characters each for month, day, hour, minute, second) + 4 (. + 3 digits for milliseconds)
    461461    // 6 for formatting and one for null termination = 27.  We add one extra character to allow us to force null termination.
    462462    char buffer[28];
    463     snprintf(buffer, sizeof(buffer) - 1, "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", 1900 + t.year, t.month + 1, t.monthDay, t.hour, t.minute, t.second, static_cast<int>(fmod(thisDateObj->internalNumber(), 1000)));
     463    snprintf(buffer, sizeof(buffer) - 1, "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", 1900 + gregorianDateTime->year, gregorianDateTime->month + 1, gregorianDateTime->monthDay, gregorianDateTime->hour, gregorianDateTime->minute, gregorianDateTime->second, static_cast<int>(fmod(thisDateObj->internalNumber(), 1000)));
    464464    buffer[sizeof(buffer) - 1] = 0;
    465465    return jsNontrivialString(exec, buffer);
    … …  
    475475    DateInstance* thisDateObj = asDateInstance(thisValue);
    476476
    477     GregorianDateTime t;
    478     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
     477    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     478    if (!gregorianDateTime)
    479479        return jsNontrivialString(exec, "Invalid Date");
    480     return jsNontrivialString(exec, formatDate(t));
     480    return jsNontrivialString(exec, formatDate(*gregorianDateTime));
    481481}
    482482
    … …  
    490490    DateInstance* thisDateObj = asDateInstance(thisValue);
    491491
    492     GregorianDateTime t;
    493     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
     492    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     493    if (!gregorianDateTime)
    494494        return jsNontrivialString(exec, "Invalid Date");
    495     return jsNontrivialString(exec, formatTime(t, outputIsUTC));
     495    return jsNontrivialString(exec, formatTime(*gregorianDateTime, outputIsUTC));
    496496}
    497497
    … …  
    540540    DateInstance* thisDateObj = asDateInstance(thisValue);
    541541
    542     GregorianDateTime t;
    543     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    544         return jsNaN(exec);
    545     return jsNumber(exec, 1900 + t.year);
     542    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     543    if (!gregorianDateTime)
     544        return jsNaN(exec);
     545    return jsNumber(exec, 1900 + gregorianDateTime->year);
    546546}
    547547
    … …  
    555555    DateInstance* thisDateObj = asDateInstance(thisValue);
    556556
    557     GregorianDateTime t;
    558     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    559         return jsNaN(exec);
    560     return jsNumber(exec, 1900 + t.year);
     557    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     558    if (!gregorianDateTime)
     559        return jsNaN(exec);
     560    return jsNumber(exec, 1900 + gregorianDateTime->year);
    561561}
    562562
    … …  
    570570    DateInstance* thisDateObj = asDateInstance(thisValue);
    571571
    572     GregorianDateTime t;
    573     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
     572    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     573    if (!gregorianDateTime)
    574574        return jsNontrivialString(exec, "Invalid Date");
    575     return jsNontrivialString(exec, formatDateUTCVariant(t) + " " + formatTime(t, outputIsUTC));
     575    return jsNontrivialString(exec, formatDateUTCVariant(*gregorianDateTime) + " " + formatTime(*gregorianDateTime, outputIsUTC));
    576576}
    577577
    … …  
    585585    DateInstance* thisDateObj = asDateInstance(thisValue);
    586586
    587     GregorianDateTime t;
    588     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    589         return jsNaN(exec);
    590     return jsNumber(exec, t.month);
     587    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     588    if (!gregorianDateTime)
     589        return jsNaN(exec);
     590    return jsNumber(exec, gregorianDateTime->month);
    591591}
    592592
    … …  
    600600    DateInstance* thisDateObj = asDateInstance(thisValue);
    601601
    602     GregorianDateTime t;
    603     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    604         return jsNaN(exec);
    605     return jsNumber(exec, t.month);
     602    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     603    if (!gregorianDateTime)
     604        return jsNaN(exec);
     605    return jsNumber(exec, gregorianDateTime->month);
    606606}
    607607
    … …  
    615615    DateInstance* thisDateObj = asDateInstance(thisValue);
    616616
    617     GregorianDateTime t;
    618     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    619         return jsNaN(exec);
    620     return jsNumber(exec, t.monthDay);
     617    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     618    if (!gregorianDateTime)
     619        return jsNaN(exec);
     620    return jsNumber(exec, gregorianDateTime->monthDay);
    621621}
    622622
    … …  
    630630    DateInstance* thisDateObj = asDateInstance(thisValue);
    631631
    632     GregorianDateTime t;
    633     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    634         return jsNaN(exec);
    635     return jsNumber(exec, t.monthDay);
     632    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     633    if (!gregorianDateTime)
     634        return jsNaN(exec);
     635    return jsNumber(exec, gregorianDateTime->monthDay);
    636636}
    637637
    … …  
    645645    DateInstance* thisDateObj = asDateInstance(thisValue);
    646646
    647     GregorianDateTime t;
    648     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    649         return jsNaN(exec);
    650     return jsNumber(exec, t.weekDay);
     647    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     648    if (!gregorianDateTime)
     649        return jsNaN(exec);
     650    return jsNumber(exec, gregorianDateTime->weekDay);
    651651}
    652652
    … …  
    660660    DateInstance* thisDateObj = asDateInstance(thisValue);
    661661
    662     GregorianDateTime t;
    663     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    664         return jsNaN(exec);
    665     return jsNumber(exec, t.weekDay);
     662    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     663    if (!gregorianDateTime)
     664        return jsNaN(exec);
     665    return jsNumber(exec, gregorianDateTime->weekDay);
    666666}
    667667
    … …  
    675675    DateInstance* thisDateObj = asDateInstance(thisValue);
    676676
    677     GregorianDateTime t;
    678     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    679         return jsNaN(exec);
    680     return jsNumber(exec, t.hour);
     677    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     678    if (!gregorianDateTime)
     679        return jsNaN(exec);
     680    return jsNumber(exec, gregorianDateTime->hour);
    681681}
    682682
    … …  
    690690    DateInstance* thisDateObj = asDateInstance(thisValue);
    691691
    692     GregorianDateTime t;
    693     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    694         return jsNaN(exec);
    695     return jsNumber(exec, t.hour);
     692    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     693    if (!gregorianDateTime)
     694        return jsNaN(exec);
     695    return jsNumber(exec, gregorianDateTime->hour);
    696696}
    697697
    … …  
    705705    DateInstance* thisDateObj = asDateInstance(thisValue);
    706706
    707     GregorianDateTime t;
    708     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    709         return jsNaN(exec);
    710     return jsNumber(exec, t.minute);
     707    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     708    if (!gregorianDateTime)
     709        return jsNaN(exec);
     710    return jsNumber(exec, gregorianDateTime->minute);
    711711}
    712712
    … …  
    720720    DateInstance* thisDateObj = asDateInstance(thisValue);
    721721
    722     GregorianDateTime t;
    723     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    724         return jsNaN(exec);
    725     return jsNumber(exec, t.minute);
     722    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     723    if (!gregorianDateTime)
     724        return jsNaN(exec);
     725    return jsNumber(exec, gregorianDateTime->minute);
    726726}
    727727
    … …  
    735735    DateInstance* thisDateObj = asDateInstance(thisValue);
    736736
    737     GregorianDateTime t;
    738     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    739         return jsNaN(exec);
    740     return jsNumber(exec, t.second);
     737    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     738    if (!gregorianDateTime)
     739        return jsNaN(exec);
     740    return jsNumber(exec, gregorianDateTime->second);
    741741}
    742742
    … …  
    750750    DateInstance* thisDateObj = asDateInstance(thisValue);
    751751
    752     GregorianDateTime t;
    753     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    754         return jsNaN(exec);
    755     return jsNumber(exec, t.second);
     752    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     753    if (!gregorianDateTime)
     754        return jsNaN(exec);
     755    return jsNumber(exec, gregorianDateTime->second);
    756756}
    757757
    … …  
    795795    DateInstance* thisDateObj = asDateInstance(thisValue);
    796796
    797     GregorianDateTime t;
    798     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
    799         return jsNaN(exec);
    800     return jsNumber(exec, -gmtoffset(t) / minutesPerHour);
     797    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     798    if (!gregorianDateTime)
     799        return jsNaN(exec);
     800    return jsNumber(exec, -gregorianDateTime->utcOffset / minutesPerHour);
    801801}
    802802
    … …  
    831831    double ms = milli - secs * msPerSecond;
    832832
    833     GregorianDateTime t;
    834     thisDateObj->getGregorianDateTime(exec, inputIsUTC, t);
    835 
    836     if (!fillStructuresUsingTimeArgs(exec, args, numArgsToUse, &ms, &t)) {
     833    const GregorianDateTime* other = thisDateObj->gregorianDateTime(exec, inputIsUTC);
     834    if (!other)
     835        return jsNaN(exec);
     836
     837    GregorianDateTime gregorianDateTime;
     838    gregorianDateTime.copyFrom(*other);
     839    if (!fillStructuresUsingTimeArgs(exec, args, numArgsToUse, &ms, &gregorianDateTime)) {
    837840        JSValue result = jsNaN(exec);
    838841        thisDateObj->setInternalValue(result);
    … …  
    840843    }
    841844   
    842     JSValue result = jsNumber(exec, gregorianDateTimeToMS(t, ms, inputIsUTC));
     845    JSValue result = jsNumber(exec, gregorianDateTimeToMS(gregorianDateTime, ms, inputIsUTC));
    843846    thisDateObj->setInternalValue(result);
    844847    return result;
    … …  
    858861   
    859862    double milli = thisDateObj->internalNumber();
    860     double ms = 0;
    861 
    862     GregorianDateTime t;
    863     if (numArgsToUse == 3 && isnan(milli))
    864         // Based on ECMA 262 15.9.5.40 - .41 (set[UTC]FullYear)
    865         // the time must be reset to +0 if it is NaN.
    866         WTF::msToGregorianDateTime(0, true, t);
    867     else {
    868         double secs = floor(milli / msPerSecond);
    869         ms = milli - secs * msPerSecond;
    870         thisDateObj->getGregorianDateTime(exec, inputIsUTC, t);
     863    if (numArgsToUse == 3 && isnan(milli)) {
     864        JSValue result = jsNumber(exec, 0);
     865        thisDateObj->setInternalValue(result);
     866        return result;
    871867    }
    872    
    873     if (!fillStructuresUsingDateArgs(exec, args, numArgsToUse, &ms, &t)) {
     868
     869    const GregorianDateTime* other = thisDateObj->gregorianDateTime(exec, inputIsUTC);
     870    if (!other)
     871        return jsNaN(exec);
     872
     873    GregorianDateTime gregorianDateTime;
     874    gregorianDateTime.copyFrom(*other);
     875   
     876    double ms = milli - floor(milli / msPerSecond) * msPerSecond;
     877    if (!fillStructuresUsingDateArgs(exec, args, numArgsToUse, &ms, &gregorianDateTime)) {
    874878        JSValue result = jsNaN(exec);
    875879        thisDateObj->setInternalValue(result);
    … …  
    877881    }
    878882           
    879     JSValue result = jsNumber(exec, gregorianDateTimeToMS(t, ms, inputIsUTC));
     883    JSValue result = jsNumber(exec, gregorianDateTimeToMS(gregorianDateTime, ms, inputIsUTC));
    880884    thisDateObj->setInternalValue(result);
    881885    return result;
    … …  
    983987    double ms = 0;
    984988
    985     GregorianDateTime t;
     989    GregorianDateTime gregorianDateTime;
    986990    if (isnan(milli))
    987991        // Based on ECMA 262 B.2.5 (setYear)
    988992        // the time must be reset to +0 if it is NaN.
    989         WTF::msToGregorianDateTime(0, true, t);
     993        msToGregorianDateTime(0, true, gregorianDateTime);
    990994    else {   
    991995        double secs = floor(milli / msPerSecond);
    992996        ms = milli - secs * msPerSecond;
    993         thisDateObj->getGregorianDateTime(exec, outputIsUTC, t);
     997        if (const GregorianDateTime* other = thisDateObj->gregorianDateTime(exec, outputIsUTC))
     998            gregorianDateTime.copyFrom(*other);
    994999    }
    9951000   
    … …  
    10021007    }
    10031008           
    1004     t.year = (year > 99 || year < 0) ? year - 1900 : year;
    1005     JSValue result = jsNumber(exec, gregorianDateTimeToMS(t, ms, outputIsUTC));
     1009    gregorianDateTime.year = (year > 99 || year < 0) ? year - 1900 : year;
     1010    JSValue result = jsNumber(exec, gregorianDateTimeToMS(gregorianDateTime, ms, outputIsUTC));
    10061011    thisDateObj->setInternalValue(result);
    10071012    return result;
    … …  
    10171022    DateInstance* thisDateObj = asDateInstance(thisValue);
    10181023
    1019     GregorianDateTime t;
    1020     if (!thisDateObj->getGregorianDateTime(exec, outputIsUTC, t))
     1024    const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec, outputIsUTC);
     1025    if (!gregorianDateTime)
    10211026        return jsNaN(exec);
    10221027
    10231028    // NOTE: IE returns the full year even in getYear.
    1024     return jsNumber(exec, t.year);
     1029    return jsNumber(exec, gregorianDateTime->year);
    10251030}
    10261031
Note: See TracChangeset for help on using the changeset viewer.