Changeset 28907 in webkit


Ignore:
Timestamp:
Dec 20, 2007 1:57:18 PM (16 years ago)
Author:
Darin Adler
Message:

Same patch as last time with the test failures problem fixed.

  • kjs/function.cpp: (KJS::GlobalFuncImp::callAsFunction): Make sure to check the completion type from newExec to see if the execute raised an exception.
Location:
trunk/JavaScriptCore
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/API/JSContextRef.cpp

    r28899 r28907  
    3232#include "JSClassRef.h"
    3333#include "JSGlobalObject.h"
    34 #include "completion.h"
    3534#include "object.h"
    3635#include <wtf/Platform.h>

  • trunk/JavaScriptCore/ChangeLog

    r28899 r28907  
     12007-12-20  Darin Adler  <darin@apple.com>
     2
     3        - re-fix http://bugs.webkit.org/show_bug.cgi?id=16471
     4          Completions need to be smaller (or not exist at all)
     5
     6        Same patch as last time with the test failures problem fixed.
     7
     8        * kjs/function.cpp:
     9        (KJS::GlobalFuncImp::callAsFunction): Make sure to check the completion
     10        type from newExec to see if the execute raised an exception.
     11
    1122007-12-20  Darin Adler  <darin@apple.com>
    213

  • trunk/JavaScriptCore/bindings/runtime_method.cpp

    r28899 r28907  
    9393    return aValue;
    9494}
    95 
    96 Completion RuntimeMethod::execute(ExecState*)
    97 {
    98     return Completion(Normal, jsUndefined());
    99 }

  • trunk/JavaScriptCore/bindings/runtime_method.h

    r28899 r28907  
    3333namespace KJS {
    3434
    35 
    36 class RuntimeMethod : public InternalFunctionImp
    37 {
     35class RuntimeMethod : public InternalFunctionImp {
    3836public:
    3937    RuntimeMethod(ExecState *exec, const Identifier &n, Bindings::MethodList &methodList);
    … …  
    4240
    4341    virtual JSValue *callAsFunction(ExecState *exec, JSObject *thisObj, const List &args);
    44 
    45     virtual Completion execute(ExecState *exec);
    4642
    4743private:

  • trunk/JavaScriptCore/kjs/ExecState.h

    r28899 r28907  
    109109
    110110        LocalStorage& localStorage() { return *m_localStorage; }
    111    
     111
     112        // These are only valid right after calling execute().
     113        ComplType completionType() const { return m_completionType; }
     114        const Identifier& breakOrContinueTarget() const
     115        {
     116            ASSERT(m_completionType == Break || m_completionType == Continue);
     117            return *m_breakOrContinueTarget;
     118        }
     119
     120        // Only for use in the implementation of execute().
     121        void setCompletionType(ComplType type)
     122        {
     123            ASSERT(type != Break);
     124            ASSERT(type != Continue);
     125            m_completionType = type;
     126        }
     127        JSValue* setNormalCompletion()
     128        {
     129            ASSERT(!hadException());
     130            m_completionType = Normal;
     131            return 0;
     132        }
     133        JSValue* setNormalCompletion(JSValue* value)
     134        {
     135            ASSERT(!hadException());
     136            m_completionType = Normal;
     137            return value;
     138        }
     139        JSValue* setBreakCompletion(const Identifier* target)
     140        {
     141            ASSERT(!hadException());
     142            m_completionType = Break;
     143            m_breakOrContinueTarget = target;
     144            return 0;
     145        }
     146        JSValue* setContinueCompletion(const Identifier* target)
     147        {
     148            ASSERT(!hadException());
     149            m_completionType = Continue;
     150            m_breakOrContinueTarget = target;
     151            return 0;
     152        }
     153        JSValue* setReturnValueCompletion(JSValue* returnValue)
     154        {
     155            ASSERT(!hadException());
     156            ASSERT(returnValue);
     157            m_completionType = ReturnValue;
     158            return returnValue;
     159        }
     160        JSValue* setThrowCompletion(JSValue* exception)
     161        {
     162            ASSERT(!hadException());
     163            ASSERT(exception);
     164            m_completionType = Throw;
     165            return exception;
     166        }
     167        JSValue* setInterruptedCompletion()
     168        {
     169            ASSERT(!hadException());
     170            m_completionType = Interrupted;
     171            return 0;
     172        }
     173
    112174    public:
    113175        ExecState(JSGlobalObject* glob, JSObject* thisV,
    … …  
    142204        int m_switchDepth;
    143205        CodeType m_codeType;
     206
     207        ComplType m_completionType;
     208        const Identifier* m_breakOrContinueTarget;
    144209    };
    145210

  • trunk/JavaScriptCore/kjs/completion.h

    r28899 r28907  
    2727namespace KJS {
    2828
    29   class Identifier;
    3029  class JSValue;
    3130
    … …  
    4544  public:
    4645    Completion(ComplType type = Normal, JSValue* value = 0)
    47         : m_type(type), m_value(value), m_target(0) { }
    48     Completion(ComplType type, const Identifier* target)
    49         : m_type(type), m_value(0), m_target(target) { }
     46        : m_type(type), m_value(value) { }
    5047
    5148    ComplType complType() const { return m_type; }
    5249    JSValue* value() const { return m_value; }
    5350    void setValue(JSValue* v) { m_value = v; }
    54     const Identifier& target() const { return *m_target; }
    5551    bool isValueCompletion() const { return !!m_value; }
    5652
    … …  
    5854    ComplType m_type;
    5955    JSValue* m_value;
    60     const Identifier* m_target;
    6156  };
    6257

  • trunk/JavaScriptCore/kjs/date_object.h

    r28899 r28907  
    133133        virtual JSValue *callAsFunction(ExecState *, JSObject *thisObj, const List &args);
    134134
    135         Completion execute(const List &);
    136135        JSObject *construct(const List &);
    137136    };

  • trunk/JavaScriptCore/kjs/function.cpp

    r28899 r28907  
    7171JSValue* FunctionImp::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
    7272{
    73   // enter a new execution context
    74   ExecState newExec(exec->dynamicGlobalObject(), thisObj, body.get(), FunctionCode, exec, exec->dynamicGlobalObject()->currentExec(), this, &args);
    75   if (exec->hadException())
    76     newExec.setException(exec->exception());
    77 
    78   Completion comp = execute(&newExec);
    79 
    80   // if an exception occured, propogate it back to the previous execution object
    81   if (newExec.hadException())
    82     comp = Completion(Throw, newExec.exception());
    83 
    84   if (comp.complType() == Throw) {
    85     exec->setException(comp.value());
    86     return comp.value();
    87   }
    88   else if (comp.complType() == ReturnValue)
    89     return comp.value();
    90   else
     73    ExecState newExec(exec->dynamicGlobalObject(), thisObj, body.get(), FunctionCode, exec, exec->dynamicGlobalObject()->currentExec(), this, &args);
     74    JSValue* result = body->execute(&newExec);
     75    if (newExec.completionType() == Throw) {
     76        exec->setException(result);
     77        return result;
     78    }
     79    if (newExec.completionType() == ReturnValue)
     80        return result;
    9181    return jsUndefined();
    9282}
    … …  
    213203  else
    214204    return obj;
    215 }
    216 
    217 Completion FunctionImp::execute(ExecState* exec)
    218 {
    219   Completion result = body->execute(exec);
    220 
    221   if (result.complType() == Throw || result.complType() == ReturnValue)
    222       return result;
    223   return Completion(Normal, jsUndefined()); // TODO: or ReturnValue ?
    224205}
    225206
    … …  
    719700        JSObject* thisVal = static_cast<JSObject*>(exec->thisValue());
    720701        ExecState newExec(globalObject, thisVal, evalNode.get(), EvalCode, exec, globalObject->currentExec());
    721         if (exec->hadException())
    722             newExec.setException(exec->exception());
    723702         
    724703        if (switchGlobal) {
    … …  
    726705            newExec.setVariableObject(static_cast<JSGlobalObject*>(thisObj));
    727706        }
    728        
    729         Completion c = evalNode->execute(&newExec);
    730          
     707        JSValue* value = evalNode->execute(&newExec);
    731708        if (switchGlobal)
    732709            newExec.popScope();
    733710
    734         // if an exception occured, propogate it back to the previous execution object
    735         if (newExec.hadException())
    736           exec->setException(newExec.exception());
    737 
    738         res = jsUndefined();
    739         if (c.complType() == Throw)
    740           exec->setException(c.value());
    741         else if (c.isValueCompletion())
    742             res = c.value();
     711        if (newExec.completionType() == Throw) {
     712            exec->setException(value);
     713            return value;
     714        }
     715        return value ? value : jsUndefined();
    743716      }
    744       break;
    745717    }
    746718  case ParseInt:

  • trunk/JavaScriptCore/kjs/function.h

    r28899 r28907  
    8383   
    8484    virtual JSValue* callAsFunction(ExecState*, JSObject* thisObj, const List& args);
    85     Completion execute(ExecState*);
    8685
    8786    // Note: unlike body->paramName, this returns Identifier::null for parameters

  • trunk/JavaScriptCore/kjs/interpreter.cpp

    r28899 r28907  
    121121        // execute the code
    122122        ExecState newExec(globalObject, thisObj, progNode.get());
    123         res = progNode->execute(&newExec);
     123        JSValue* value = progNode->execute(&newExec);
     124        res = Completion(newExec.completionType(), value);
    124125    }
    125126   

  • trunk/JavaScriptCore/kjs/nodes.cpp

    r28899 r28907  
    4747#define KJS_BREAKPOINT \
    4848  if (Debugger::debuggersPresent > 0 && !hitStatement(exec)) \
    49     return Completion(Normal);
     49    return 0;
    5050
    5151#define KJS_CHECKEXCEPTION \
    … …  
    272272}
    273273
    274 Completion Node::createErrorCompletion(ExecState* exec, ErrorType e, const char *msg)
    275 {
    276     return Completion(Throw, Error::create(exec, e, msg, lineNo(), currentSourceId(exec), currentSourceURL(exec)));
    277 }
    278 
    279 Completion Node::createErrorCompletion(ExecState *exec, ErrorType e, const char *msg, const Identifier &ident)
     274JSValue* Node::setErrorCompletion(ExecState* exec, ErrorType e, const char* msg)
     275{
     276    return exec->setThrowCompletion(Error::create(exec, e, msg, lineNo(), currentSourceId(exec), currentSourceURL(exec)));
     277}
     278
     279JSValue* Node::setErrorCompletion(ExecState* exec, ErrorType e, const char* msg, const Identifier& ident)
    280280{
    281281    UString message = msg;
    282282    substitute(message, ident.ustring());
    283     return Completion(Throw, Error::create(exec, e, message, lineNo(), currentSourceId(exec), currentSourceURL(exec)));
     283    return exec->setThrowCompletion(Error::create(exec, e, message, lineNo(), currentSourceId(exec), currentSourceURL(exec)));
    284284}
    285285
    … …  
    365365}
    366366
    367 Completion Node::rethrowException(ExecState* exec)
     367JSValue* Node::rethrowException(ExecState* exec)
    368368{
    369369    JSValue* exception = exec->exception();
    370370    exec->clearException();
    371371    handleException(exec, exception);
    372     return Completion(Throw, exception);
     372    return exec->setThrowCompletion(exception);
    373373}
    374374
    … …  
    387387}
    388388
    389 // return true if the debugger wants us to stop at this point
     389// Set normal completion and return false if the debugger wants us to stop at this point.
     390// FIXME: This seems like poor naming and strange design. Why false to stop? Why "hit statement"?
    390391bool StatementNode::hitStatement(ExecState* exec)
    391392{
    392   Debugger *dbg = exec->dynamicGlobalObject()->debugger();
    393   if (dbg)
    394     return dbg->atStatement(exec, currentSourceId(exec), firstLine(), lastLine());
    395   else
    396     return true; // continue
     393    Debugger* debugger = exec->dynamicGlobalObject()->debugger();
     394    if (!debugger || debugger->atStatement(exec, currentSourceId(exec), firstLine(), lastLine()))
     395        return true;
     396    exec->setCompletionType(Normal);
     397    return false;
    397398}
    398399
    … …  
    35493550
    35503551// ECMA 12.2
    3551 Completion VarStatementNode::execute(ExecState *exec)
    3552 {
    3553     KJS_BREAKPOINT;
     3552JSValue* VarStatementNode::execute(ExecState* exec)
     3553{
     3554    KJS_BREAKPOINT
    35543555
    35553556    next->evaluate(exec);
    35563557    KJS_CHECKEXCEPTION
    35573558
    3558     return Completion(Normal);
     3559    return exec->setNormalCompletion();
    35593560}
    35603561
    … …  
    35883589}
    35893590
    3590 static inline Completion statementListExecute(SourceElements& statements, ExecState* exec)
    3591 {
    3592     JSValue* v = 0;
    3593     Completion c(Normal);
    3594     const SourceElements::iterator end = statements.end();
    3595     for (SourceElements::iterator ptr = statements.begin(); ptr != end; ++ptr) {
    3596         c = (*ptr)->execute(exec);
    3597        
    3598         if (JSValue* v2 = c.value())
    3599             v = v2;
    3600         c.setValue(v);
    3601        
    3602         if (c.complType() != Normal)
    3603             return c;
    3604     }
    3605     return c;
    3606 }
    3607    
     3591static inline JSValue* statementListExecute(SourceElements& statements, ExecState* exec)
     3592{
     3593    JSValue* value = 0;
     3594    size_t size = statements.size();
     3595    for (size_t i = 0; i != size; ++i) {
     3596        JSValue* statementValue = statements[i]->execute(exec);
     3597        if (exec->completionType() != Normal)
     3598            return statementValue;
     3599        if (statementValue)
     3600            value = statementValue;
     3601    }
     3602    return exec->setNormalCompletion(value);
     3603}
     3604
    36083605// ------------------------------ BlockNode ------------------------------------
    36093606
    … …  
    36203617
    36213618// ECMA 12.1
    3622 Completion BlockNode::execute(ExecState *exec)
     3619JSValue* BlockNode::execute(ExecState* exec)
    36233620{
    36243621    return statementListExecute(*m_children, exec);
    … …  
    36283625
    36293626// ECMA 12.3
    3630 Completion EmptyStatementNode::execute(ExecState *)
    3631 {
    3632   return Completion(Normal);
     3627JSValue* EmptyStatementNode::execute(ExecState* exec)
     3628{
     3629    return exec->setNormalCompletion();
    36333630}
    36343631
    … …  
    36423639
    36433640// ECMA 12.4
    3644 Completion ExprStatementNode::execute(ExecState *exec)
    3645 {
    3646   KJS_BREAKPOINT;
    3647 
    3648   JSValue *v = expr->evaluate(exec);
    3649   KJS_CHECKEXCEPTION
    3650 
    3651   return Completion(Normal, v);
     3641JSValue* ExprStatementNode::execute(ExecState* exec)
     3642{
     3643    KJS_BREAKPOINT
     3644
     3645    JSValue* value = expr->evaluate(exec);
     3646    KJS_CHECKEXCEPTION
     3647
     3648    return exec->setNormalCompletion(value);
    36523649}
    36533650
    … …  
    36653662
    36663663// ECMA 12.5
    3667 Completion IfNode::execute(ExecState* exec)
    3668 {
    3669     KJS_BREAKPOINT;
     3664JSValue* IfNode::execute(ExecState* exec)
     3665{
     3666    KJS_BREAKPOINT
    36703667
    36713668    bool b = expr->evaluateToBoolean(exec);
    … …  
    36783675    // no else
    36793676    if (!statement2)
    3680         return Completion(Normal);
     3677        return exec->setNormalCompletion();
    36813678
    36823679    // else
    … …  
    36933690
    36943691// ECMA 12.6.1
    3695 Completion DoWhileNode::execute(ExecState *exec)
    3696 {
    3697     KJS_BREAKPOINT;
     3692JSValue* DoWhileNode::execute(ExecState* exec)
     3693{
     3694    KJS_BREAKPOINT
    36983695
    36993696    JSValue* value = 0;
    … …  
    37013698    while (1) {
    37023699        exec->pushIteration();
    3703         Completion c = statement->execute(exec);
     3700        JSValue* statementValue = statement->execute(exec);
    37043701        exec->popIteration();
    37053702
    37063703        if (exec->dynamicGlobalObject()->timedOut())
    3707             return Completion(Interrupted);
    3708 
    3709         if (c.isValueCompletion())
    3710             value = c.value();
    3711 
    3712         if (!((c.complType() == Continue) && ls.contains(c.target()))) {
    3713             if ((c.complType() == Break) && ls.contains(c.target()))
    3714                 return Completion(Normal, value);
    3715             if (c.complType() != Normal)
    3716                 return c;
     3704            exec->setInterruptedCompletion();
     3705
     3706        if (statementValue)
     3707            value = statementValue;
     3708
     3709        if (exec->completionType() != Normal) {
     3710            if (exec->completionType() == Continue && ls.contains(exec->breakOrContinueTarget()))
     3711                goto continueDoWhileLoop;
     3712            if (exec->completionType() == Break && ls.contains(exec->breakOrContinueTarget()))
     3713                break;
     3714            return statementValue;
    37173715        }
    37183716
     3717continueDoWhileLoop:
    37193718        bool b = expr->evaluateToBoolean(exec);
    37203719        KJS_CHECKEXCEPTION
    37213720        if (!b)
    3722             return Completion(Normal, value);
    3723     }
    3724 
    3725     return Completion(); // work around gcc 4.0 bug
     3721            break;
     3722    }
     3723
     3724    return exec->setNormalCompletion(value);
    37263725}
    37273726
    … …  
    37353734
    37363735// ECMA 12.6.2
    3737 Completion WhileNode::execute(ExecState *exec)
    3738 {
    3739     KJS_BREAKPOINT;
     3736JSValue* WhileNode::execute(ExecState* exec)
     3737{
     3738    KJS_BREAKPOINT
    37403739
    37413740    JSValue* value = 0;
    … …  
    37453744        KJS_CHECKEXCEPTION
    37463745        if (!b)
    3747             return Completion(Normal, value);
     3746            break;
    37483747
    37493748        exec->pushIteration();
    3750         Completion c = statement->execute(exec);
     3749        JSValue* statementValue = statement->execute(exec);
    37513750        exec->popIteration();
    37523751
    37533752        if (exec->dynamicGlobalObject()->timedOut())
    3754             return Completion(Interrupted);
    3755    
    3756         if (c.isValueCompletion())
    3757             value = c.value();
    3758 
    3759         if ((c.complType() == Continue) && ls.contains(c.target()))
    3760             continue;
    3761         if ((c.complType() == Break) && ls.contains(c.target()))
    3762             return Completion(Normal, value);
    3763         if (c.complType() != Normal)
    3764             return c;
    3765     }
    3766 
    3767     return Completion(); // work around gcc 4.0 bug
     3753            return exec->setInterruptedCompletion();
     3754   
     3755        if (statementValue)
     3756            value = statementValue;
     3757
     3758        if (exec->completionType() != Normal) {
     3759            if (exec->completionType() == Continue && ls.contains(exec->breakOrContinueTarget()))
     3760                continue;
     3761            if (exec->completionType() == Break && ls.contains(exec->breakOrContinueTarget()))
     3762                break;
     3763            return statementValue;
     3764        }
     3765    }
     3766
     3767    return exec->setNormalCompletion(value);
    37683768}
    37693769
    … …  
    37823782
    37833783// ECMA 12.6.3
    3784 Completion ForNode::execute(ExecState *exec)
    3785 {
    3786     JSValue* cval = 0;
     3784JSValue* ForNode::execute(ExecState *exec)
     3785{
     3786    JSValue* value = 0;
    37873787
    37883788    if (expr1) {
    … …  
    37963796            KJS_CHECKEXCEPTION
    37973797            if (!b)
    3798                 return Completion(Normal, cval);
     3798                break;
    37993799        }
    38003800
    38013801        exec->pushIteration();
    3802         Completion c = statement->execute(exec);
     3802        JSValue* statementValue = statement->execute(exec);
    38033803        exec->popIteration();
    3804         if (c.isValueCompletion())
    3805             cval = c.value();
    3806         if (!((c.complType() == Continue) && ls.contains(c.target()))) {
    3807             if ((c.complType() == Break) && ls.contains(c.target()))
    3808                 return Completion(Normal, cval);
    3809             if (c.complType() != Normal)
    3810                 return c;
     3804        if (statementValue)
     3805            value = statementValue;
     3806
     3807        if (exec->dynamicGlobalObject()->timedOut())
     3808            return exec->setInterruptedCompletion();
     3809
     3810        if (exec->completionType() != Normal) {
     3811            if (exec->completionType() == Continue && ls.contains(exec->breakOrContinueTarget()))
     3812                goto continueForLoop;
     3813            if (exec->completionType() == Break && ls.contains(exec->breakOrContinueTarget()))
     3814                break;
     3815            return statementValue;
    38113816        }
    38123817
    3813         if (exec->dynamicGlobalObject()->timedOut())
    3814             return Completion(Interrupted);
    3815 
     3818continueForLoop:
    38163819        if (expr3) {
    38173820            expr3->evaluate(exec);
    … …  
    38203823    }
    38213824 
    3822     return Completion(); // work around gcc 4.0 bug
     3825    return exec->setNormalCompletion(value);
    38233826}
    38243827
    … …  
    38483851
    38493852// ECMA 12.6.4
    3850 Completion ForInNode::execute(ExecState *exec)
    3851 {
    3852   JSValue *e;
    3853   JSValue *retval = 0;
    3854   JSObject *v;
    3855   Completion c;
    3856   PropertyNameArray propertyNames;
     3853JSValue* ForInNode::execute(ExecState* exec)
     3854{
     3855  JSValue* value = 0;
    38573856
    38583857  if (varDecl) {
    … …  
    38613860  }
    38623861
    3863   e = expr->evaluate(exec);
    3864 
    3865   // for Null and Undefined, we want to make sure not to go through
    3866   // the loop at all, because their object wrappers will have a
    3867   // property list but will throw an exception if you attempt to
    3868   // access any property.
     3862  JSValue* e = expr->evaluate(exec);
     3863
     3864  // For Null and Undefined, we want to make sure not to go through
     3865  // the loop at all, because toObject will throw an exception.
    38693866  if (e->isUndefinedOrNull())
    3870     return Completion(Normal);
     3867    return exec->setNormalCompletion();
    38713868
    38723869  KJS_CHECKEXCEPTION
    3873   v = e->toObject(exec);
     3870  JSObject* v = e->toObject(exec);
     3871  PropertyNameArray propertyNames;
    38743872  v->getPropertyNames(exec, propertyNames);
    38753873 
    38763874  PropertyNameArray::const_iterator end = propertyNames.end();
    38773875  for (PropertyNameArray::const_iterator it = propertyNames.begin(); it != end; ++it) {
    3878       const Identifier &name = *it;
     3876      const Identifier& name = *it;
    38793877      if (!v->hasProperty(exec, name))
    38803878          continue;
    … …  
    39293927
    39303928    exec->pushIteration();
    3931     c = statement->execute(exec);
     3929    JSValue* statementValue = statement->execute(exec);
    39323930    exec->popIteration();
    3933     if (c.isValueCompletion())
    3934       retval = c.value();
    3935 
    3936     if (!((c.complType() == Continue) && ls.contains(c.target()))) {
    3937       if ((c.complType() == Break) && ls.contains(c.target()))
    3938         break;
    3939       if (c.complType() != Normal) {
    3940         return c;
    3941       }
     3931    if (statementValue)
     3932      value = statementValue;
     3933
     3934    if (exec->completionType() != Normal) {
     3935        if (exec->completionType() == Continue && ls.contains(exec->breakOrContinueTarget()))
     3936            continue;
     3937        if (exec->completionType() == Break && ls.contains(exec->breakOrContinueTarget()))
     3938            break;
     3939        return statementValue;
    39423940    }
    39433941  }
    39443942
    3945   return Completion(Normal, retval);
     3943  return exec->setNormalCompletion(value);
    39463944}
    39473945
    … …  
    39493947
    39503948// ECMA 12.7
    3951 Completion ContinueNode::execute(ExecState *exec)
    3952 {
    3953   KJS_BREAKPOINT;
     3949JSValue* ContinueNode::execute(ExecState* exec)
     3950{
     3951  KJS_BREAKPOINT
    39543952
    39553953  if (ident.isEmpty() && !exec->inIteration())
    3956     return createErrorCompletion(exec, SyntaxError, "Invalid continue statement.");
     3954    return setErrorCompletion(exec, SyntaxError, "Invalid continue statement.");
    39573955  if (!ident.isEmpty() && !exec->seenLabels()->contains(ident))
    3958     return createErrorCompletion(exec, SyntaxError, "Label %s not found.", ident);
    3959   return Completion(Continue, &ident);
     3956    return setErrorCompletion(exec, SyntaxError, "Label %s not found.", ident);
     3957  return exec->setContinueCompletion(&ident);
    39603958}
    39613959
    … …  
    39633961
    39643962// ECMA 12.8
    3965 Completion BreakNode::execute(ExecState *exec)
    3966 {
    3967   KJS_BREAKPOINT;
    3968 
    3969   if (ident.isEmpty() && !exec->inIteration() &&
    3970       !exec->inSwitch())
    3971     return createErrorCompletion(exec, SyntaxError, "Invalid break statement.");
     3963JSValue* BreakNode::execute(ExecState *exec)
     3964{
     3965  KJS_BREAKPOINT
     3966
     3967  if (ident.isEmpty() && !exec->inIteration() && !exec->inSwitch())
     3968    return setErrorCompletion(exec, SyntaxError, "Invalid break statement.");
    39723969  if (!ident.isEmpty() && !exec->seenLabels()->contains(ident))
    3973     return createErrorCompletion(exec, SyntaxError, "Label %s not found.");
    3974   return Completion(Break, &ident);
     3970    return setErrorCompletion(exec, SyntaxError, "Label %s not found.");
     3971  return exec->setBreakCompletion(&ident);
    39753972}
    39763973
    … …  
    39843981
    39853982// ECMA 12.9
    3986 Completion ReturnNode::execute(ExecState *exec)
    3987 {
    3988   KJS_BREAKPOINT;
     3983JSValue* ReturnNode::execute(ExecState* exec)
     3984{
     3985  KJS_BREAKPOINT
    39893986
    39903987  CodeType codeType = exec->codeType();
    39913988  if (codeType != FunctionCode)
    3992     return createErrorCompletion(exec, SyntaxError, "Invalid return statement.");
     3989    return setErrorCompletion(exec, SyntaxError, "Invalid return statement.");
    39933990
    39943991  if (!value)
    3995     return Completion(ReturnValue, jsUndefined());
    3996 
    3997   JSValue *v = value->evaluate(exec);
     3992    return exec->setReturnValueCompletion(jsUndefined());
     3993
     3994  JSValue* v = value->evaluate(exec);
    39983995  KJS_CHECKEXCEPTION
    39993996
    4000   return Completion(ReturnValue, v);
     3997  return exec->setReturnValueCompletion(v);
    40013998}
    40023999
    … …  
    40104007
    40114008// ECMA 12.10
    4012 Completion WithNode::execute(ExecState *exec)
    4013 {
    4014   KJS_BREAKPOINT;
     4009JSValue* WithNode::execute(ExecState *exec)
     4010{
     4011  KJS_BREAKPOINT
    40154012
    40164013  JSValue *v = expr->evaluate(exec);
    … …  
    40194016  KJS_CHECKEXCEPTION
    40204017  exec->pushScope(o);
    4021   Completion res = statement->execute(exec);
     4018  JSValue* value = statement->execute(exec);
    40224019  exec->popScope();
    40234020
    4024   return res;
     4021  return value;
    40254022}
    40264023   
    … …  
    40454042
    40464043// ECMA 12.11
    4047 Completion CaseClauseNode::evalStatements(ExecState *exec)
     4044JSValue* CaseClauseNode::executeStatements(ExecState* exec)
    40484045{
    40494046  if (m_children)
    40504047    return statementListExecute(*m_children, exec);
    4051   else
    4052     return Completion(Normal, jsUndefined());
     4048  return exec->setNormalCompletion();
    40534049}
    40544050
    … …  
    40824078
    40834079// ECMA 12.11
    4084 Completion CaseBlockNode::evalBlock(ExecState *exec, JSValue *input)
    4085 {
    4086   JSValue *v;
    4087   Completion res;
    4088   ClauseListNode *a = list1.get();
    4089   ClauseListNode *b = list2.get();
    4090   CaseClauseNode *clause;
    4091 
     4080JSValue* CaseBlockNode::executeBlock(ExecState* exec, JSValue* input)
     4081{
     4082  ClauseListNode* a = list1.get();
    40924083    while (a) {
    4093       clause = a->getClause();
     4084      CaseClauseNode* clause = a->getClause();
    40944085      a = a->getNext();
    4095       v = clause->evaluate(exec);
     4086      JSValue* v = clause->evaluate(exec);
    40964087      KJS_CHECKEXCEPTION
    40974088      if (strictEqual(exec, input, v)) {
    4098         res = clause->evalStatements(exec);
    4099         if (res.complType() != Normal)
     4089        JSValue* res = clause->executeStatements(exec);
     4090        if (exec->completionType() != Normal)
    41004091          return res;
    4101         while (a) {
    4102           res = a->getClause()->evalStatements(exec);
    4103           if (res.complType() != Normal)
     4092        for (; a; a = a->getNext()) {
     4093          JSValue* res = a->getClause()->executeStatements(exec);
     4094          if (exec->completionType() != Normal)
    41044095            return res;
    4105           a = a->getNext();
    41064096        }
    41074097        break;
    … …  
    41094099    }
    41104100
     4101  ClauseListNode* b = list2.get();
    41114102  while (b) {
    4112     clause = b->getClause();
     4103    CaseClauseNode* clause = b->getClause();
    41134104    b = b->getNext();
    4114     v = clause->evaluate(exec);
     4105    JSValue* v = clause->evaluate(exec);
    41154106    KJS_CHECKEXCEPTION
    41164107    if (strictEqual(exec, input, v)) {
    4117       res = clause->evalStatements(exec);
    4118       if (res.complType() != Normal)
     4108      JSValue* res = clause->executeStatements(exec);
     4109      if (exec->completionType() != Normal)
    41194110        return res;
    41204111      goto step18;
    … …  
    41244115  // default clause
    41254116  if (def) {
    4126     res = def->evalStatements(exec);
    4127     if (res.complType() != Normal)
     4117    JSValue* res = def->executeStatements(exec);
     4118    if (exec->completionType() != Normal)
    41284119      return res;
    41294120  }
    … …  
    41314122 step18:
    41324123  while (b) {
    4133     clause = b->getClause();
    4134     res = clause->evalStatements(exec);
    4135     if (res.complType() != Normal)
     4124    CaseClauseNode* clause = b->getClause();
     4125    JSValue* res = clause->executeStatements(exec);
     4126    if (exec->completionType() != Normal)
    41364127      return res;
    41374128    b = b->getNext();
    … …  
    41414132  KJS_CHECKEXCEPTION
    41424133
    4143   return Completion(Normal);
     4134  return exec->setNormalCompletion();
    41444135}
    41454136
    … …  
    41534144
    41544145// ECMA 12.11
    4155 Completion SwitchNode::execute(ExecState *exec)
    4156 {
    4157   KJS_BREAKPOINT;
     4146JSValue* SwitchNode::execute(ExecState* exec)
     4147{
     4148  KJS_BREAKPOINT
    41584149
    41594150  JSValue *v = expr->evaluate(exec);
    … …  
    41614152
    41624153  exec->pushSwitch();
    4163   Completion res = block->evalBlock(exec,v);
     4154  JSValue* result = block->executeBlock(exec, v);
    41644155  exec->popSwitch();
    41654156
    4166   if ((res.complType() == Break) && ls.contains(res.target()))
    4167     return Completion(Normal, res.value());
    4168   return res;
     4157  if (exec->completionType() == Break && ls.contains(exec->breakOrContinueTarget()))
     4158    exec->setCompletionType(Normal);
     4159  return result;
    41694160}
    41704161
    … …  
    41774168
    41784169// ECMA 12.12
    4179 Completion LabelNode::execute(ExecState *exec)
     4170JSValue* LabelNode::execute(ExecState *exec)
    41804171{
    41814172  if (!exec->seenLabels()->push(label))
    4182     return createErrorCompletion(exec, SyntaxError, "Duplicated label %s found.", label);
    4183   Completion e = statement->execute(exec);
     4173    return setErrorCompletion(exec, SyntaxError, "Duplicated label %s found.", label);
     4174  JSValue* result = statement->execute(exec);
    41844175  exec->seenLabels()->pop();
    41854176
    4186   if ((e.complType() == Break) && (e.target() == label))
    4187     return Completion(Normal, e.value());
    4188   return e;
     4177  if (exec->completionType() == Break && exec->breakOrContinueTarget() == label)
     4178    exec->setCompletionType(Normal);
     4179  return result;
    41894180}
    41904181
    … …  
    41974188
    41984189// ECMA 12.13
    4199 Completion ThrowNode::execute(ExecState *exec)
    4200 {
    4201   KJS_BREAKPOINT;
     4190JSValue* ThrowNode::execute(ExecState* exec)
     4191{
     4192  KJS_BREAKPOINT
    42024193
    42034194  JSValue *v = expr->evaluate(exec);
    … …  
    42054196
    42064197  handleException(exec, v);
    4207   return Completion(Throw, v);
     4198  return exec->setThrowCompletion(v);
    42084199}
    42094200
    … …  
    42194210
    42204211// ECMA 12.14
    4221 Completion TryNode::execute(ExecState *exec)
    4222 {
    4223   KJS_BREAKPOINT;
    4224 
    4225   Completion c = tryBlock->execute(exec);
     4212JSValue* TryNode::execute(ExecState *exec)
     4213{
     4214  KJS_BREAKPOINT
     4215
     4216  JSValue* result = tryBlock->execute(exec);
    42264217
    42274218  if (Collector::isOutOfMemory())
    4228       return c; // don't try to catch an out of memory exception thrown by the collector
     4219      return result; // don't try to catch an out of memory exception thrown by the collector
    42294220 
    4230   if (catchBlock && c.complType() == Throw) {
    4231     JSObject *obj = new JSObject;
    4232     obj->put(exec, exceptionIdent, c.value(), DontDelete);
     4221  if (catchBlock && exec->completionType() == Throw) {
     4222    JSObject* obj = new JSObject;
     4223    obj->put(exec, exceptionIdent, result, DontDelete);
    42334224    exec->pushScope(obj);
    4234     c = catchBlock->execute(exec);
     4225    result = catchBlock->execute(exec);
    42354226    exec->popScope();
    42364227  }
    42374228
    42384229  if (finallyBlock) {
    4239     Completion c2 = finallyBlock->execute(exec);
    4240     if (c2.complType() != Normal)
    4241       c = c2;
     4230    ComplType savedCompletionType = exec->completionType();
     4231    JSValue* finallyResult = finallyBlock->execute(exec);
     4232    if (exec->completionType() != Normal)
     4233        result = finallyResult;
     4234    else
     4235        exec->setCompletionType(savedCompletionType);
    42424236  }
    42434237
    4244   return c;
     4238  return result;
    42454239}
    42464240
    … …  
    44974491}
    44984492
    4499 Completion ProgramNode::execute(ExecState* exec)
     4493JSValue* ProgramNode::execute(ExecState* exec)
    45004494{
    45014495    processDeclarations(exec);
    … …  
    45034497}
    45044498
    4505 Completion EvalNode::execute(ExecState* exec)
     4499JSValue* EvalNode::execute(ExecState* exec)
    45064500{
    45074501    processDeclarations(exec);
    … …  
    45094503}
    45104504
    4511 Completion FunctionBodyNode::execute(ExecState* exec)
     4505JSValue* FunctionBodyNode::execute(ExecState* exec)
    45124506{
    45134507    processDeclarations(exec);
    … …  
    45164510        if (!dbg->callEvent(exec, sourceId(), lineNo(), exec->function(), *exec->arguments())) {
    45174511            dbg->imp()->abort();
    4518             return Completion(Interrupted, jsUndefined());
     4512            return exec->setInterruptedCompletion();
    45194513        }
    45204514    }   
    45214515   
    4522     Completion completion = ScopeNode::execute(exec);
     4516    JSValue* result = ScopeNode::execute(exec);
    45234517   
    45244518    if (Debugger* dbg = exec->dynamicGlobalObject()->debugger()) {
    4525         if (completion.complType() == Throw)
    4526             exec->setException(completion.value());
    4527 
     4519        if (exec->completionType() == Throw)
     4520            exec->setException(result);
    45284521        if (!dbg->returnEvent(exec, sourceId(), lineNo(), exec->function())) {
    45294522            dbg->imp()->abort();
    4530             return Completion(Interrupted, jsUndefined());
     4523            return exec->setInterruptedCompletion();
    45314524        }
    45324525    }
    45334526
    45344527   
    4535     return completion;
     4528    return result;
    45364529}
    45374530
    … …  
    45564549}
    45574550
    4558 Completion FuncDeclNode::execute(ExecState *)
    4559 {
    4560     return Completion(Normal);
     4551JSValue* FuncDeclNode::execute(ExecState* exec)
     4552{
     4553    return exec->setNormalCompletion();
    45614554}
    45624555

  • trunk/JavaScriptCore/kjs/nodes.h

    r28899 r28907  
    145145  protected:
    146146    Node(JSType) KJS_FAST_CALL; // used by ExpressionNode
    147     Completion createErrorCompletion(ExecState *, ErrorType, const char *msg) KJS_FAST_CALL;
    148     Completion createErrorCompletion(ExecState *, ErrorType, const char *msg, const Identifier &) KJS_FAST_CALL;
    149 
     147
     148    // for use in execute()
     149    JSValue* setErrorCompletion(ExecState*, ErrorType, const char* msg) KJS_FAST_CALL;
     150    JSValue* setErrorCompletion(ExecState*, ErrorType, const char* msg, const Identifier&) KJS_FAST_CALL;
     151
     152    // for use in evaluate()
    150153    JSValue* throwError(ExecState*, ErrorType, const char* msg) KJS_FAST_CALL;
    151154    JSValue* throwError(ExecState*, ErrorType, const char* msg, const char*) KJS_FAST_CALL;
    … …  
    161164    void handleException(ExecState*, JSValue*) KJS_FAST_CALL;
    162165
    163     Completion rethrowException(ExecState*) KJS_FAST_CALL;
     166    // for use in execute()
     167    JSValue* rethrowException(ExecState*) KJS_FAST_CALL;
    164168
    165169    int m_line : 28;
    … …  
    201205    int firstLine() const KJS_FAST_CALL { return lineNo(); }
    202206    int lastLine() const KJS_FAST_CALL { return m_lastLine; }
    203     bool hitStatement(ExecState*) KJS_FAST_CALL;
    204     virtual Completion execute(ExecState *exec) KJS_FAST_CALL = 0;
     207    virtual JSValue* execute(ExecState *exec) KJS_FAST_CALL = 0;
    205208    void pushLabel(const Identifier &id) KJS_FAST_CALL { ls.push(id); }
    206209    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    207210  protected:
     211    bool hitStatement(ExecState*) KJS_FAST_CALL;
    208212    LabelStack ls;
    209213  private:
    … …  
    17251729    VarStatementNode(VarDeclNode* l) KJS_FAST_CALL : next(l) { }
    17261730    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1727     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1731    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    17281732    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    17291733  private:
    … …  
    17441748    }
    17451749    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL { ASSERT_NOT_REACHED(); }
    1746     virtual Completion execute(ExecState*) KJS_FAST_CALL  { ASSERT_NOT_REACHED(); return Completion(); }
     1750    virtual JSValue* execute(ExecState*) KJS_FAST_CALL  { ASSERT_NOT_REACHED(); return 0; }
    17471751    virtual void streamTo(SourceStream&) const KJS_FAST_CALL  { ASSERT_NOT_REACHED(); }
    17481752    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    … …  
    17551759    BlockNode(SourceElements* children) KJS_FAST_CALL;
    17561760    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1757     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1761    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    17581762    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    17591763  protected:
    … …  
    17641768  public:
    17651769    EmptyStatementNode() KJS_FAST_CALL { } // debug
    1766     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1770    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    17671771    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    17681772  };
    … …  
    17721776    ExprStatementNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
    17731777    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1774     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1778    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    17751779    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    17761780  private:
    … …  
    17831787      : expr(e), statement1(s1), statement2(s2) { }
    17841788    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1785     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1789    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    17861790    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    17871791  private:
    … …  
    17951799    DoWhileNode(StatementNode *s, ExpressionNode* e) KJS_FAST_CALL : statement(s), expr(e) { }
    17961800    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1797     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1801    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    17981802    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    17991803  private:
    … …  
    18061810    WhileNode(ExpressionNode* e, StatementNode *s) KJS_FAST_CALL : expr(e), statement(s) { }
    18071811    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1808     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1812    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18091813    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18101814  private:
    … …  
    18251829
    18261830    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1827     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1831    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18281832    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18291833  private:
    … …  
    18391843    ForInNode(const Identifier &i, AssignExprNode *in, ExpressionNode* e, StatementNode *s) KJS_FAST_CALL;
    18401844    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1841     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1845    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18421846    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18431847    VarDeclNode* getVarDecl() { return varDecl.get(); }
    … …  
    18551859    ContinueNode() KJS_FAST_CALL { }
    18561860    ContinueNode(const Identifier &i) KJS_FAST_CALL : ident(i) { }
    1857     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1861    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18581862    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18591863  private:
    … …  
    18651869    BreakNode() KJS_FAST_CALL { }
    18661870    BreakNode(const Identifier &i) KJS_FAST_CALL : ident(i) { }
    1867     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1871    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18681872    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18691873  private:
    … …  
    18751879    ReturnNode(ExpressionNode* v) KJS_FAST_CALL : value(v) {}
    18761880    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1877     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1881    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18781882    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18791883  private:
    … …  
    18851889    WithNode(ExpressionNode* e, StatementNode* s) KJS_FAST_CALL : expr(e), statement(s) { }
    18861890    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1887     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1891    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18881892    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    18891893  private:
    … …  
    18961900    LabelNode(const Identifier &l, StatementNode *s) KJS_FAST_CALL : label(l), statement(s) { }
    18971901    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1898     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1902    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    18991903    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19001904  private:
    … …  
    19071911    ThrowNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) {}
    19081912    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1909     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1913    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19101914    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19111915  private:
    … …  
    19181922      : tryBlock(b), exceptionIdent(e), catchBlock(c), finallyBlock(f) { }
    19191923    virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    1920     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1924    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19211925    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    19221926  private:
    … …  
    19651969  public:
    19661970    ProgramNode(SourceElements*, DeclarationStacks::VarStack*, DeclarationStacks::FunctionStack*) KJS_FAST_CALL;
    1967     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1971    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19681972   
    19691973  private:
    … …  
    19781982  public:
    19791983    EvalNode(SourceElements*, DeclarationStacks::VarStack*, DeclarationStacks::FunctionStack*) KJS_FAST_CALL;
    1980     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1984    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19811985   
    19821986  private:
    … …  
    19881992    FunctionBodyNode(SourceElements*, DeclarationStacks::VarStack*, DeclarationStacks::FunctionStack*) KJS_FAST_CALL;
    19891993
    1990     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     1994    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    19911995
    19921996    SymbolTable& symbolTable() KJS_FAST_CALL { return m_symbolTable; }
    … …  
    20262030    FuncDeclNode(const Identifier& i, ParameterNode* p, FunctionBodyNode* b) KJS_FAST_CALL
    20272031      : ident(i), param(p), body(b) { addParams(); }
    2028     virtual Completion execute(ExecState*) KJS_FAST_CALL;
     2032    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    20292033    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    20302034    ALWAYS_INLINE FunctionImp* makeFunction(ExecState*) KJS_FAST_CALL;
    … …  
    20462050
    20472051      JSValue* evaluate(ExecState*) KJS_FAST_CALL;
    2048       Completion evalStatements(ExecState*) KJS_FAST_CALL;
     2052      JSValue* executeStatements(ExecState*) KJS_FAST_CALL;
    20492053
    20502054  private:
    … …  
    20742078      CaseBlockNode(ClauseListNode* l1, CaseClauseNode* d, ClauseListNode* l2) KJS_FAST_CALL;
    20752079      virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    2076       Completion evalBlock(ExecState *exec, JSValue *input) KJS_FAST_CALL;
     2080      JSValue* executeBlock(ExecState*, JSValue *input) KJS_FAST_CALL;
    20772081      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    20782082      virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
    … …  
    20872091      SwitchNode(ExpressionNode* e, CaseBlockNode *b) KJS_FAST_CALL : expr(e), block(b) { }
    20882092      virtual void optimizeVariableAccess(SymbolTable&, DeclarationStacks::NodeStack&) KJS_FAST_CALL;
    2089       virtual Completion execute(ExecState*) KJS_FAST_CALL;
     2093      virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
    20902094      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
    20912095  private:

  • trunk/JavaScriptCore/kjs/number_object.h

    r28899 r28907  
    8989    enum { NaNValue, NegInfinity, PosInfinity, MaxValue, MinValue };
    9090
    91     Completion execute(const List &);
    9291    JSObject *construct(const List &);
    9392  };
Note: See TracChangeset for help on using the changeset viewer.