Changeset 156540 in webkit


Ignore:
Timestamp:
Sep 27, 2013 6:40:59 AM (11 years ago)
Author:
akling@apple.com
Message:

Pass VM instead of ExecState to JSDateMath functions.
<​https://webkit.org/b/121997>

Reviewed by Geoffrey Garen.

The JSC date math functions only need the VM, so pass that from
callers instead of the whole ExecState.

Location:
trunk/Source
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r156521 r156540  
     12013-09-27  Andreas Kling  <akling@apple.com>
     2
     3        Pass VM instead of ExecState to JSDateMath functions.
     4        <https://webkit.org/b/121997>
     5
     6        Reviewed by Geoffrey Garen.
     7
     8        The JSC date math functions only need the VM, so pass that from
     9        callers instead of the whole ExecState.
     10
    1112013-09-26  Andreas Kling  <akling@apple.com>
    212

  • trunk/Source/JavaScriptCore/runtime/DateConstructor.cpp

    r156498 r156540  
    107107            JSValue primitive = args.at(0).toPrimitive(exec);
    108108            if (primitive.isString())
    109                 value = parseDate(exec, primitive.getString(exec));
     109                value = parseDate(exec->vm(), primitive.getString(exec));
    110110            else
    111111                value = primitive.toNumber(exec);
    … …  
    140140            t.setIsDST(-1);
    141141            double ms = (numArgs >= 7) ? doubleArguments[6] : 0;
    142             value = gregorianDateTimeToMS(exec, t, ms, false);
     142            value = gregorianDateTimeToMS(exec->vm(), t, ms, false);
    143143        }
    144144    }
    … …  
    162162static EncodedJSValue JSC_HOST_CALL callDate(ExecState* exec)
    163163{
     164    VM& vm = exec->vm();
    164165    GregorianDateTime ts;
    165     msToGregorianDateTime(exec, currentTimeMS(), false, ts);
    166     return JSValue::encode(jsNontrivialString(exec, formatDateTime(ts, DateTimeFormatDateAndTime, false)));
     166    msToGregorianDateTime(vm, currentTimeMS(), false, ts);
     167    return JSValue::encode(jsNontrivialString(&vm, formatDateTime(ts, DateTimeFormatDateAndTime, false)));
    167168}
    168169
    … …  
    175176static EncodedJSValue JSC_HOST_CALL dateParse(ExecState* exec)
    176177{
    177     return JSValue::encode(jsNumber(parseDate(exec, exec->argument(0).toString(exec)->value(exec))));
     178    return JSValue::encode(jsNumber(parseDate(exec->vm(), exec->argument(0).toString(exec)->value(exec))));
    178179}
    179180
    … …  
    213214    t.setSecond(JSC::toInt32(doubleArguments[5]));
    214215    double ms = (n >= 7) ? doubleArguments[6] : 0;
    215     return JSValue::encode(jsNumber(timeClip(gregorianDateTimeToMS(exec, t, ms, true))));
     216    return JSValue::encode(jsNumber(timeClip(gregorianDateTimeToMS(exec->vm(), t, ms, true))));
    216217}
    217218

  • trunk/Source/JavaScriptCore/runtime/DateInstance.cpp

    r154038 r156540  
    6565        return 0;
    6666
     67    VM& vm = exec->vm();
    6768    if (!m_data)
    68         m_data = exec->vm().dateInstanceCache.add(milli);
     69        m_data = vm.dateInstanceCache.add(milli);
    6970
    7071    if (m_data->m_gregorianDateTimeCachedForMS != milli) {
    71         msToGregorianDateTime(exec, milli, false, m_data->m_cachedGregorianDateTime);
     72        msToGregorianDateTime(vm, milli, false, m_data->m_cachedGregorianDateTime);
    7273        m_data->m_gregorianDateTimeCachedForMS = milli;
    7374    }
    … …  
    8182        return 0;
    8283
     84    VM& vm = exec->vm();
    8385    if (!m_data)
    84         m_data = exec->vm().dateInstanceCache.add(milli);
     86        m_data = vm.dateInstanceCache.add(milli);
    8587
    8688    if (m_data->m_gregorianDateTimeUTCCachedForMS != milli) {
    87         msToGregorianDateTime(exec, milli, true, m_data->m_cachedGregorianDateTimeUTC);
     89        msToGregorianDateTime(vm, milli, true, m_data->m_cachedGregorianDateTimeUTC);
    8890        m_data->m_gregorianDateTimeUTCCachedForMS = milli;
    8991    }

  • trunk/Source/JavaScriptCore/runtime/DatePrototype.cpp

    r156498 r156540  
    889889    DateInstance* thisDateObj = asDateInstance(thisValue);
    890890    double milli = thisDateObj->internalNumber();
     891    VM& vm = exec->vm();
    891892   
    892893    if (!exec->argumentCount() || std::isnan(milli)) {
    893894        JSValue result = jsNaN();
    894         thisDateObj->setInternalValue(exec->vm(), result);
     895        thisDateObj->setInternalValue(vm, result);
    895896        return JSValue::encode(result);
    896897    }
    … …  
    909910    if (!fillStructuresUsingTimeArgs(exec, numArgsToUse, &ms, &gregorianDateTime)) {
    910911        JSValue result = jsNaN();
    911         thisDateObj->setInternalValue(exec->vm(), result);
     912        thisDateObj->setInternalValue(vm, result);
    912913        return JSValue::encode(result);
    913914    }
    914915   
    915     JSValue result = jsNumber(gregorianDateTimeToMS(exec, gregorianDateTime, ms, inputIsUTC));
    916     thisDateObj->setInternalValue(exec->vm(), result);
     916    JSValue result = jsNumber(gregorianDateTimeToMS(vm, gregorianDateTime, ms, inputIsUTC));
     917    thisDateObj->setInternalValue(vm, result);
    917918    return JSValue::encode(result);
    918919}
    … …  
    929930        thisDateObj->setInternalValue(exec->vm(), result);
    930931        return JSValue::encode(result);
    931     }     
    932    
     932    }
     933
     934    VM& vm = exec->vm();
    933935    double milli = thisDateObj->internalNumber();
    934936    double ms = 0;
    … …  
    936938    GregorianDateTime gregorianDateTime;
    937939    if (numArgsToUse == 3 && std::isnan(milli))
    938         msToGregorianDateTime(exec, 0, true, gregorianDateTime);
     940        msToGregorianDateTime(vm, 0, true, gregorianDateTime);
    939941    else {
    940942        ms = milli - floor(milli / msPerSecond) * msPerSecond;
    … …  
    949951    if (!fillStructuresUsingDateArgs(exec, numArgsToUse, &ms, &gregorianDateTime)) {
    950952        JSValue result = jsNaN();
    951         thisDateObj->setInternalValue(exec->vm(), result);
     953        thisDateObj->setInternalValue(vm, result);
    952954        return JSValue::encode(result);
    953955    }
    954956           
    955     JSValue result = jsNumber(gregorianDateTimeToMS(exec, gregorianDateTime, ms, inputIsUTC));
    956     thisDateObj->setInternalValue(exec->vm(), result);
     957    JSValue result = jsNumber(gregorianDateTimeToMS(vm, gregorianDateTime, ms, inputIsUTC));
     958    thisDateObj->setInternalValue(vm, result);
    957959    return JSValue::encode(result);
    958960}
    … …  
    10481050        return throwVMTypeError(exec);
    10491051
     1052    VM& vm = exec->vm();
    10501053    DateInstance* thisDateObj = asDateInstance(thisValue);
    10511054    if (!exec->argumentCount()) {
    10521055        JSValue result = jsNaN();
    1053         thisDateObj->setInternalValue(exec->vm(), result);
     1056        thisDateObj->setInternalValue(vm, result);
    10541057        return JSValue::encode(result);
    10551058    }
    … …  
    10621065        // Based on ECMA 262 B.2.5 (setYear)
    10631066        // the time must be reset to +0 if it is NaN.
    1064         msToGregorianDateTime(exec, 0, true, gregorianDateTime);
     1067        msToGregorianDateTime(vm, 0, true, gregorianDateTime);
    10651068    else {
    10661069        double secs = floor(milli / msPerSecond);
    … …  
    10731076    if (!std::isfinite(year)) {
    10741077        JSValue result = jsNaN();
    1075         thisDateObj->setInternalValue(exec->vm(), result);
     1078        thisDateObj->setInternalValue(vm, result);
    10761079        return JSValue::encode(result);
    10771080    }
    10781081
    10791082    gregorianDateTime.setYear(toInt32((year >= 0 && year <= 99) ? (year + 1900) : year));
    1080     JSValue result = jsNumber(gregorianDateTimeToMS(exec, gregorianDateTime, ms, false));
    1081     thisDateObj->setInternalValue(exec->vm(), result);
     1083    JSValue result = jsNumber(gregorianDateTimeToMS(vm, gregorianDateTime, ms, false));
     1084    thisDateObj->setInternalValue(vm, result);
    10821085    return JSValue::encode(result);
    10831086}

  • trunk/Source/JavaScriptCore/runtime/JSDateMath.cpp

    r150835 r156540  
    133133// more than one daylight savings offset change per month.
    134134// If this function is called with NaN it returns NaN.
    135 static LocalTimeOffset localTimeOffset(ExecState* exec, double ms)
    136 {
    137     LocalTimeOffsetCache& cache = exec->vm().localTimeOffsetCache;
     135static LocalTimeOffset localTimeOffset(VM& vm, double ms)
     136{
     137    LocalTimeOffsetCache& cache = vm.localTimeOffsetCache;
    138138    double start = cache.start;
    139139    double end = cache.end;
    … …  
    189189}
    190190
    191 double gregorianDateTimeToMS(ExecState* exec, const GregorianDateTime& t, double milliSeconds, bool inputIsUTC)
     191double gregorianDateTimeToMS(VM& vm, const GregorianDateTime& t, double milliSeconds, bool inputIsUTC)
    192192{
    193193    double day = dateToDaysFrom1970(t.year(), t.month(), t.monthDay());
    … …  
    196196
    197197    if (!inputIsUTC)
    198         result -= localTimeOffset(exec, result).offset;
     198        result -= localTimeOffset(vm, result).offset;
    199199
    200200    return result;
    … …  
    202202
    203203// input is UTC
    204 void msToGregorianDateTime(ExecState* exec, double ms, bool outputIsUTC, GregorianDateTime& tm)
     204void msToGregorianDateTime(VM& vm, double ms, bool outputIsUTC, GregorianDateTime& tm)
    205205{
    206206    LocalTimeOffset localTime;
    207207    if (!outputIsUTC) {
    208         localTime = localTimeOffset(exec, ms);
     208        localTime = localTimeOffset(vm, ms);
    209209        ms += localTime.offset;
    210210    }
    … …  
    223223}
    224224
    225 double parseDateFromNullTerminatedCharacters(ExecState* exec, const char* dateString)
    226 {
    227     ASSERT(exec);
     225double parseDateFromNullTerminatedCharacters(VM& vm, const char* dateString)
     226{
    228227    bool haveTZ;
    229228    int offset;
    … …  
    234233    // fall back to local timezone
    235234    if (!haveTZ)
    236         offset = localTimeOffset(exec, ms).offset / WTF::msPerMinute;
     235        offset = localTimeOffset(vm, ms).offset / WTF::msPerMinute;
    237236
    238237    return ms - (offset * WTF::msPerMinute);
    239238}
    240239
    241 double parseDate(ExecState* exec, const String& date)
    242 {
    243     if (date == exec->vm().cachedDateString)
    244         return exec->vm().cachedDateStringValue;
     240double parseDate(VM& vm, const String& date)
     241{
     242    if (date == vm.cachedDateString)
     243        return vm.cachedDateStringValue;
    245244    double value = parseES5DateFromNullTerminatedCharacters(date.utf8().data());
    246245    if (std::isnan(value))
    247         value = parseDateFromNullTerminatedCharacters(exec, date.utf8().data());
    248     exec->vm().cachedDateString = date;
    249     exec->vm().cachedDateStringValue = value;
     246        value = parseDateFromNullTerminatedCharacters(vm, date.utf8().data());
     247    vm.cachedDateString = date;
     248    vm.cachedDateStringValue = value;
    250249    return value;
    251250}

  • trunk/Source/JavaScriptCore/runtime/JSDateMath.h

    r127191 r156540  
    4949namespace JSC {
    5050
    51 class ExecState;
     51class VM;
    5252
    53 void msToGregorianDateTime(ExecState*, double, bool outputIsUTC, GregorianDateTime&);
    54 double gregorianDateTimeToMS(ExecState*, const GregorianDateTime&, double, bool inputIsUTC);
    55 double getUTCOffset(ExecState*);
    56 double parseDateFromNullTerminatedCharacters(ExecState*, const char* dateString);
    57 double parseDate(ExecState*, const WTF::String&);
     53void msToGregorianDateTime(VM&, double, bool outputIsUTC, GregorianDateTime&);
     54double gregorianDateTimeToMS(VM&, const GregorianDateTime&, double, bool inputIsUTC);
     55double getUTCOffset(VM&);
     56double parseDateFromNullTerminatedCharacters(VM&, const char* dateString);
     57double parseDate(VM&, const WTF::String&);
    5858
    5959} // namespace JSC

  • trunk/Source/WebCore/bridge/qt/qt_runtime.cpp

    r156503 r156540  
    292292        double ms = JSValueToNumber(context, value, exception);
    293293        GregorianDateTime convertedGdt;
    294         msToGregorianDateTime(exec, ms, /*utc*/ true, convertedGdt);
     294        msToGregorianDateTime(exec->vm(), ms, /*utc*/ true, convertedGdt);
    295295        gdt->copyFrom(convertedGdt);
    296296    }
Note: See TracChangeset for help on using the changeset viewer.