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


Ignore:
Timestamp:
Dec 20, 2007, 9:42:50 AM (17 years ago)
Author:
Darin Adler
Message:

Reviewed by Eric.

SuSpider shows 2.4% speedup.

Stop using completions in the execution engine.
Instead, the completion type and label target are both
stored in the ExecState.

  • API/JSContextRef.cpp: Removed unneeded include of "completion.h".
  • bindings/runtime_method.cpp: Removed unused execute function.
  • bindings/runtime_method.h: Ditto.
  • kjs/ExecState.h: Added completionType, breakOrContinueTarget, setCompletionType, setNormalCompletion, setBreakCompletion, setContinueCompletion, setReturnValueCompletion, setThrowCompletion, setInterruptedCompletion, m_completionType, and m_breakOrContinueTarget.
  • kjs/completion.h: Removed constructor and getter for target for break and continue from Completion. This class is now only used for the public API to Interpreter and such.
  • kjs/date_object.h: Removed unused execute function.
  • kjs/function.cpp: (KJS::FunctionImp::callAsFunction): Removed some unneeded exception processing. Updated to call the new execute function and to get the completion type from the ExecState. Merged in the execute function, which repeated some of the same logic and was called only from here. (KJS::GlobalFuncImp::callAsFunction): More of the same for eval.
  • kjs/function.h: Removed execute.
  • kjs/interpreter.cpp: (KJS::Interpreter::evaluate): Added code to convert the result of execut into a Completion.
  • kjs/nodes.cpp: (KJS::Node::setErrorCompletion): Renamed from createErrorCompletion. Now sets the completion type in the ExecState. (KJS::Node::rethrowException): Now sets the completion type in the ExecState. (KJS::StatementNode::hitStatement): Now sets the completion type in the ExecState. (KJS::VarStatementNode::execute): Updated to put completion type in the ExecState instead of a Completion object. (KJS::statementListExecute): Ditto. Also changed the for loop to use indices instead of iterators. (KJS::BlockNode::execute): Updated return type. (KJS::EmptyStatementNode::execute): Updated to put completion type in the ExecState instead of a Completion object. (KJS::ExprStatementNode::execute): Ditto. (KJS::IfNode::execute): Ditto. (KJS::DoWhileNode::execute): Ditto. Also streamlined the logic a little to make the normal case a little faster and moved the end outside the loop so that "break" can do a break. (KJS::WhileNode::execute): Ditto. (KJS::ForNode::execute): Ditto. (KJS::ForInNode::execute): Ditto. (KJS::ContinueNode::execute): Updated to put completion type in the ExecState instead of a Completion object. (KJS::BreakNode::execute): Ditto. (KJS::ReturnNode::execute): Ditto. (KJS::WithNode::execute): Ditto. (KJS::CaseClauseNode::executeStatements): Ditto. Also renamed to have execute in its name to reflect the fact that it's a member of the same family of functions. (KJS::CaseBlockNode::executeBlock): Ditto. (KJS::SwitchNode::execute): Ditto. (KJS::LabelNode::execute): Ditto. (KJS::ThrowNode::execute): Ditto. (KJS::TryNode::execute): Ditto. (KJS::ProgramNode::execute): Ditto. (KJS::EvalNode::execute): Ditto. (KJS::FunctionBodyNode::execute): Ditto. (KJS::FuncDeclNode::execute): Ditto.
  • kjs/nodes.h: Renamed setErrorCompletion to createErrorCompletion, made hitStatement protected, changed return value of execute to a JSValue, renamed evalStatements to executeStatements, and evalBlock to executeBlock.
  • kjs/number_object.h: Removed unused execute function.
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/kjs/nodes.cpp

    r28886 r28887  
    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
Note: See TracChangeset for help on using the changeset viewer.