Changeset 33038 in webkit for trunk/JavaScriptCore/kjs/nodes.cpp


Ignore:
Timestamp:
May 12, 2008, 12:12:31 AM (17 years ago)
Author:
[email protected]
Message:

Roll out recent threading changes (r32807, r32810, r32819, r32822) to simplify
SquirrelFish merging.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/JavaScriptCore/kjs/nodes.cpp

    r32822 r33038  
    4242#include <wtf/HashSet.h>
    4343#include <wtf/MathExtras.h>
    44 #if USE(MULTIPLE_THREADS)
    45 #include <wtf/ThreadSpecific.h>
    46 #endif
    47 
    48 using namespace WTF;
    4944
    5045namespace KJS {
     
    123118#define LOG_CHANNEL_PREFIX Log
    124119#endif
    125 
    126120static WTFLogChannel LogKJSNodeLeaks = { 0x00000000, "", WTFLogChannelOn };
    127121
     
    138132#endif
    139133
    140 static HashSet<ParserRefCounted*>* newTrackedObjects()
    141 {
    142 #if USE(MULTIPLE_THREADS)
    143     static ThreadSpecific<HashSet<ParserRefCounted*> > sharedInstance;
    144     return sharedInstance;
    145 #else
    146     static HashSet<ParserRefCounted*> sharedInstance;
    147     return &sharedInstance;
    148 #endif
    149 }
    150 
    151 static HashCountedSet<ParserRefCounted*>* trackedObjectExtraRefCounts()
    152 {
    153 #if USE(MULTIPLE_THREADS)
    154     static ThreadSpecific<HashCountedSet<ParserRefCounted*> > sharedInstance;
    155     return sharedInstance;
    156 #else
    157     static HashCountedSet<ParserRefCounted*> sharedInstance;
    158     return &sharedInstance;
    159 #endif
    160 }
    161 
    162 void initializeNodesThreading()
    163 {
    164     newTrackedObjects();
    165     trackedObjectExtraRefCounts();
    166 }
     134static HashSet<ParserRefCounted*>* newTrackedObjects;
     135static HashCountedSet<ParserRefCounted*>* trackedObjectExtraRefCounts;
    167136
    168137ParserRefCounted::ParserRefCounted()
     
    171140    ++ParserRefCountedCounter::count;
    172141#endif
    173     newTrackedObjects()->add(this);
    174     ASSERT(newTrackedObjects()->contains(this));
     142    if (!newTrackedObjects)
     143        newTrackedObjects = new HashSet<ParserRefCounted*>;
     144    newTrackedObjects->add(this);
     145    ASSERT(newTrackedObjects->contains(this));
    175146}
    176147
     
    184155void ParserRefCounted::ref()
    185156{
    186     HashSet<ParserRefCounted*>* localNewTrackedObjects = newTrackedObjects();
    187 
    188157    // bumping from 0 to 1 is just removing from the new nodes set
    189     HashSet<ParserRefCounted*>::iterator it = localNewTrackedObjects->find(this);
    190     if (it != localNewTrackedObjects->end()) {
    191         localNewTrackedObjects->remove(it);
    192         ASSERT(!trackedObjectExtraRefCounts()->contains(this));
     158    if (newTrackedObjects) {
     159        HashSet<ParserRefCounted*>::iterator it = newTrackedObjects->find(this);
     160        if (it != newTrackedObjects->end()) {
     161            newTrackedObjects->remove(it);
     162            ASSERT(!trackedObjectExtraRefCounts || !trackedObjectExtraRefCounts->contains(this));
     163            return;
     164        }
     165    }
     166
     167    ASSERT(!newTrackedObjects || !newTrackedObjects->contains(this));
     168
     169    if (!trackedObjectExtraRefCounts)
     170        trackedObjectExtraRefCounts = new HashCountedSet<ParserRefCounted*>;
     171    trackedObjectExtraRefCounts->add(this);
     172}
     173
     174void ParserRefCounted::deref()
     175{
     176    ASSERT(!newTrackedObjects || !newTrackedObjects->contains(this));
     177
     178    if (!trackedObjectExtraRefCounts) {
     179        delete this;
    193180        return;
    194181    }
    195182
    196     ASSERT(!localNewTrackedObjects->contains(this));
    197 
    198     trackedObjectExtraRefCounts()->add(this);
    199 }
    200 
    201 void ParserRefCounted::deref()
    202 {
    203     ASSERT(!newTrackedObjects()->contains(this));
    204     HashCountedSet<ParserRefCounted*>* localTrackedObjectExtraRefCounts = trackedObjectExtraRefCounts();
    205 
    206     HashCountedSet<ParserRefCounted*>::iterator it = localTrackedObjectExtraRefCounts->find(this);
    207     if (it == localTrackedObjectExtraRefCounts->end())
     183    HashCountedSet<ParserRefCounted*>::iterator it = trackedObjectExtraRefCounts->find(this);
     184    if (it == trackedObjectExtraRefCounts->end())
    208185        delete this;
    209186    else
    210         localTrackedObjectExtraRefCounts->remove(it);
     187        trackedObjectExtraRefCounts->remove(it);
    211188}
    212189
    213190unsigned ParserRefCounted::refcount()
    214191{
    215     HashCountedSet<ParserRefCounted*>* localTrackedObjectExtraRefCounts = trackedObjectExtraRefCounts();
    216 
    217     if (newTrackedObjects()->contains(this)) {
    218         ASSERT(!localTrackedObjectExtraRefCounts->contains(this));
     192    if (newTrackedObjects && newTrackedObjects->contains(this)) {
     193        ASSERT(!trackedObjectExtraRefCounts || !trackedObjectExtraRefCounts->contains(this));
    219194        return 0;
    220195    }
    221196
    222     ASSERT(!newTrackedObjects()->contains(this));
    223 
    224     if (!localTrackedObjectExtraRefCounts)
     197    ASSERT(!newTrackedObjects || !newTrackedObjects->contains(this));
     198
     199    if (!trackedObjectExtraRefCounts)
    225200        return 1;
    226201
    227     return 1 + localTrackedObjectExtraRefCounts->count(this);
     202    return 1 + trackedObjectExtraRefCounts->count(this);
    228203}
    229204
    230205void ParserRefCounted::deleteNewObjects()
    231206{
    232     HashSet<ParserRefCounted*>* localNewTrackedObjects = newTrackedObjects();
     207    if (!newTrackedObjects)
     208        return;
     209
    233210#ifndef NDEBUG
    234     HashSet<ParserRefCounted*>::iterator end = localNewTrackedObjects->end();
    235     for (HashSet<ParserRefCounted*>::iterator it = localNewTrackedObjects->begin(); it != end; ++it)
    236         ASSERT(!trackedObjectExtraRefCounts()->contains(*it));
     211    HashSet<ParserRefCounted*>::iterator end = newTrackedObjects->end();
     212    for (HashSet<ParserRefCounted*>::iterator it = newTrackedObjects->begin(); it != end; ++it)
     213        ASSERT(!trackedObjectExtraRefCounts || !trackedObjectExtraRefCounts->contains(*it));
    237214#endif
    238     deleteAllValues(*localNewTrackedObjects);
    239     localNewTrackedObjects->clear();
     215    deleteAllValues(*newTrackedObjects);
     216    delete newTrackedObjects;
     217    newTrackedObjects = 0;
    240218}
    241219
     
    383361        JSObject* exception = static_cast<JSObject*>(exceptionValue);
    384362        if (!exception->hasProperty(exec, "line") && !exception->hasProperty(exec, "sourceURL")) {
    385             exception->put(exec, "line", jsNumber(exec, m_line));
    386             exception->put(exec, "sourceURL", jsString(exec, currentSourceURL(exec)));
     363            exception->put(exec, "line", jsNumber(m_line));
     364            exception->put(exec, "sourceURL", jsString(currentSourceURL(exec)));
    387365        }
    388366    }
     
    476454// ------------------------------ NumberNode -----------------------------------
    477455
    478 JSValue* NumberNode::evaluate(ExecState* exec)
     456JSValue* NumberNode::evaluate(ExecState*)
    479457{
    480458    // Number nodes are only created when the number can't fit in a JSImmediate, so no need to check again.
    481     return jsNumberCell(exec, m_double);
     459    return jsNumberCell(m_double);
    482460}
    483461
     
    525503// ------------------------------ StringNode -----------------------------------
    526504
    527 JSValue* StringNode::evaluate(ExecState* exec)
    528 {
    529     return jsOwnedString(exec, m_value);
     505JSValue* StringNode::evaluate(ExecState*)
     506{
     507    return jsOwnedString(m_value);
    530508}
    531509
     
    842820
    843821    if (m_optional)
    844         array->put(exec, exec->propertyNames().length, jsNumber(exec, m_elision + length));
     822        array->put(exec, exec->propertyNames().length, jsNumber(m_elision + length));
    845823
    846824    return array;
     
    15891567            JSObject* base = *iter;
    15901568            JSValue* v = slot.getValue(exec, base, m_ident)->toJSNumber(exec);
    1591             base->put(exec, m_ident, jsNumber(exec, v->toNumber(exec) + 1));
     1569            base->put(exec, m_ident, jsNumber(v->toNumber(exec) + 1));
    15921570            return v;
    15931571        }
     
    16101588    JSValue** slot = &exec->localStorage()[m_index].value;
    16111589    JSValue* v = (*slot)->toJSNumber(exec);
    1612     *slot = jsNumber(exec, v->toNumber(exec) + 1);
     1590    *slot = jsNumber(v->toNumber(exec) + 1);
    16131591    return v;
    16141592}
     
    16501628            JSObject* base = *iter;
    16511629            JSValue* v = slot.getValue(exec, base, m_ident)->toJSNumber(exec);
    1652             base->put(exec, m_ident, jsNumber(exec, v->toNumber(exec) - 1));
     1630            base->put(exec, m_ident, jsNumber(v->toNumber(exec) - 1));
    16531631            return v;
    16541632        }
     
    16711649    JSValue** slot = &exec->localStorage()[m_index].value;
    16721650    JSValue* v = (*slot)->toJSNumber(exec);
    1673     *slot = jsNumber(exec, v->toNumber(exec) - 1);
     1651    *slot = jsNumber(v->toNumber(exec) - 1);
    16741652    return v;
    16751653}
     
    16811659    JSValue** slot = &exec->localStorage()[m_index].value;
    16821660    double n = (*slot)->toNumber(exec);
    1683     *slot = jsNumber(exec, n - 1);
     1661    *slot = jsNumber(n - 1);
    16841662    return n;
    16851663}
     
    17351713
    17361714        JSValue* v2 = v->toJSNumber(exec);
    1737         base->put(exec, propertyIndex, jsNumber(exec, v2->toNumber(exec) + 1));
     1715        base->put(exec, propertyIndex, jsNumber(v2->toNumber(exec) + 1));
    17381716
    17391717        return v2;
     
    17461724
    17471725    JSValue* v2 = v->toJSNumber(exec);
    1748     base->put(exec, propertyName, jsNumber(exec, v2->toNumber(exec) + 1));
     1726    base->put(exec, propertyName, jsNumber(v2->toNumber(exec) + 1));
    17491727    return v2;
    17501728}
     
    17661744
    17671745        JSValue* v2 = v->toJSNumber(exec);
    1768         base->put(exec, propertyIndex, jsNumber(exec, v2->toNumber(exec) - 1));
     1746        base->put(exec, propertyIndex, jsNumber(v2->toNumber(exec) - 1));
    17691747        return v2;
    17701748    }
     
    17761754
    17771755    JSValue* v2 = v->toJSNumber(exec);
    1778     base->put(exec, propertyName, jsNumber(exec, v2->toNumber(exec) - 1));
     1756    base->put(exec, propertyName, jsNumber(v2->toNumber(exec) - 1));
    17791757    return v2;
    17801758}
     
    17981776
    17991777    JSValue* v2 = v->toJSNumber(exec);
    1800     base->put(exec, m_ident, jsNumber(exec, v2->toNumber(exec) + 1));
     1778    base->put(exec, m_ident, jsNumber(v2->toNumber(exec) + 1));
    18011779    return v2;
    18021780}
     
    18131791
    18141792    JSValue* v2 = v->toJSNumber(exec);
    1815     base->put(exec, m_ident, jsNumber(exec, v2->toNumber(exec) - 1));
     1793    base->put(exec, m_ident, jsNumber(v2->toNumber(exec) - 1));
    18161794    return v2;
    18171795}
     
    19501928}
    19511929
    1952 static JSValue* typeStringForValue(ExecState*, JSValue*) KJS_FAST_CALL;
    1953 static JSValue* typeStringForValue(ExecState* exec, JSValue* v)
     1930static JSValue* typeStringForValue(JSValue* v) KJS_FAST_CALL;
     1931static JSValue* typeStringForValue(JSValue* v)
    19541932{
    19551933    switch (v->type()) {
    19561934        case UndefinedType:
    1957             return jsString(exec, "undefined");
     1935            return jsString("undefined");
    19581936        case NullType:
    1959             return jsString(exec, "object");
     1937            return jsString("object");
    19601938        case BooleanType:
    1961             return jsString(exec, "boolean");
     1939            return jsString("boolean");
    19621940        case NumberType:
    1963             return jsString(exec, "number");
     1941            return jsString("number");
    19641942        case StringType:
    1965             return jsString(exec, "string");
     1943            return jsString("string");
    19661944        default:
    19671945            if (v->isObject()) {
     
    19691947                // as null when doing comparisons.
    19701948                if (static_cast<JSObject*>(v)->masqueradeAsUndefined())
    1971                     return jsString(exec, "undefined");
     1949                    return jsString("undefined");
    19721950                else if (static_cast<JSObject*>(v)->implementsCall())
    1973                     return jsString(exec, "function");
     1951                    return jsString("function");
    19741952            }
    19751953
    1976             return jsString(exec, "object");
     1954            return jsString("object");
    19771955    }
    19781956}
     
    19891967    ASSERT(exec->variableObject() == exec->scopeChain().top());
    19901968
    1991     return typeStringForValue(exec, exec->localStorage()[m_index].value);
     1969    return typeStringForValue(exec->localStorage()[m_index].value);
    19921970}
    19931971
     
    20071985        if (base->getPropertySlot(exec, m_ident, slot)) {
    20081986            JSValue* v = slot.getValue(exec, base, m_ident);
    2009             return typeStringForValue(exec, v);
     1987            return typeStringForValue(v);
    20101988        }
    20111989
     
    20131991    } while (iter != end);
    20141992
    2015     return jsString(exec, "undefined");
     1993    return jsString("undefined");
    20161994}
    20171995
     
    20232001    KJS_CHECKEXCEPTIONVALUE
    20242002
    2025     return typeStringForValue(exec, v);
     2003    return typeStringForValue(v);
    20262004}
    20272005
     
    20472025
    20482026    double n = (*slot)->toNumber(exec);
    2049     JSValue* n2 = jsNumber(exec, n + 1);
     2027    JSValue* n2 = jsNumber(n + 1);
    20502028    *slot = n2;
    20512029    return n2;
     
    20702048
    20712049            double n = v->toNumber(exec);
    2072             JSValue* n2 = jsNumber(exec, n + 1);
     2050            JSValue* n2 = jsNumber(n + 1);
    20732051            base->put(exec, m_ident, n2);
    20742052
     
    20992077
    21002078    double n = (*slot)->toNumber(exec);
    2101     JSValue* n2 = jsNumber(exec, n - 1);
     2079    JSValue* n2 = jsNumber(n - 1);
    21022080    *slot = n2;
    21032081    return n2;
     
    21222100
    21232101            double n = v->toNumber(exec);
    2124             JSValue* n2 = jsNumber(exec, n - 1);
     2102            JSValue* n2 = jsNumber(n - 1);
    21252103            base->put(exec, m_ident, n2);
    21262104
     
    21392117{
    21402118    ASSERT(exec->variableObject() == exec->scopeChain().top());
    2141     return jsNumber(exec, exec->localStorage()[m_index].value->toNumber(exec) + 1);
     2119    return jsNumber(exec->localStorage()[m_index].value->toNumber(exec) + 1);
    21422120}
    21432121
     
    21472125{
    21482126    ASSERT(exec->variableObject() == exec->scopeChain().top());
    2149     return jsNumber(exec, exec->localStorage()[m_index].value->toNumber(exec) - 1);
     2127    return jsNumber(exec->localStorage()[m_index].value->toNumber(exec) - 1);
    21502128}
    21512129
     
    21552133{
    21562134    ASSERT(exec->variableObject() == exec->scopeChain().top());
    2157     return jsNumber(exec, exec->localStorage()[m_index].value->toNumber(exec));
     2135    return jsNumber(exec->localStorage()[m_index].value->toNumber(exec));
    21582136}
    21592137
     
    21632141{
    21642142    ASSERT(exec->variableObject() == exec->scopeChain().top());
    2165     return jsNumber(exec, exec->localStorage()[m_index].value->toNumber(exec));
     2143    return jsNumber(exec->localStorage()[m_index].value->toNumber(exec));
    21662144}
    21672145
     
    21892167        KJS_CHECKEXCEPTIONVALUE
    21902168
    2191         JSValue* n2 = jsNumber(exec, v->toNumber(exec) + 1);
     2169        JSValue* n2 = jsNumber(v->toNumber(exec) + 1);
    21922170        base->put(exec, propertyIndex, n2);
    21932171
     
    22002178    KJS_CHECKEXCEPTIONVALUE
    22012179
    2202     JSValue* n2 = jsNumber(exec, v->toNumber(exec) + 1);
     2180    JSValue* n2 = jsNumber(v->toNumber(exec) + 1);
    22032181    base->put(exec, propertyName, n2);
    22042182
     
    22212199        KJS_CHECKEXCEPTIONVALUE
    22222200
    2223         JSValue* n2 = jsNumber(exec, v->toNumber(exec) - 1);
     2201        JSValue* n2 = jsNumber(v->toNumber(exec) - 1);
    22242202        base->put(exec, propertyIndex, n2);
    22252203
     
    22322210    KJS_CHECKEXCEPTIONVALUE
    22332211
    2234     JSValue* n2 = jsNumber(exec, v->toNumber(exec) - 1);
     2212    JSValue* n2 = jsNumber(v->toNumber(exec) - 1);
    22352213    base->put(exec, propertyName, n2);
    22362214
     
    22562234
    22572235    double n = v->toNumber(exec);
    2258     JSValue* n2 = jsNumber(exec, n + 1);
     2236    JSValue* n2 = jsNumber(n + 1);
    22592237    base->put(exec, m_ident, n2);
    22602238
     
    22732251
    22742252    double n = v->toNumber(exec);
    2275     JSValue* n2 = jsNumber(exec, n - 1);
     2253    JSValue* n2 = jsNumber(n - 1);
    22762254    base->put(exec, m_ident, n2);
    22772255
     
    23352313{
    23362314    // No need to check exception, caller will do so right after evaluate()
    2337     return jsNumber(exec, -m_expr->evaluateToNumber(exec));
     2315    return jsNumber(-m_expr->evaluateToNumber(exec));
    23382316}
    23392317
     
    23592337JSValue* BitwiseNotNode::evaluate(ExecState* exec)
    23602338{
    2361     return jsNumber(exec, inlineEvaluateToInt32(exec));
     2339    return jsNumber(inlineEvaluateToInt32(exec));
    23622340}
    23632341
     
    24192397JSValue* MultNode::evaluate(ExecState* exec)
    24202398{
    2421     return jsNumber(exec, inlineEvaluateToNumber(exec));
     2399    return jsNumber(inlineEvaluateToNumber(exec));
    24222400}
    24232401
     
    24602438JSValue* DivNode::evaluate(ExecState* exec)
    24612439{
    2462     return jsNumber(exec, inlineEvaluateToNumber(exec));
     2440    return jsNumber(inlineEvaluateToNumber(exec));
    24632441}
    24642442
     
    24952473JSValue* ModNode::evaluate(ExecState* exec)
    24962474{
    2497     return jsNumber(exec, inlineEvaluateToNumber(exec));
     2475    return jsNumber(inlineEvaluateToNumber(exec));
    24982476}
    24992477
     
    25462524        if (value.isNull())
    25472525            return throwOutOfMemoryError(exec);
    2548         return jsString(exec, value);
    2549     }
    2550 
    2551     return jsNumber(exec, p1->toNumber(exec) + p2->toNumber(exec));
     2526        return jsString(value);
     2527    }
     2528
     2529    return jsNumber(p1->toNumber(exec) + p2->toNumber(exec));
    25522530}
    25532531
     
    25852563
    25862564    if (bothTypes == ((NumberType << 3) | NumberType))
    2587         return jsNumber(exec, v1->toNumber(exec) + v2->toNumber(exec));
     2565        return jsNumber(v1->toNumber(exec) + v2->toNumber(exec));
    25882566    if (bothTypes == ((StringType << 3) | StringType)) {
    25892567        UString value = static_cast<StringImp*>(v1)->value() + static_cast<StringImp*>(v2)->value();
    25902568        if (value.isNull())
    25912569            return throwOutOfMemoryError(exec);
    2592         return jsString(exec, value);
     2570        return jsString(value);
    25932571    }
    25942572
     
    26702648JSValue* AddNumbersNode::evaluate(ExecState* exec)
    26712649{
    2672     return jsNumber(exec, inlineEvaluateToNumber(exec));
     2650    return jsNumber(inlineEvaluateToNumber(exec));
    26732651}
    26742652
     
    26962674    KJS_CHECKEXCEPTIONVALUE
    26972675
    2698     return jsString(exec, static_cast<StringImp*>(v1)->value() + static_cast<StringImp*>(v2)->value());
     2676    return jsString(static_cast<StringImp*>(v1)->value() + static_cast<StringImp*>(v2)->value());
    26992677}
    27002678
     
    27082686
    27092687    JSValue* p2 = v2->toPrimitive(exec, UnspecifiedType);
    2710     return jsString(exec, static_cast<StringImp*>(v1)->value() + p2->toString(exec));
     2688    return jsString(static_cast<StringImp*>(v1)->value() + p2->toString(exec));
    27112689}
    27122690
     
    27202698
    27212699    JSValue* p1 = v1->toPrimitive(exec, UnspecifiedType);
    2722     return jsString(exec, p1->toString(exec) + static_cast<StringImp*>(v2)->value());
     2700    return jsString(p1->toString(exec) + static_cast<StringImp*>(v2)->value());
    27232701}
    27242702
     
    27402718JSValue* SubNode::evaluate(ExecState* exec)
    27412719{
    2742     return jsNumber(exec, inlineEvaluateToNumber(exec));
     2720    return jsNumber(inlineEvaluateToNumber(exec));
    27432721}
    27442722
     
    27772755JSValue* LeftShiftNode::evaluate(ExecState* exec)
    27782756{
    2779     return jsNumber(exec, inlineEvaluateToInt32(exec));
     2757    return jsNumber(inlineEvaluateToInt32(exec));
    27802758}
    27812759
     
    28122790JSValue* RightShiftNode::evaluate(ExecState* exec)
    28132791{
    2814     return jsNumber(exec, inlineEvaluateToInt32(exec));
     2792    return jsNumber(inlineEvaluateToInt32(exec));
    28152793}
    28162794
     
    28472825JSValue* UnsignedRightShiftNode::evaluate(ExecState* exec)
    28482826{
    2849     return jsNumber(exec, inlineEvaluateToUInt32(exec));
     2827    return jsNumber(inlineEvaluateToUInt32(exec));
    28502828}
    28512829
     
    32983276JSValue* BitXOrNode::evaluate(ExecState* exec)
    32993277{
    3300     return jsNumber(exec, inlineEvaluateToInt32(exec));
     3278    return jsNumber(inlineEvaluateToInt32(exec));
    33013279}
    33023280
     
    33373315JSValue* BitOrNode::evaluate(ExecState* exec)
    33383316{
    3339     return jsNumber(exec, inlineEvaluateToInt32(exec));
     3317    return jsNumber(inlineEvaluateToInt32(exec));
    33403318}
    33413319
     
    34673445    switch (oper) {
    34683446        case OpMultEq:
    3469             v = jsNumber(exec, current->toNumber(exec) * right->evaluateToNumber(exec));
     3447            v = jsNumber(current->toNumber(exec) * right->evaluateToNumber(exec));
    34703448            break;
    34713449        case OpDivEq:
    3472             v = jsNumber(exec, current->toNumber(exec) / right->evaluateToNumber(exec));
     3450            v = jsNumber(current->toNumber(exec) / right->evaluateToNumber(exec));
    34733451            break;
    34743452        case OpPlusEq:
     
    34763454            break;
    34773455        case OpMinusEq:
    3478             v = jsNumber(exec, current->toNumber(exec) - right->evaluateToNumber(exec));
     3456            v = jsNumber(current->toNumber(exec) - right->evaluateToNumber(exec));
    34793457            break;
    34803458        case OpLShift:
    34813459            i1 = current->toInt32(exec);
    34823460            i2 = right->evaluateToInt32(exec);
    3483             v = jsNumber(exec, i1 << i2);
     3461            v = jsNumber(i1 << i2);
    34843462            break;
    34853463        case OpRShift:
    34863464            i1 = current->toInt32(exec);
    34873465            i2 = right->evaluateToInt32(exec);
    3488             v = jsNumber(exec, i1 >> i2);
     3466            v = jsNumber(i1 >> i2);
    34893467            break;
    34903468        case OpURShift:
    34913469            ui = current->toUInt32(exec);
    34923470            i2 = right->evaluateToInt32(exec);
    3493             v = jsNumber(exec, ui >> i2);
     3471            v = jsNumber(ui >> i2);
    34943472            break;
    34953473        case OpAndEq:
    34963474            i1 = current->toInt32(exec);
    34973475            i2 = right->evaluateToInt32(exec);
    3498             v = jsNumber(exec, i1 & i2);
     3476            v = jsNumber(i1 & i2);
    34993477            break;
    35003478        case OpXOrEq:
    35013479            i1 = current->toInt32(exec);
    35023480            i2 = right->evaluateToInt32(exec);
    3503             v = jsNumber(exec, i1 ^ i2);
     3481            v = jsNumber(i1 ^ i2);
    35043482            break;
    35053483        case OpOrEq:
    35063484            i1 = current->toInt32(exec);
    35073485            i2 = right->evaluateToInt32(exec);
    3508             v = jsNumber(exec, i1 | i2);
     3486            v = jsNumber(i1 | i2);
    35093487            break;
    35103488        case OpModEq: {
    35113489            double d1 = current->toNumber(exec);
    35123490            double d2 = right->evaluateToNumber(exec);
    3513             v = jsNumber(exec, fmod(d1, d2));
     3491            v = jsNumber(fmod(d1, d2));
    35143492        }
    35153493            break;
     
    42634241            continue;
    42644242
    4265         JSValue* str = jsOwnedString(exec, name.ustring());
     4243        JSValue* str = jsOwnedString(name.ustring());
    42664244
    42674245        if (m_lexpr->isResolveNode()) {
     
    45894567
    45904568    if (m_catchBlock && exec->completionType() == Throw) {
    4591         JSObject* obj = new (exec) JSObject;
     4569        JSObject* obj = new JSObject;
    45924570        obj->putDirect(m_exceptionIdent, result, DontDelete);
    45934571        exec->dynamicGlobalObject()->tearOffActivation(exec);
     
    49494927FunctionImp* FuncDeclNode::makeFunction(ExecState* exec)
    49504928{
    4951     FunctionImp* func = new (exec) FunctionImp(exec, m_ident, m_body.get(), exec->scopeChain());
     4929    FunctionImp* func = new FunctionImp(exec, m_ident, m_body.get(), exec->scopeChain());
    49524930
    49534931    JSObject* proto = exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
    49544932    proto->putDirect(exec->propertyNames().constructor, func, DontEnum);
    49554933    func->putDirect(exec->propertyNames().prototype, proto, DontDelete);
    4956     func->putDirect(exec->propertyNames().length, jsNumber(exec, m_body->parameters().size()), ReadOnly | DontDelete | DontEnum);
     4934    func->putDirect(exec->propertyNames().length, jsNumber(m_body->parameters().size()), ReadOnly | DontDelete | DontEnum);
    49574935    return func;
    49584936}
     
    49834961        // but they won't register with the current scope chain and should
    49844962        // be contained as single property in an anonymous object.
    4985         functionScopeObject = new (exec) JSObject;
     4963        functionScopeObject = new JSObject;
    49864964        exec->pushScope(functionScopeObject);
    49874965    }
    49884966
    4989     FunctionImp* func = new (exec) FunctionImp(exec, m_ident, m_body.get(), exec->scopeChain());
     4967    FunctionImp* func = new FunctionImp(exec, m_ident, m_body.get(), exec->scopeChain());
    49904968    JSObject* proto = exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
    49914969    proto->putDirect(exec->propertyNames().constructor, func, DontEnum);
Note: See TracChangeset for help on using the changeset viewer.