Changeset 29836 in webkit for trunk/JavaScriptCore

Timestamp:

Jan 28, 2008, 12:50:45 PM (17 years ago)

Author:

[email protected]

Message:

Rubber-stamped by Darin Adler.

• Fix whitespace in nodes.h/cpp and nodes2string.cpp.

(NOTE: Specific changed functions elided for space and clarity)

• kjs/nodes.cpp:
• kjs/nodes.h:
• kjs/nodes2string.cpp:

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• kjs/nodes.cpp (modified) (134 diffs)
• kjs/nodes.h (modified) (9 diffs)
• kjs/nodes2string.cpp (modified) (13 diffs)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2008-01-28  Sam Weinig  <[email protected]>
+
+        Rubber-stamped by Darin Adler.
+
+        - Fix whitespace in nodes.h/cpp and nodes2string.cpp.
+
+        (NOTE: Specific changed functions elided for space and clarity)
+        * kjs/nodes.cpp:
+        * kjs/nodes.h:
+        * kjs/nodes2string.cpp:
+
 2008-01-27  Sam Weinig  <[email protected]>
 

trunk/JavaScriptCore/kjs/nodes.cpp

@@ -1 +1 @@
 /*
- *  Copyright (C) 1999-2002 Harri Porten ([email protected])
- *  Copyright (C) 2001 Peter Kelly ([email protected])
- *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
- *  Copyright (C) 2007 Cameron Zwarich ([email protected])
- *  Copyright (C) 2007 Maks Orlovich
- *  Copyright (C) 2007 Eric Seidel <[email protected]>
- *
- *  This library is free software; you can redistribute it and/or
- *  modify it under the terms of the GNU Library General Public
- *  License as published by the Free Software Foundation; either
- *  version 2 of the License, or (at your option) any later version.
- *
- *  This library is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  Library General Public License for more details.
- *
- *  You should have received a copy of the GNU Library General Public License
- *  along with this library; see the file COPYING.LIB.  If not, write to
- *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- *  Boston, MA 02110-1301, USA.
- *
- */
+*  Copyright (C) 1999-2002 Harri Porten ([email protected])
+*  Copyright (C) 2001 Peter Kelly ([email protected])
+*  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
+*  Copyright (C) 2007 Cameron Zwarich ([email protected])
+*  Copyright (C) 2007 Maks Orlovich
+*  Copyright (C) 2007 Eric Seidel <[email protected]>
+*
+*  This library is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Library General Public
+*  License as published by the Free Software Foundation; either
+*  version 2 of the License, or (at your option) any later version.
+*
+*  This library is distributed in the hope that it will be useful,
+*  but WITHOUT ANY WARRANTY; without even the implied warranty of
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+*  Library General Public License for more details.
+*
+*  You should have received a copy of the GNU Library General Public License
+*  along with this library; see the file COPYING.LIB.  If not, write to
+*  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+*  Boston, MA 02110-1301, USA.
+*
+*/
 
 #include "config.h"
@@ -45 +45 @@
 namespace KJS {
 
-    class FunctionBodyNodeWithDebuggerHooks : public FunctionBodyNode {
-    public:
-        FunctionBodyNodeWithDebuggerHooks(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
-        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    };
+class FunctionBodyNodeWithDebuggerHooks : public FunctionBodyNode {
+public:
+    FunctionBodyNodeWithDebuggerHooks(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
+    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+};
 
 #define KJS_CHECKEXCEPTION \
-  if (exec->hadException()) \
+if (exec->hadException()) \
     return rethrowException(exec);
 
 #define KJS_CHECKEXCEPTIONVALUE \
-  if (exec->hadException()) { \
+if (exec->hadException()) { \
     handleException(exec); \
     return jsUndefined(); \
-  }
+}
 
 #define KJS_CHECKEXCEPTIONNUMBER \
-  if (exec->hadException()) { \
+if (exec->hadException()) { \
     handleException(exec); \
     return 0; \
-  }
+}
 
 #define KJS_CHECKEXCEPTIONBOOLEAN \
-  if (exec->hadException()) { \
+if (exec->hadException()) { \
     handleException(exec); \
     return false; \
-  }
+}
 
 #define KJS_CHECKEXCEPTIONVOID \
-  if (exec->hadException()) { \
+if (exec->hadException()) { \
     handleException(exec); \
     return; \
-  }
+}
 
 #if !ASSERT_DISABLED
 static inline bool canSkipLookup(ExecState* exec, const Identifier& ident)
 {
-    // Static lookup in EvalCode is impossible because variables aren't DontDelete. 
+    // Static lookup in EvalCode is impossible because variables aren't DontDelete.
     // Static lookup in GlobalCode may be possible, but we haven't implemented support for it yet.
     if (exec->codeType() != FunctionCode)
@@ -94 +94 @@
     if (!exec->variableObject()->symbolTable().contains(ident.ustring().rep()))
         return false;
-        
+
     return true;
 }
@@ -113 +113 @@
 static WTFLogChannel LogKJSNodeLeaks = { 0x00000000, "", WTFLogChannelOn };
 
-struct ParserRefCountedCounter { 
-    static unsigned count; 
-    ParserRefCountedCounter() 
-    { 
-        if (count) 
-            LOG(KJSNodeLeaks, "LEAK: %u KJS::Node\n", count); 
+struct ParserRefCountedCounter {
+    static unsigned count;
+    ParserRefCountedCounter()
+    {
+        if (count)
+            LOG(KJSNodeLeaks, "LEAK: %u KJS::Node\n", count);
     }
 };
@@ -133 +133 @@
     ++ParserRefCountedCounter::count;
 #endif
-  if (!newTrackedObjects)
-      newTrackedObjects = new HashSet<ParserRefCounted*>;
-  newTrackedObjects->add(this);
-  ASSERT(newTrackedObjects->contains(this));
+    if (!newTrackedObjects)
+        newTrackedObjects = new HashSet<ParserRefCounted*>;
+    newTrackedObjects->add(this);
+    ASSERT(newTrackedObjects->contains(this));
 }
 
@@ -156 +156 @@
             return;
         }
-    }   
+    }
 
     ASSERT(!newTrackedObjects || !newTrackedObjects->contains(this));
-    
+
     if (!trackedObjectExtraRefCounts)
         trackedObjectExtraRefCounts = new HashCountedSet<ParserRefCounted*>;
@@ -168 +168 @@
 {
     ASSERT(!newTrackedObjects || !newTrackedObjects->contains(this));
-    
+
     if (!trackedObjectExtraRefCounts) {
         delete this;
@@ -187 +187 @@
         return 0;
     }
- 
+
     ASSERT(!newTrackedObjects || !newTrackedObjects->contains(this));
 
@@ -251 +251 @@
 }
 
-static void substitute(UString &string, const UString &substring) KJS_FAST_CALL;
-static void substitute(UString &string, const UString &substring)
+static void substitute(UString& string, const UString& substring) KJS_FAST_CALL;
+static void substitute(UString& string, const UString& substring)
 {
     int position = string.find("%s");
@@ -286 +286 @@
 }
 
-JSValue *Node::throwError(ExecState* exec, ErrorType e, const char *msg)
+JSValue* Node::throwError(ExecState* exec, ErrorType e, const char* msg)
 {
     return KJS::throwError(exec, e, msg, lineNo(), currentSourceId(exec), currentSourceURL(exec));
 }
 
-JSValue *Node::throwError(ExecState* exec, ErrorType e, const char* msg, const char* string)
+JSValue* Node::throwError(ExecState* exec, ErrorType e, const char* msg, const char* string)
 {
     UString message = msg;
@@ -298 +298 @@
 }
 
-JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, Node *expr)
+JSValue* Node::throwError(ExecState* exec, ErrorType e, const char* msg, JSValue* v, Node* expr)
 {
     UString message = msg;
@@ -306 +306 @@
 }
 
-
-JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, const Identifier &label)
+JSValue* Node::throwError(ExecState* exec, ErrorType e, const char* msg, const Identifier& label)
 {
     UString message = msg;
@@ -314 +313 @@
 }
 
-JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, Node *e1, Node *e2)
+JSValue* Node::throwError(ExecState* exec, ErrorType e, const char* msg, JSValue* v, Node* e1, Node* e2)
 {
     UString message = msg;
@@ -323 +322 @@
 }
 
-JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, Node *expr, const Identifier &label)
+JSValue* Node::throwError(ExecState* exec, ErrorType e, const char* msg, JSValue* v, Node* expr, const Identifier& label)
 {
     UString message = msg;
@@ -332 +331 @@
 }
 
-JSValue *Node::throwError(ExecState *exec, ErrorType e, const char *msg, JSValue *v, const Identifier &label)
+JSValue* Node::throwError(ExecState* exec, ErrorType e, const char* msg, JSValue* v, const Identifier& label)
 {
     UString message = msg;
@@ -340 +339 @@
 }
 
-JSValue *Node::throwUndefinedVariableError(ExecState *exec, const Identifier &ident)
+JSValue* Node::throwUndefinedVariableError(ExecState* exec, const Identifier& ident)
 {
     return throwError(exec, ReferenceError, "Can't find variable: %s", ident);
@@ -377 +376 @@
 // ------------------------------ StatementNode --------------------------------
 
-StatementNode::StatementNode() 
+StatementNode::StatementNode()
     : m_lastLine(-1)
 {
@@ -430 +429 @@
 // ------------------------------ NullNode -------------------------------------
 
-JSValue *NullNode::evaluate(ExecState *)
-{
-  return jsNull();
+JSValue* NullNode::evaluate(ExecState* )
+{
+    return jsNull();
 }
 
@@ -456 +455 @@
     return jsNumberCell(m_double);
 }
-    
+
 double NumberNode::evaluateToNumber(ExecState*)
 {
@@ -502 +501 @@
 JSValue* StringNode::evaluate(ExecState*)
 {
-  return jsOwnedString(m_value);
+    return jsOwnedString(m_value);
 }
 
@@ -514 +513 @@
     return !m_value.isEmpty();
 }
-    
+
 // ------------------------------ RegExpNode -----------------------------------
 
@@ -525 +524 @@
 
 // ECMA 11.1.1
-JSValue *ThisNode::evaluate(ExecState *exec)
-{
-  return exec->thisValue();
+JSValue* ThisNode::evaluate(ExecState* exec)
+{
+    return exec->thisValue();
 }
 
@@ -535 +534 @@
 JSValue* ResolveNode::inlineEvaluate(ExecState* exec)
 {
-  // Check for missed optimization opportunity.
-  ASSERT(!canSkipLookup(exec, m_ident));
-
-  const ScopeChain& chain = exec->scopeChain();
-  ScopeChainIterator iter = chain.begin();
-  ScopeChainIterator end = chain.end();
-  
-  // we must always have something in the scope chain
-  ASSERT(iter != end);
-
-  PropertySlot slot;
-  do { 
-    JSObject *o = *iter;
-
-    if (o->getPropertySlot(exec, m_ident, slot))
-      return slot.getValue(exec, o, m_ident);
-    
-    ++iter;
-  } while (iter != end);
-
-  return throwUndefinedVariableError(exec, m_ident);
+    // Check for missed optimization opportunity.
+    ASSERT(!canSkipLookup(exec, m_ident));
+
+    const ScopeChain& chain = exec->scopeChain();
+    ScopeChainIterator iter = chain.begin();
+    ScopeChainIterator end = chain.end();
+
+    // we must always have something in the scope chain
+    ASSERT(iter != end);
+
+    PropertySlot slot;
+    do {
+        JSObject* o = *iter;
+
+        if (o->getPropertySlot(exec, m_ident, slot))
+            return slot.getValue(exec, o, m_ident);
+
+        ++iter;
+    } while (iter != end);
+
+    return throwUndefinedVariableError(exec, m_ident);
 }
 
@@ -640 +639 @@
 
 // ECMA 11.1.4
-JSValue *ElementNode::evaluate(ExecState *exec)
-{
-  JSObject* array = exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, exec->emptyList());
-  int length = 0;
-  for (ElementNode *n = this; n; n = n->m_next.get()) {
-    JSValue *val = n->m_node->evaluate(exec);
-    KJS_CHECKEXCEPTIONVALUE
-    length += n->m_elision;
-    array->put(exec, length++, val);
-  }
-  return array;
+JSValue* ElementNode::evaluate(ExecState* exec)
+{
+    JSObject* array = exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, exec->emptyList());
+    int length = 0;
+    for (ElementNode* n = this; n; n = n->m_next.get()) {
+        JSValue* val = n->m_node->evaluate(exec);
+        KJS_CHECKEXCEPTIONVALUE
+        length += n->m_elision;
+        array->put(exec, length++, val);
+    }
+    return array;
 }
 
@@ -661 +660 @@
 }
 
-
 // ECMA 11.1.4
-JSValue *ArrayNode::evaluate(ExecState *exec)
-{
-  JSObject *array;
-  int length;
-
-  if (m_element) {
-    array = static_cast<JSObject*>(m_element->evaluate(exec));
-    KJS_CHECKEXCEPTIONVALUE
-    length = m_opt ? array->get(exec, exec->propertyNames().length)->toInt32(exec) : 0;
-  } else {
-    JSValue* newArr = exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, exec->emptyList());
-    array = static_cast<JSObject*>(newArr);
-    length = 0;
-  }
-
-  if (m_opt)
-    array->put(exec, exec->propertyNames().length, jsNumber(m_elision + length), DontEnum | DontDelete);
-
-  return array;
+JSValue* ArrayNode::evaluate(ExecState* exec)
+{
+    JSObject* array;
+    int length;
+
+    if (m_element) {
+        array = static_cast<JSObject*>(m_element->evaluate(exec));
+        KJS_CHECKEXCEPTIONVALUE
+        length = m_optional ? array->get(exec, exec->propertyNames().length)->toInt32(exec) : 0;
+    } else {
+        JSValue* newArr = exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, exec->emptyList());
+        array = static_cast<JSObject*>(newArr);
+        length = 0;
+    }
+
+    if (m_optional)
+        array->put(exec, exec->propertyNames().length, jsNumber(m_elision + length), DontEnum | DontDelete);
+
+    return array;
 }
 
@@ -693 +691 @@
 
 // ECMA 11.1.5
-JSValue *ObjectLiteralNode::evaluate(ExecState *exec)
-{
-  if (m_list)
-    return m_list->evaluate(exec);
-
-  return exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
+JSValue* ObjectLiteralNode::evaluate(ExecState* exec)
+{
+    if (m_list)
+        return m_list->evaluate(exec);
+
+    return exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
 }
 
@@ -711 +709 @@
 
 // ECMA 11.1.5
-JSValue *PropertyListNode::evaluate(ExecState *exec)
-{
-  JSObject* obj = exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
-  
-  for (PropertyListNode *p = this; p; p = p->m_next.get()) {
-    JSValue *v = p->m_node->m_assign->evaluate(exec);
-    KJS_CHECKEXCEPTIONVALUE
-    
-    switch (p->m_node->m_type) {
-      case PropertyNode::Getter:
-        ASSERT(v->isObject());
-        obj->defineGetter(exec, p->m_node->name(), static_cast<JSObject *>(v));
-        break;
-      case PropertyNode::Setter:
-        ASSERT(v->isObject());
-        obj->defineSetter(exec, p->m_node->name(), static_cast<JSObject *>(v));
-        break;
-      case PropertyNode::Constant:
-        obj->put(exec, p->m_node->name(), v);
-        break;
-    }
-  }
-
-  return obj;
+JSValue* PropertyListNode::evaluate(ExecState* exec)
+{
+    JSObject* obj = exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
+
+    for (PropertyListNode* p = this; p; p = p->m_next.get()) {
+        JSValue* v = p->m_node->m_assign->evaluate(exec);
+        KJS_CHECKEXCEPTIONVALUE
+
+        switch (p->m_node->m_type) {
+            case PropertyNode::Getter:
+                ASSERT(v->isObject());
+                obj->defineGetter(exec, p->m_node->name(), static_cast<JSObject* >(v));
+                break;
+            case PropertyNode::Setter:
+                ASSERT(v->isObject());
+                obj->defineSetter(exec, p->m_node->name(), static_cast<JSObject* >(v));
+                break;
+            case PropertyNode::Constant:
+                obj->put(exec, p->m_node->name(), v);
+                break;
+        }
+    }
+
+    return obj;
 }
 
@@ -745 +743 @@
 
 // ECMA 11.1.5
-JSValue *PropertyNode::evaluate(ExecState*)
-{
-  ASSERT(false);
-  return jsNull();
+JSValue* PropertyNode::evaluate(ExecState*)
+{
+    ASSERT(false);
+    return jsNull();
 }
 
@@ -762 +760 @@
 JSValue* BracketAccessorNode::inlineEvaluate(ExecState* exec)
 {
-  JSValue* v1 = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSValue* v2 = m_subscript->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSObject* o = v1->toObject(exec);
-  uint32_t i;
-  if (v2->getUInt32(i))
-    return o->get(exec, i);
-  return o->get(exec, Identifier(v2->toString(exec)));
+    JSValue* v1 = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSValue* v2 = m_subscript->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSObject* o = v1->toObject(exec);
+    uint32_t i;
+    if (v2->getUInt32(i))
+        return o->get(exec, i);
+    return o->get(exec, Identifier(v2->toString(exec)));
 }
 
@@ -804 +802 @@
     KJS_CHECKEXCEPTIONNUMBER
     return v->toUInt32(exec);
-}    
+}
 
 // ------------------------------ DotAccessorNode --------------------------------
@@ -852 +850 @@
     KJS_CHECKEXCEPTIONNUMBER
     return v->toUInt32(exec);
-}    
+}
 
 // ------------------------------ ArgumentListNode -----------------------------
@@ -867 +865 @@
 void ArgumentListNode::evaluateList(ExecState* exec, List& list)
 {
-  for (ArgumentListNode *n = this; n; n = n->m_next.get()) {
-    JSValue *v = n->m_expr->evaluate(exec);
-    KJS_CHECKEXCEPTIONVOID
-    list.append(v);
-  }
+    for (ArgumentListNode* n = this; n; n = n->m_next.get()) {
+        JSValue* v = n->m_expr->evaluate(exec);
+        KJS_CHECKEXCEPTIONVOID
+        list.append(v);
+    }
 }
 
@@ -895 +893 @@
 JSValue* NewExprNode::inlineEvaluate(ExecState* exec)
 {
-  JSValue* v = m_expr->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  List argList;
-  if (m_args) {
-    m_args->evaluateList(exec, argList);
-    KJS_CHECKEXCEPTIONVALUE
-  }
-
-  if (!v->isObject())
-    return throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with new.", v, m_expr.get());
-
-  JSObject *constr = static_cast<JSObject*>(v);
-  if (!constr->implementsConstruct())
-    return throwError(exec, TypeError, "Value %s (result of expression %s) is not a constructor. Cannot be used with new.", v, m_expr.get());
-
-  return constr->construct(exec, argList);
+    JSValue* v = m_expr->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    List argList;
+    if (m_args) {
+        m_args->evaluateList(exec, argList);
+        KJS_CHECKEXCEPTIONVALUE
+    }
+
+    if (!v->isObject())
+        return throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with new.", v, m_expr.get());
+
+    JSObject* constr = static_cast<JSObject*>(v);
+    if (!constr->implementsConstruct())
+        return throwError(exec, TypeError, "Value %s (result of expression %s) is not a constructor. Cannot be used with new.", v, m_expr.get());
+
+    return constr->construct(exec, argList);
 }
 
@@ -945 +943 @@
     KJS_CHECKEXCEPTIONNUMBER
     return v->toUInt32(exec);
-}    
+}
 
 void FunctionCallValueNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
@@ -954 +952 @@
 
 // ECMA 11.2.3
-JSValue *FunctionCallValueNode::evaluate(ExecState *exec)
-{
-  JSValue *v = m_expr->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  if (!v->isObject()) {
-    return throwError(exec, TypeError, "Value %s (result of expression %s) is not object.", v, m_expr.get());
-  }
-  
-  JSObject *func = static_cast<JSObject*>(v);
-
-  if (!func->implementsCall()) {
-    return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, m_expr.get());
-  }
-
-  List argList;
-  m_args->evaluateList(exec, argList);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *thisObj =  exec->dynamicGlobalObject();
-
-  return func->call(exec, thisObj, argList);
+JSValue* FunctionCallValueNode::evaluate(ExecState* exec)
+{
+    JSValue* v = m_expr->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    if (!v->isObject()) {
+        return throwError(exec, TypeError, "Value %s (result of expression %s) is not object.", v, m_expr.get());
+    }
+
+    JSObject* func = static_cast<JSObject*>(v);
+
+    if (!func->implementsCall()) {
+        return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, m_expr.get());
+    }
+
+    List argList;
+    m_args->evaluateList(exec, argList);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* thisObj =  exec->dynamicGlobalObject();
+
+    return func->call(exec, thisObj, argList);
 }
 
@@ -990 +988 @@
 JSValue* FunctionCallResolveNode::inlineEvaluate(ExecState* exec)
 {
-  // Check for missed optimization opportunity.
-  ASSERT(!canSkipLookup(exec, m_ident));
-
-  const ScopeChain& chain = exec->scopeChain();
-  ScopeChainIterator iter = chain.begin();
-  ScopeChainIterator end = chain.end();
-  
-  // we must always have something in the scope chain
-  ASSERT(iter != end);
-
-  PropertySlot slot;
-  JSObject* base;
-  do { 
-    base = *iter;
-    if (base->getPropertySlot(exec, m_ident, slot)) {
-      JSValue* v = slot.getValue(exec, base, m_ident);
-      KJS_CHECKEXCEPTIONVALUE
-        
-      if (!v->isObject())
-        return throwError(exec, TypeError, "Value %s (result of expression %s) is not object.", v, m_ident);
-      
-      JSObject *func = static_cast<JSObject*>(v);
-      
-      if (!func->implementsCall())
-        return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, m_ident);
-      
-      List argList;
-      m_args->evaluateList(exec, argList);
-      KJS_CHECKEXCEPTIONVALUE
-        
-      JSObject* thisObj = base;
-      // ECMA 11.2.3 says that in this situation the this value should be null.
-      // However, section 10.2.3 says that in the case where the value provided
-      // by the caller is null, the global object should be used. It also says
-      // that the section does not apply to internal functions, but for simplicity
-      // of implementation we use the global object anyway here. This guarantees
-      // that in host objects you always get a valid object for this.
-      if (thisObj->isActivationObject())
-        thisObj = exec->dynamicGlobalObject();
-
-      return func->call(exec, thisObj, argList);
-    }
-    ++iter;
-  } while (iter != end);
-  
-  return throwUndefinedVariableError(exec, m_ident);
+    // Check for missed optimization opportunity.
+    ASSERT(!canSkipLookup(exec, m_ident));
+
+    const ScopeChain& chain = exec->scopeChain();
+    ScopeChainIterator iter = chain.begin();
+    ScopeChainIterator end = chain.end();
+
+    // we must always have something in the scope chain
+    ASSERT(iter != end);
+
+    PropertySlot slot;
+    JSObject* base;
+    do {
+        base = *iter;
+        if (base->getPropertySlot(exec, m_ident, slot)) {
+            JSValue* v = slot.getValue(exec, base, m_ident);
+            KJS_CHECKEXCEPTIONVALUE
+
+            if (!v->isObject())
+                return throwError(exec, TypeError, "Value %s (result of expression %s) is not object.", v, m_ident);
+
+            JSObject* func = static_cast<JSObject*>(v);
+
+            if (!func->implementsCall())
+                return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, m_ident);
+
+            List argList;
+            m_args->evaluateList(exec, argList);
+            KJS_CHECKEXCEPTIONVALUE
+
+            JSObject* thisObj = base;
+            // ECMA 11.2.3 says that in this situation the this value should be null.
+            // However, section 10.2.3 says that in the case where the value provided
+            // by the caller is null, the global object should be used. It also says
+            // that the section does not apply to internal functions, but for simplicity
+            // of implementation we use the global object anyway here. This guarantees
+            // that in host objects you always get a valid object for this.
+            if (thisObj->isActivationObject())
+                thisObj = exec->dynamicGlobalObject();
+
+            return func->call(exec, thisObj, argList);
+        }
+        ++iter;
+    } while (iter != end);
+
+    return throwUndefinedVariableError(exec, m_ident);
 }
 
@@ -1079 +1077 @@
     if (!v->isObject())
         return throwError(exec, TypeError, "Value %s (result of expression %s) is not object.", v, m_ident);
-      
+
     JSObject* func = static_cast<JSObject*>(v);
     if (!func->implementsCall())
         return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, m_ident);
-      
+
     List argList;
     m_args->evaluateList(exec, argList);
@@ -1132 +1130 @@
 
 // ECMA 11.2.3
-JSValue *FunctionCallBracketNode::evaluate(ExecState *exec)
-{
-  JSValue *baseVal = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSValue *subscriptVal = m_subscript->evaluate(exec);
-
-  JSObject *baseObj = baseVal->toObject(exec);
-  uint32_t i;
-  PropertySlot slot;
-
-  JSValue *funcVal;
-  if (subscriptVal->getUInt32(i)) {
-    if (baseObj->getPropertySlot(exec, i, slot))
-      funcVal = slot.getValue(exec, baseObj, i);
-    else
-      funcVal = jsUndefined();
-  } else {
-    Identifier ident(subscriptVal->toString(exec));
-    if (baseObj->getPropertySlot(exec, ident, slot))
-      funcVal = baseObj->get(exec, ident);
-    else
-      funcVal = jsUndefined();
-  }
-
-  KJS_CHECKEXCEPTIONVALUE
-  
-  if (!funcVal->isObject()) {
-    return throwError(exec, TypeError, "Value %s (result of expression %s[%s]) is not object.", funcVal, m_base.get(), m_subscript.get());
-  }
-  
-  JSObject *func = static_cast<JSObject*>(funcVal);
-
-  if (!func->implementsCall()) {
-    return throwError(exec, TypeError, "Object %s (result of expression %s[%s]) does not allow calls.", funcVal, m_base.get(), m_subscript.get());
-  }
-
-  List argList;
-  m_args->evaluateList(exec, argList);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *thisObj = baseObj;
-  ASSERT(thisObj);
-  ASSERT(thisObj->isObject());
-  ASSERT(!thisObj->isActivationObject());
-
-  return func->call(exec, thisObj, argList);
-}
-
-static const char *dotExprNotAnObjectString() KJS_FAST_CALL;
-static const char *dotExprNotAnObjectString()
-{
-  return "Value %s (result of expression %s.%s) is not object.";
-}
-
-static const char *dotExprDoesNotAllowCallsString() KJS_FAST_CALL;
-static const char *dotExprDoesNotAllowCallsString()
-{
-  return "Object %s (result of expression %s.%s) does not allow calls.";
+JSValue* FunctionCallBracketNode::evaluate(ExecState* exec)
+{
+    JSValue* baseVal = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSValue* subscriptVal = m_subscript->evaluate(exec);
+
+    JSObject* baseObj = baseVal->toObject(exec);
+    uint32_t i;
+    PropertySlot slot;
+
+    JSValue* funcVal;
+    if (subscriptVal->getUInt32(i)) {
+        if (baseObj->getPropertySlot(exec, i, slot))
+            funcVal = slot.getValue(exec, baseObj, i);
+        else
+            funcVal = jsUndefined();
+    } else {
+        Identifier ident(subscriptVal->toString(exec));
+        if (baseObj->getPropertySlot(exec, ident, slot))
+            funcVal = baseObj->get(exec, ident);
+        else
+            funcVal = jsUndefined();
+    }
+
+    KJS_CHECKEXCEPTIONVALUE
+
+    if (!funcVal->isObject())
+        return throwError(exec, TypeError, "Value %s (result of expression %s[%s]) is not object.", funcVal, m_base.get(), m_subscript.get());
+
+    JSObject* func = static_cast<JSObject*>(funcVal);
+
+    if (!func->implementsCall())
+        return throwError(exec, TypeError, "Object %s (result of expression %s[%s]) does not allow calls.", funcVal, m_base.get(), m_subscript.get());
+
+    List argList;
+    m_args->evaluateList(exec, argList);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* thisObj = baseObj;
+    ASSERT(thisObj);
+    ASSERT(thisObj->isObject());
+    ASSERT(!thisObj->isActivationObject());
+
+    return func->call(exec, thisObj, argList);
+}
+
+static const char* dotExprNotAnObjectString() KJS_FAST_CALL;
+static const char* dotExprNotAnObjectString()
+{
+    return "Value %s (result of expression %s.%s) is not object.";
+}
+
+static const char* dotExprDoesNotAllowCallsString() KJS_FAST_CALL;
+static const char* dotExprDoesNotAllowCallsString()
+{
+    return "Object %s (result of expression %s.%s) does not allow calls.";
 }
 
@@ -1202 +1198 @@
 JSValue* FunctionCallDotNode::inlineEvaluate(ExecState* exec)
 {
-  JSValue *baseVal = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *baseObj = baseVal->toObject(exec);
-  PropertySlot slot;
-  JSValue *funcVal = baseObj->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, baseObj, m_ident) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-
-  if (!funcVal->isObject())
-    return throwError(exec, TypeError, dotExprNotAnObjectString(), funcVal, m_base.get(), m_ident);
-  
-  JSObject *func = static_cast<JSObject*>(funcVal);
-
-  if (!func->implementsCall())
-    return throwError(exec, TypeError, dotExprDoesNotAllowCallsString(), funcVal, m_base.get(), m_ident);
-
-  List argList;
-  m_args->evaluateList(exec, argList);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *thisObj = baseObj;
-  ASSERT(thisObj);
-  ASSERT(thisObj->isObject());
-  ASSERT(!thisObj->isActivationObject());
-
-  return func->call(exec, thisObj, argList);
+    JSValue* baseVal = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* baseObj = baseVal->toObject(exec);
+    PropertySlot slot;
+    JSValue* funcVal = baseObj->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, baseObj, m_ident) : jsUndefined();
+    KJS_CHECKEXCEPTIONVALUE
+
+    if (!funcVal->isObject())
+        return throwError(exec, TypeError, dotExprNotAnObjectString(), funcVal, m_base.get(), m_ident);
+
+    JSObject* func = static_cast<JSObject*>(funcVal);
+
+    if (!func->implementsCall())
+        return throwError(exec, TypeError, dotExprDoesNotAllowCallsString(), funcVal, m_base.get(), m_ident);
+
+    List argList;
+    m_args->evaluateList(exec, argList);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* thisObj = baseObj;
+    ASSERT(thisObj);
+    ASSERT(thisObj->isObject());
+    ASSERT(!thisObj->isActivationObject());
+
+    return func->call(exec, thisObj, argList);
 }
 
@@ -1279 +1275 @@
 }
 
-JSValue *PostIncResolveNode::evaluate(ExecState *exec)
-{
-  // Check for missed optimization opportunity.
-  ASSERT(!canSkipLookup(exec, m_ident));
-
-  const ScopeChain& chain = exec->scopeChain();
-  ScopeChainIterator iter = chain.begin();
-  ScopeChainIterator end = chain.end();
-  
-  // we must always have something in the scope chain
-  ASSERT(iter != end);
-
-  PropertySlot slot;
-  do { 
-    if ((*iter)->getPropertySlot(exec, m_ident, slot)) {
-        // See the comment in PostIncResolveNode::evaluate().
-        
-        JSObject* base = *iter;
-        JSValue* v = slot.getValue(exec, base, m_ident)->toJSNumber(exec);
-        base->put(exec, m_ident, jsNumber(v->toNumber(exec) + 1));
-        return v;
-    }
-
-    ++iter;
-  } while (iter != end);
-
-  return throwUndefinedVariableError(exec, m_ident);
+JSValue* PostIncResolveNode::evaluate(ExecState* exec)
+{
+    // Check for missed optimization opportunity.
+    ASSERT(!canSkipLookup(exec, m_ident));
+
+    const ScopeChain& chain = exec->scopeChain();
+    ScopeChainIterator iter = chain.begin();
+    ScopeChainIterator end = chain.end();
+
+    // we must always have something in the scope chain
+    ASSERT(iter != end);
+
+    PropertySlot slot;
+    do {
+        if ((*iter)->getPropertySlot(exec, m_ident, slot)) {
+            // See the comment in PostIncResolveNode::evaluate().
+
+            JSObject* base = *iter;
+            JSValue* v = slot.getValue(exec, base, m_ident)->toJSNumber(exec);
+            base->put(exec, m_ident, jsNumber(v->toNumber(exec) + 1));
+            return v;
+        }
+
+        ++iter;
+    } while (iter != end);
+
+    return throwUndefinedVariableError(exec, m_ident);
 }
 
@@ -1312 +1308 @@
     new (this) PreIncResolveNode(PlacementNewAdopt);
 }
-    
+
 JSValue* PostIncLocalVarNode::evaluate(ExecState* exec)
 {
@@ -1327 +1323 @@
     new (this) PreIncLocalVarNode(m_index);
 }
-
 
 // Decrement
@@ -1341 +1336 @@
 }
 
-JSValue *PostDecResolveNode::evaluate(ExecState *exec)
-{
-  // Check for missed optimization opportunity.
-  ASSERT(!canSkipLookup(exec, m_ident));
-
-  const ScopeChain& chain = exec->scopeChain();
-  ScopeChainIterator iter = chain.begin();
-  ScopeChainIterator end = chain.end();
-  
-  // we must always have something in the scope chain
-  ASSERT(iter != end);
-
-  PropertySlot slot;
-  do { 
-    if ((*iter)->getPropertySlot(exec, m_ident, slot)) {
-        // See the comment in PostIncResolveNode::evaluate().
-        
-        JSObject* base = *iter;
-        JSValue* v = slot.getValue(exec, base, m_ident)->toJSNumber(exec);
-        base->put(exec, m_ident, jsNumber(v->toNumber(exec) - 1));
-        return v;
-    }
-
-    ++iter;
-  } while (iter != end);
-
-  return throwUndefinedVariableError(exec, m_ident);
-}
-    
+JSValue* PostDecResolveNode::evaluate(ExecState* exec)
+{
+    // Check for missed optimization opportunity.
+    ASSERT(!canSkipLookup(exec, m_ident));
+
+    const ScopeChain& chain = exec->scopeChain();
+    ScopeChainIterator iter = chain.begin();
+    ScopeChainIterator end = chain.end();
+
+    // we must always have something in the scope chain
+    ASSERT(iter != end);
+
+    PropertySlot slot;
+    do {
+        if ((*iter)->getPropertySlot(exec, m_ident, slot)) {
+            // See the comment in PostIncResolveNode::evaluate().
+
+            JSObject* base = *iter;
+            JSValue* v = slot.getValue(exec, base, m_ident)->toJSNumber(exec);
+            base->put(exec, m_ident, jsNumber(v->toNumber(exec) - 1));
+            return v;
+        }
+
+        ++iter;
+    } while (iter != end);
+
+    return throwUndefinedVariableError(exec, m_ident);
+}
+
 void PostDecResolveNode::optimizeForUnnecessaryResult()
 {
     new (this) PreDecResolveNode(PlacementNewAdopt);
 }
-    
+
 JSValue* PostDecLocalVarNode::evaluate(ExecState* exec)
 {
@@ -1388 +1383 @@
 {
     ASSERT(exec->variableObject() == exec->scopeChain().top());
-    
+
     JSValue** slot = &exec->localStorage()[m_index].value;
     double n = (*slot)->toNumber(exec);
@@ -1419 +1414 @@
     new (this) PreDecLocalVarNode(m_index);
 }
-    
+
 // ------------------------------ PostfixBracketNode ----------------------------------
 
@@ -1428 +1423 @@
 }
 
-JSValue *PostIncBracketNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSValue *subscript = m_subscript->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *base = baseValue->toObject(exec);
-
-  uint32_t propertyIndex;
-  if (subscript->getUInt32(propertyIndex)) {
+JSValue* PostIncBracketNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSValue* subscript = m_subscript->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* base = baseValue->toObject(exec);
+
+    uint32_t propertyIndex;
+    if (subscript->getUInt32(propertyIndex)) {
+        PropertySlot slot;
+        JSValue* v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
+        KJS_CHECKEXCEPTIONVALUE
+
+        JSValue* v2 = v->toJSNumber(exec);
+        base->put(exec, propertyIndex, jsNumber(v2->toNumber(exec) + 1));
+
+        return v2;
+    }
+
+    Identifier propertyName(subscript->toString(exec));
     PropertySlot slot;
-    JSValue *v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
+    JSValue* v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
     KJS_CHECKEXCEPTIONVALUE
 
     JSValue* v2 = v->toJSNumber(exec);
-    base->put(exec, propertyIndex, jsNumber(v2->toNumber(exec) + 1));
-        
+    base->put(exec, propertyName, jsNumber(v2->toNumber(exec) + 1));
     return v2;
-  }
-
-  Identifier propertyName(subscript->toString(exec));
-  PropertySlot slot;
-  JSValue *v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSValue* v2 = v->toJSNumber(exec);
-  base->put(exec, propertyName, jsNumber(v2->toNumber(exec) + 1));
-  return v2;
-}
-
-JSValue *PostDecBracketNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSValue *subscript = m_subscript->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *base = baseValue->toObject(exec);
-
-  uint32_t propertyIndex;
-  if (subscript->getUInt32(propertyIndex)) {
+}
+
+JSValue* PostDecBracketNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSValue* subscript = m_subscript->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* base = baseValue->toObject(exec);
+
+    uint32_t propertyIndex;
+    if (subscript->getUInt32(propertyIndex)) {
+        PropertySlot slot;
+        JSValue* v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
+        KJS_CHECKEXCEPTIONVALUE
+
+        JSValue* v2 = v->toJSNumber(exec);
+        base->put(exec, propertyIndex, jsNumber(v2->toNumber(exec) - 1));
+        return v2;
+    }
+
+    Identifier propertyName(subscript->toString(exec));
     PropertySlot slot;
-    JSValue *v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
+    JSValue* v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
     KJS_CHECKEXCEPTIONVALUE
 
     JSValue* v2 = v->toJSNumber(exec);
-    base->put(exec, propertyIndex, jsNumber(v2->toNumber(exec) - 1));
+    base->put(exec, propertyName, jsNumber(v2->toNumber(exec) - 1));
     return v2;
-  }
-
-  Identifier propertyName(subscript->toString(exec));
-  PropertySlot slot;
-  JSValue *v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSValue* v2 = v->toJSNumber(exec);
-  base->put(exec, propertyName, jsNumber(v2->toNumber(exec) - 1));
-  return v2;
 }
 
@@ -1496 +1491 @@
 }
 
-JSValue *PostIncDotNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSObject *base = baseValue->toObject(exec);
-
-  PropertySlot slot;
-  JSValue *v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSValue* v2 = v->toJSNumber(exec);
-  base->put(exec, m_ident, jsNumber(v2->toNumber(exec) + 1));
-  return v2;
-}
-
-JSValue *PostDecDotNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSObject *base = baseValue->toObject(exec);
-
-  PropertySlot slot;
-  JSValue *v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSValue* v2 = v->toJSNumber(exec);
-  base->put(exec, m_ident, jsNumber(v2->toNumber(exec) - 1));
-  return v2;
+JSValue* PostIncDotNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSObject* base = baseValue->toObject(exec);
+
+    PropertySlot slot;
+    JSValue* v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSValue* v2 = v->toJSNumber(exec);
+    base->put(exec, m_ident, jsNumber(v2->toNumber(exec) + 1));
+    return v2;
+}
+
+JSValue* PostDecDotNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSObject* base = baseValue->toObject(exec);
+
+    PropertySlot slot;
+    JSValue* v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSValue* v2 = v->toJSNumber(exec);
+    base->put(exec, m_ident, jsNumber(v2->toNumber(exec) - 1));
+    return v2;
 }
 
@@ -1531 +1526 @@
 {
     throwError(exec, ReferenceError, "Postfix %s operator applied to value that is not a reference.",
-        m_oper == OpPlusPlus ? "++" : "--");
+               m_operator == OpPlusPlus ? "++" : "--");
     handleException(exec);
     return jsUndefined();
@@ -1547 +1542 @@
 // ECMA 11.4.1
 
-JSValue *DeleteResolveNode::evaluate(ExecState *exec)
-{
-  // Check for missed optimization opportunity.
-  ASSERT(!canSkipLookup(exec, m_ident));
-
-  const ScopeChain& chain = exec->scopeChain();
-  ScopeChainIterator iter = chain.begin();
-  ScopeChainIterator end = chain.end();
-  
-  // we must always have something in the scope chain
-  ASSERT(iter != end);
-
-  PropertySlot slot;
-  JSObject *base;
-  do { 
-    base = *iter;
-    if (base->getPropertySlot(exec, m_ident, slot)) {
-        return jsBoolean(base->deleteProperty(exec, m_ident));
-    }
-
-    ++iter;
-  } while (iter != end);
-
-  return jsBoolean(true);
+JSValue* DeleteResolveNode::evaluate(ExecState* exec)
+{
+    // Check for missed optimization opportunity.
+    ASSERT(!canSkipLookup(exec, m_ident));
+
+    const ScopeChain& chain = exec->scopeChain();
+    ScopeChainIterator iter = chain.begin();
+    ScopeChainIterator end = chain.end();
+
+    // We must always have something in the scope chain
+    ASSERT(iter != end);
+
+    PropertySlot slot;
+    JSObject* base;
+    do {
+        base = *iter;
+        if (base->getPropertySlot(exec, m_ident, slot))
+            return jsBoolean(base->deleteProperty(exec, m_ident));
+
+        ++iter;
+    } while (iter != end);
+
+    return jsBoolean(true);
 }
 
@@ -1586 +1580 @@
 }
 
-JSValue *DeleteBracketNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSValue *subscript = m_subscript->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *base = baseValue->toObject(exec);
-
-  uint32_t propertyIndex;
-  if (subscript->getUInt32(propertyIndex))
-      return jsBoolean(base->deleteProperty(exec, propertyIndex));
-
-  Identifier propertyName(subscript->toString(exec));
-  return jsBoolean(base->deleteProperty(exec, propertyName));
+JSValue* DeleteBracketNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSValue* subscript = m_subscript->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* base = baseValue->toObject(exec);
+
+    uint32_t propertyIndex;
+    if (subscript->getUInt32(propertyIndex))
+        return jsBoolean(base->deleteProperty(exec, propertyIndex));
+
+    Identifier propertyName(subscript->toString(exec));
+    return jsBoolean(base->deleteProperty(exec, propertyName));
 }
 
@@ -1610 +1604 @@
 }
 
-JSValue *DeleteDotNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  JSObject *base = baseValue->toObject(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  return jsBoolean(base->deleteProperty(exec, m_ident));
+JSValue* DeleteDotNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    JSObject* base = baseValue->toObject(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    return jsBoolean(base->deleteProperty(exec, m_ident));
 }
 
@@ -1626 +1620 @@
 }
 
-JSValue *DeleteValueNode::evaluate(ExecState *exec)
-{
-  m_expr->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  // delete on a non-location expression ignores the value and returns true
-  return jsBoolean(true);
+JSValue* DeleteValueNode::evaluate(ExecState* exec)
+{
+    m_expr->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    // delete on a non-location expression ignores the value and returns true
+    return jsBoolean(true);
 }
 
@@ -1643 +1637 @@
 
 // ECMA 11.4.2
-JSValue *VoidNode::evaluate(ExecState *exec)
-{
-  m_expr->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  return jsUndefined();
+JSValue* VoidNode::evaluate(ExecState* exec)
+{
+    m_expr->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    return jsUndefined();
 }
 
@@ -1660 +1654 @@
 }
 
-static JSValue *typeStringForValue(JSValue *v) KJS_FAST_CALL;
-static JSValue *typeStringForValue(JSValue *v)
+static JSValue* typeStringForValue(JSValue* v) KJS_FAST_CALL;
+static JSValue* typeStringForValue(JSValue* v)
 {
     switch (v->type()) {
-    case UndefinedType:
-        return jsString("undefined");
-    case NullType:
-        return jsString("object");
-    case BooleanType:
-        return jsString("boolean");
-    case NumberType:
-        return jsString("number");
-    case StringType:
-        return jsString("string");
-    default:
-        if (v->isObject()) {
-            // Return "undefined" for objects that should be treated
-            // as null when doing comparisons.
-            if (static_cast<JSObject*>(v)->masqueradeAsUndefined())
-                return jsString("undefined");
-            else if (static_cast<JSObject*>(v)->implementsCall())
-                return jsString("function");
-        }
-        
-        return jsString("object");
+        case UndefinedType:
+            return jsString("undefined");
+        case NullType:
+            return jsString("object");
+        case BooleanType:
+            return jsString("boolean");
+        case NumberType:
+            return jsString("number");
+        case StringType:
+            return jsString("string");
+        default:
+            if (v->isObject()) {
+                // Return "undefined" for objects that should be treated
+                // as null when doing comparisons.
+                if (static_cast<JSObject*>(v)->masqueradeAsUndefined())
+                    return jsString("undefined");
+                else if (static_cast<JSObject*>(v)->implementsCall())
+                    return jsString("function");
+            }
+
+            return jsString("object");
     }
 }
@@ -1702 +1696 @@
 }
 
-JSValue *TypeOfResolveNode::evaluate(ExecState *exec)
-{
-  const ScopeChain& chain = exec->scopeChain();
-  ScopeChainIterator iter = chain.begin();
-  ScopeChainIterator end = chain.end();
-  
-  // we must always have something in the scope chain
-  ASSERT(iter != end);
-
-  PropertySlot slot;
-  JSObject *base;
-  do { 
-    base = *iter;
-    if (base->getPropertySlot(exec, m_ident, slot)) {
-        JSValue *v = slot.getValue(exec, base, m_ident);
-        return typeStringForValue(v);
-    }
-
-    ++iter;
-  } while (iter != end);
-
-  return jsString("undefined");
+JSValue* TypeOfResolveNode::evaluate(ExecState* exec)
+{
+    const ScopeChain& chain = exec->scopeChain();
+    ScopeChainIterator iter = chain.begin();
+    ScopeChainIterator end = chain.end();
+
+    // We must always have something in the scope chain
+    ASSERT(iter != end);
+
+    PropertySlot slot;
+    JSObject* base;
+    do {
+        base = *iter;
+        if (base->getPropertySlot(exec, m_ident, slot)) {
+            JSValue* v = slot.getValue(exec, base, m_ident);
+            return typeStringForValue(v);
+        }
+
+        ++iter;
+    } while (iter != end);
+
+    return jsString("undefined");
 }
 
 // ------------------------------ TypeOfValueNode -----------------------------------
 
-JSValue *TypeOfValueNode::evaluate(ExecState *exec)
-{
-  JSValue *v = m_expr->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  return typeStringForValue(v);
+JSValue* TypeOfValueNode::evaluate(ExecState* exec)
+{
+    JSValue* v = m_expr->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    return typeStringForValue(v);
 }
 
@@ -1762 +1756 @@
 }
 
-JSValue *PreIncResolveNode::evaluate(ExecState *exec)
-{
-  const ScopeChain& chain = exec->scopeChain();
-  ScopeChainIterator iter = chain.begin();
-  ScopeChainIterator end = chain.end();
-  
-  // we must always have something in the scope chain
-  ASSERT(iter != end);
-
-  PropertySlot slot;
-  do { 
-    if ((*iter)->getPropertySlot(exec, m_ident, slot)) {
-        // See the comment in PostIncResolveNode::evaluate().
-        
-        JSObject* base = *iter;
-        JSValue *v = slot.getValue(exec, base, m_ident);
-
-        double n = v->toNumber(exec);
-        JSValue *n2 = jsNumber(n + 1);
-        base->put(exec, m_ident, n2);
-
-        return n2;
-    }
-
-    ++iter;
-  } while (iter != end);
-
-  return throwUndefinedVariableError(exec, m_ident);
+JSValue* PreIncResolveNode::evaluate(ExecState* exec)
+{
+    const ScopeChain& chain = exec->scopeChain();
+    ScopeChainIterator iter = chain.begin();
+    ScopeChainIterator end = chain.end();
+
+    // we must always have something in the scope chain
+    ASSERT(iter != end);
+
+    PropertySlot slot;
+    do {
+        if ((*iter)->getPropertySlot(exec, m_ident, slot)) {
+            // See the comment in PostIncResolveNode::evaluate().
+
+            JSObject* base = *iter;
+            JSValue* v = slot.getValue(exec, base, m_ident);
+
+            double n = v->toNumber(exec);
+            JSValue* n2 = jsNumber(n + 1);
+            base->put(exec, m_ident, n2);
+
+            return n2;
+        }
+
+        ++iter;
+    } while (iter != end);
+
+    return throwUndefinedVariableError(exec, m_ident);
 }
 
@@ -1814 +1808 @@
 }
 
-JSValue *PreDecResolveNode::evaluate(ExecState *exec)
-{
-  const ScopeChain& chain = exec->scopeChain();
-  ScopeChainIterator iter = chain.begin();
-  ScopeChainIterator end = chain.end();
-  
-  // we must always have something in the scope chain
-  ASSERT(iter != end);
-
-  PropertySlot slot;
-  do { 
-    if ((*iter)->getPropertySlot(exec, m_ident, slot)) {
-        // See the comment in PostIncResolveNode::evaluate().
-        
-        JSObject* base = *iter;
-        JSValue *v = slot.getValue(exec, base, m_ident);
-
-        double n = v->toNumber(exec);
-        JSValue *n2 = jsNumber(n - 1);
-        base->put(exec, m_ident, n2);
-
-        return n2;
-    }
-
-    ++iter;
-  } while (iter != end);
-
-  return throwUndefinedVariableError(exec, m_ident);
+JSValue* PreDecResolveNode::evaluate(ExecState* exec)
+{
+    const ScopeChain& chain = exec->scopeChain();
+    ScopeChainIterator iter = chain.begin();
+    ScopeChainIterator end = chain.end();
+
+    // we must always have something in the scope chain
+    ASSERT(iter != end);
+
+    PropertySlot slot;
+    do {
+        if ((*iter)->getPropertySlot(exec, m_ident, slot)) {
+            // See the comment in PostIncResolveNode::evaluate().
+
+            JSObject* base = *iter;
+            JSValue* v = slot.getValue(exec, base, m_ident);
+
+            double n = v->toNumber(exec);
+            JSValue* n2 = jsNumber(n - 1);
+            base->put(exec, m_ident, n2);
+
+            return n2;
+        }
+
+        ++iter;
+    } while (iter != end);
+
+    return throwUndefinedVariableError(exec, m_ident);
 }
 
@@ -1884 +1878 @@
 }
 
-JSValue *PreIncBracketNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSValue *subscript = m_subscript->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *base = baseValue->toObject(exec);
-
-  uint32_t propertyIndex;
-  if (subscript->getUInt32(propertyIndex)) {
+JSValue* PreIncBracketNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSValue* subscript = m_subscript->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* base = baseValue->toObject(exec);
+
+    uint32_t propertyIndex;
+    if (subscript->getUInt32(propertyIndex)) {
+        PropertySlot slot;
+        JSValue* v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
+        KJS_CHECKEXCEPTIONVALUE
+
+        JSValue* n2 = jsNumber(v->toNumber(exec) + 1);
+        base->put(exec, propertyIndex, n2);
+
+        return n2;
+    }
+
+    Identifier propertyName(subscript->toString(exec));
     PropertySlot slot;
-    JSValue *v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
-    KJS_CHECKEXCEPTIONVALUE
-
-    JSValue *n2 = jsNumber(v->toNumber(exec) + 1);
-    base->put(exec, propertyIndex, n2);
+    JSValue* v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSValue* n2 = jsNumber(v->toNumber(exec) + 1);
+    base->put(exec, propertyName, n2);
 
     return n2;
-  }
-
-  Identifier propertyName(subscript->toString(exec));
-  PropertySlot slot;
-  JSValue *v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSValue *n2 = jsNumber(v->toNumber(exec) + 1);
-  base->put(exec, propertyName, n2);
-
-  return n2;
-}
-
-JSValue *PreDecBracketNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSValue *subscript = m_subscript->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *base = baseValue->toObject(exec);
-
-  uint32_t propertyIndex;
-  if (subscript->getUInt32(propertyIndex)) {
+}
+
+JSValue* PreDecBracketNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSValue* subscript = m_subscript->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* base = baseValue->toObject(exec);
+
+    uint32_t propertyIndex;
+    if (subscript->getUInt32(propertyIndex)) {
+        PropertySlot slot;
+        JSValue* v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
+        KJS_CHECKEXCEPTIONVALUE
+
+        JSValue* n2 = jsNumber(v->toNumber(exec) - 1);
+        base->put(exec, propertyIndex, n2);
+
+        return n2;
+    }
+
+    Identifier propertyName(subscript->toString(exec));
     PropertySlot slot;
-    JSValue *v = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
-    KJS_CHECKEXCEPTIONVALUE
-
-    JSValue *n2 = jsNumber(v->toNumber(exec) - 1);
-    base->put(exec, propertyIndex, n2);
+    JSValue* v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSValue* n2 = jsNumber(v->toNumber(exec) - 1);
+    base->put(exec, propertyName, n2);
 
     return n2;
-  }
-
-  Identifier propertyName(subscript->toString(exec));
-  PropertySlot slot;
-  JSValue *v = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSValue *n2 = jsNumber(v->toNumber(exec) - 1);
-  base->put(exec, propertyName, n2);
-
-  return n2;
 }
 
@@ -1955 +1949 @@
 }
 
-JSValue *PreIncDotNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSObject *base = baseValue->toObject(exec);
-
-  PropertySlot slot;
-  JSValue *v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-
-  double n = v->toNumber(exec);
-  JSValue *n2 = jsNumber(n + 1);
-  base->put(exec, m_ident, n2);
-
-  return n2;
-}
-
-JSValue *PreDecDotNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSObject *base = baseValue->toObject(exec);
-
-  PropertySlot slot;
-  JSValue *v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-
-  double n = v->toNumber(exec);
-  JSValue *n2 = jsNumber(n - 1);
-  base->put(exec, m_ident, n2);
-
-  return n2;
+JSValue* PreIncDotNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSObject* base = baseValue->toObject(exec);
+
+    PropertySlot slot;
+    JSValue* v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
+    KJS_CHECKEXCEPTIONVALUE
+
+    double n = v->toNumber(exec);
+    JSValue* n2 = jsNumber(n + 1);
+    base->put(exec, m_ident, n2);
+
+    return n2;
+}
+
+JSValue* PreDecDotNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSObject* base = baseValue->toObject(exec);
+
+    PropertySlot slot;
+    JSValue* v = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
+    KJS_CHECKEXCEPTIONVALUE
+
+    double n = v->toNumber(exec);
+    JSValue* n2 = jsNumber(n - 1);
+    base->put(exec, m_ident, n2);
+
+    return n2;
 }
 
@@ -1994 +1988 @@
 {
     throwError(exec, ReferenceError, "Prefix %s operator applied to value that is not a reference.",
-        m_oper == OpPlusPlus ? "++" : "--");
+               m_operator == OpPlusPlus ? "++" : "--");
     handleException(exec);
     return jsUndefined();
@@ -2009 +2003 @@
 JSValue* UnaryPlusNode::evaluate(ExecState* exec)
 {
-    JSValue *v = m_expr->evaluate(exec);
+    JSValue* v = m_expr->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     return v->toJSNumber(exec);
@@ -2127 +2121 @@
 }
 
-JSValue *MultNode::evaluate(ExecState* exec)
+JSValue* MultNode::evaluate(ExecState* exec)
 {
     return jsNumber(inlineEvaluateToNumber(exec));
 }
-    
+
 double MultNode::evaluateToNumber(ExecState* exec)
 {
@@ -2241 +2235 @@
     exec->setException(error);
     return 0.0;
-}    
+}
 
 // ECMA 11.6
@@ -2247 +2241 @@
 {
     // exception for the Date exception in defaultValue()
-    JSValue *p1 = v1->toPrimitive(exec, UnspecifiedType);
-    JSValue *p2 = v2->toPrimitive(exec, UnspecifiedType);
-    
+    JSValue* p1 = v1->toPrimitive(exec, UnspecifiedType);
+    JSValue* p2 = v2->toPrimitive(exec, UnspecifiedType);
+
     if (p1->isString() || p2->isString()) {
         UString value = p1->toString(exec) + p2->toString(exec);
@@ -2256 +2250 @@
         return jsString(value);
     }
-    
+
     return jsNumber(p1->toNumber(exec) + p2->toNumber(exec));
 }
@@ -2263 +2257 @@
 {
     // exception for the Date exception in defaultValue()
-    JSValue *p1 = v1->toPrimitive(exec, UnspecifiedType);
-    JSValue *p2 = v2->toPrimitive(exec, UnspecifiedType);
-    
+    JSValue* p1 = v1->toPrimitive(exec, UnspecifiedType);
+    JSValue* p2 = v2->toPrimitive(exec, UnspecifiedType);
+
     if (p1->isString() || p2->isString()) {
         UString value = p1->toString(exec) + p2->toString(exec);
@@ -2272 +2266 @@
         return value.toDouble();
     }
-    
+
     return p1->toNumber(exec) + p2->toNumber(exec);
 }
@@ -2286 +2280 @@
 //    1       Add case: 3 5
 
-static inline JSValue* add(ExecState* exec, JSValue* v1, JSValue *v2)
+static inline JSValue* add(ExecState* exec, JSValue* v1, JSValue* v2)
 {
     JSType t1 = v1->type();
     JSType t2 = v2->type();
     const unsigned bothTypes = (t1 << 3) | t2;
-    
+
     if (bothTypes == ((NumberType << 3) | NumberType))
         return jsNumber(v1->toNumber(exec) + v2->toNumber(exec));
@@ -2300 +2294 @@
         return jsString(value);
     }
-    
+
     // All other cases are pretty uncommon
     return addSlowCase(exec, v1, v2);
 }
 
-static inline double addToNumber(ExecState* exec, JSValue* v1, JSValue *v2)
+static inline double addToNumber(ExecState* exec, JSValue* v1, JSValue* v2)
 {
     JSType t1 = v1->type();
     JSType t2 = v2->type();
     const unsigned bothTypes = (t1 << 3) | t2;
-    
+
     if (bothTypes == ((NumberType << 3) | NumberType))
         return v1->toNumber(exec) + v2->toNumber(exec);
@@ -2319 +2313 @@
         return value.toDouble();
     }
-    
+
     // All other cases are pretty uncommon
     return addSlowCaseToNumber(exec, v1, v2);
@@ -2333 +2327 @@
 JSValue* AddNode::evaluate(ExecState* exec)
 {
-  JSValue* v1 = m_term1->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSValue* v2 = m_term2->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  return add(exec, v1, v2);
+    JSValue* v1 = m_term1->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSValue* v2 = m_term2->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    return add(exec, v1, v2);
 }
 
@@ -2346 +2340 @@
     JSValue* v1 = m_term1->evaluate(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    
+
     JSValue* v2 = m_term2->evaluate(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    
+
     return addToNumber(exec, v1, v2);
 }
@@ -2366 +2360 @@
 {
     return JSValue::toUInt32(inlineEvaluateToNumber(exec));
-}    
+}
 
 double AddNumbersNode::inlineEvaluateToNumber(ExecState* exec)
@@ -2400 +2394 @@
     JSValue* v1 = m_term1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    
+
     JSValue* v2 = m_term2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    
+
     return jsString(static_cast<StringImp*>(v1)->value() + static_cast<StringImp*>(v2)->value());
 }
@@ -2411 +2405 @@
     JSValue* v1 = m_term1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    
+
     JSValue* v2 = m_term2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    
+
     JSValue* p2 = v2->toPrimitive(exec, UnspecifiedType);
     return jsString(static_cast<StringImp*>(v1)->value() + p2->toString(exec));
@@ -2423 +2417 @@
     JSValue* v1 = m_term1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    
+
     JSValue* v2 = m_term2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    
+
     JSValue* p1 = v1->toPrimitive(exec, UnspecifiedType);
     return jsString(p1->toString(exec) + static_cast<StringImp*>(v2)->value());
@@ -2464 +2458 @@
 {
     return JSValue::toUInt32(inlineEvaluateToNumber(exec));
-}    
+}
 
 // ------------------------------ Shift Nodes ------------------------------------
@@ -2575 +2569 @@
 // ------------------------------ Relational Nodes -------------------------------
 
-static inline bool lessThan(ExecState *exec, JSValue* v1, JSValue* v2) 
+static inline bool lessThan(ExecState* exec, JSValue* v1, JSValue* v2)
 {
     double n1;
@@ -2583 +2577 @@
     bool wasNotString1 = v1->getPrimitiveNumber(exec, n1, p1);
     bool wasNotString2 = v2->getPrimitiveNumber(exec, n2, p2);
-    
+
     if (wasNotString1 | wasNotString2)
         return n1 < n2;
@@ -2590 +2584 @@
 }
 
-static inline bool lessThanEq(ExecState *exec, JSValue* v1, JSValue* v2) 
+static inline bool lessThanEq(ExecState* exec, JSValue* v1, JSValue* v2)
 {
     double n1;
@@ -2598 +2592 @@
     bool wasNotString1 = v1->getPrimitiveNumber(exec, n1, p1);
     bool wasNotString2 = v2->getPrimitiveNumber(exec, n2, p2);
-    
+
     if (wasNotString1 | wasNotString2)
         return n1 <= n2;
@@ -2674 +2668 @@
 
 // ECMA 11.8.2
-bool GreaterNode::inlineEvaluateToBoolean(ExecState *exec)
+bool GreaterNode::inlineEvaluateToBoolean(ExecState* exec)
 {
     JSValue* v1 = m_expr1->evaluate(exec);
@@ -2688 +2682 @@
 }
 
-bool GreaterNode::evaluateToBoolean(ExecState *exec)
+bool GreaterNode::evaluateToBoolean(ExecState* exec)
 {
     return inlineEvaluateToBoolean(exec);
@@ -2805 +2799 @@
 
 // ECMA 11.8.7
-JSValue* InNode::evaluate(ExecState *exec)
+JSValue* InNode::evaluate(ExecState* exec)
 {
     JSValue* v1 = m_expr1->evaluate(exec);
@@ -2818 +2812 @@
 }
 
-bool InNode::evaluateToBoolean(ExecState *exec)
+bool InNode::evaluateToBoolean(ExecState* exec)
 {
     JSValue* v1 = m_expr1->evaluate(exec);
@@ -2848 +2842 @@
     JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    
+
     return equal(exec, v1, v2);
 }
@@ -2953 +2947 @@
 // ECMA 11.10
 JSValue* BitAndNode::evaluate(ExecState* exec)
-{    
-    JSValue *v1 = m_expr1->evaluate(exec);
-    KJS_CHECKEXCEPTIONVALUE
-    JSValue *v2 = m_expr2->evaluate(exec);
+{
+    JSValue* v1 = m_expr1->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
 
@@ -3169 +3163 @@
 static ALWAYS_INLINE JSValue* valueForReadModifyAssignment(ExecState* exec, JSValue* current, ExpressionNode* right, Operator oper)
 {
-  JSValue *v;
-  int i1;
-  int i2;
-  unsigned int ui;
-  switch (oper) {
-  case OpMultEq:
-    v = jsNumber(current->toNumber(exec) * right->evaluateToNumber(exec));
-    break;
-  case OpDivEq:
-    v = jsNumber(current->toNumber(exec) / right->evaluateToNumber(exec));
-    break;
-  case OpPlusEq:
-    v = add(exec, current, right->evaluate(exec));
-    break;
-  case OpMinusEq:
-    v = jsNumber(current->toNumber(exec) - right->evaluateToNumber(exec));
-    break;
-  case OpLShift:
-    i1 = current->toInt32(exec);
-    i2 = right->evaluateToInt32(exec);
-    v = jsNumber(i1 << i2);
-    break;
-  case OpRShift:
-    i1 = current->toInt32(exec);
-    i2 = right->evaluateToInt32(exec);
-    v = jsNumber(i1 >> i2);
-    break;
-  case OpURShift:
-    ui = current->toUInt32(exec);
-    i2 = right->evaluateToInt32(exec);
-    v = jsNumber(ui >> i2);
-    break;
-  case OpAndEq:
-    i1 = current->toInt32(exec);
-    i2 = right->evaluateToInt32(exec);
-    v = jsNumber(i1 & i2);
-    break;
-  case OpXOrEq:
-    i1 = current->toInt32(exec);
-    i2 = right->evaluateToInt32(exec);
-    v = jsNumber(i1 ^ i2);
-    break;
-  case OpOrEq:
-    i1 = current->toInt32(exec);
-    i2 = right->evaluateToInt32(exec);
-    v = jsNumber(i1 | i2);
-    break;
-  case OpModEq: {
-    double d1 = current->toNumber(exec);
-    double d2 = right->evaluateToNumber(exec);
-    v = jsNumber(fmod(d1, d2));
-  }
-    break;
-  default:
-    ASSERT_NOT_REACHED();
-    v = jsUndefined();
-  }
-  
-  return v;
+    JSValue* v;
+    int i1;
+    int i2;
+    unsigned int ui;
+    switch (oper) {
+        case OpMultEq:
+            v = jsNumber(current->toNumber(exec) * right->evaluateToNumber(exec));
+            break;
+        case OpDivEq:
+            v = jsNumber(current->toNumber(exec) / right->evaluateToNumber(exec));
+            break;
+        case OpPlusEq:
+            v = add(exec, current, right->evaluate(exec));
+            break;
+        case OpMinusEq:
+            v = jsNumber(current->toNumber(exec) - right->evaluateToNumber(exec));
+            break;
+        case OpLShift:
+            i1 = current->toInt32(exec);
+            i2 = right->evaluateToInt32(exec);
+            v = jsNumber(i1 << i2);
+            break;
+        case OpRShift:
+            i1 = current->toInt32(exec);
+            i2 = right->evaluateToInt32(exec);
+            v = jsNumber(i1 >> i2);
+            break;
+        case OpURShift:
+            ui = current->toUInt32(exec);
+            i2 = right->evaluateToInt32(exec);
+            v = jsNumber(ui >> i2);
+            break;
+        case OpAndEq:
+            i1 = current->toInt32(exec);
+            i2 = right->evaluateToInt32(exec);
+            v = jsNumber(i1 & i2);
+            break;
+        case OpXOrEq:
+            i1 = current->toInt32(exec);
+            i2 = right->evaluateToInt32(exec);
+            v = jsNumber(i1 ^ i2);
+            break;
+        case OpOrEq:
+            i1 = current->toInt32(exec);
+            i2 = right->evaluateToInt32(exec);
+            v = jsNumber(i1 | i2);
+            break;
+        case OpModEq: {
+            double d1 = current->toNumber(exec);
+            double d2 = right->evaluateToNumber(exec);
+            v = jsNumber(fmod(d1, d2));
+        }
+            break;
+        default:
+            ASSERT_NOT_REACHED();
+            v = jsUndefined();
+    }
+
+    return v;
 }
 
@@ -3265 +3259 @@
     JSValue** slot = &exec->localStorage()[m_index].value;
 
-    ASSERT(m_oper != OpEqual);
-    JSValue* v = valueForReadModifyAssignment(exec, *slot, m_right.get(), m_oper);
-
-    KJS_CHECKEXCEPTIONVALUE
-
+    ASSERT(m_operator != OpEqual);
+    JSValue* v = valueForReadModifyAssignment(exec, *slot, m_right.get(), m_operator);
+
+    KJS_CHECKEXCEPTIONVALUE
     *slot = v;
     return v;
@@ -3284 +3277 @@
 
     exec->localStorage()[m_index].value = v;
-    
+
     return v;
 }
@@ -3294 +3287 @@
     ASSERT(exec->variableObject() == exec->scopeChain().top());
     JSValue* left = exec->localStorage()[m_index].value;
-    ASSERT(m_oper != OpEqual);
-    JSValue* result = valueForReadModifyAssignment(exec, left, m_right.get(), m_oper);
+    ASSERT(m_operator != OpEqual);
+    JSValue* result = valueForReadModifyAssignment(exec, left, m_right.get(), m_operator);
     KJS_CHECKEXCEPTIONVALUE
     return result;
@@ -3307 +3300 @@
 }
 
-JSValue *ReadModifyResolveNode::evaluate(ExecState *exec)
-{
-  const ScopeChain& chain = exec->scopeChain();
-  ScopeChainIterator iter = chain.begin();
-  ScopeChainIterator end = chain.end();
-  
-  // we must always have something in the scope chain
-  ASSERT(iter != end);
-
-  PropertySlot slot;
-  JSObject *base;
-  do { 
-    base = *iter;
-    if (base->getPropertySlot(exec, m_ident, slot)) {
-      // See the comment in PostIncResolveNode::evaluate().
-      
-      base = *iter;
-      goto found;
-    }
-
-    ++iter;
-  } while (iter != end);
-
-  ASSERT(m_oper != OpEqual);
-  return throwUndefinedVariableError(exec, m_ident);
-
- found:
-  JSValue *v;
-
-  
-  ASSERT(m_oper != OpEqual);
-  JSValue *v1 = slot.getValue(exec, base, m_ident);
-  KJS_CHECKEXCEPTIONVALUE
-  v = valueForReadModifyAssignment(exec, v1, m_right.get(), m_oper);
-
-  KJS_CHECKEXCEPTIONVALUE
-
-  base->put(exec, m_ident, v);
-  return v;
-}
-
-JSValue *AssignResolveNode::evaluate(ExecState *exec)
-{
-  const ScopeChain& chain = exec->scopeChain();
-  ScopeChainIterator iter = chain.begin();
-  ScopeChainIterator end = chain.end();
-  
-  // we must always have something in the scope chain
-  ASSERT(iter != end);
-
-  PropertySlot slot;
-  JSObject *base;
-  do { 
-    base = *iter;
-    if (base->getPropertySlot(exec, m_ident, slot)) {
-      // See the comment in PostIncResolveNode::evaluate().
-      
-      base = *iter;
-      goto found;
-    }
-
-    ++iter;
-  } while (iter != end);
-
- found:
-  JSValue *v = m_right->evaluate(exec);
-
-  KJS_CHECKEXCEPTIONVALUE
-
-  base->put(exec, m_ident, v);
-  return v;
+JSValue* ReadModifyResolveNode::evaluate(ExecState* exec)
+{
+    const ScopeChain& chain = exec->scopeChain();
+    ScopeChainIterator iter = chain.begin();
+    ScopeChainIterator end = chain.end();
+
+    // We must always have something in the scope chain
+    ASSERT(iter != end);
+
+    PropertySlot slot;
+    JSObject* base;
+    do {
+        base = *iter;
+        if (base->getPropertySlot(exec, m_ident, slot)) {
+            // See the comment in PostIncResolveNode::evaluate().
+
+            base = *iter;
+            goto found;
+        }
+
+        ++iter;
+    } while (iter != end);
+
+    ASSERT(m_operator != OpEqual);
+    return throwUndefinedVariableError(exec, m_ident);
+
+found:
+    JSValue* v;
+
+    ASSERT(m_operator != OpEqual);
+    JSValue* v1 = slot.getValue(exec, base, m_ident);
+    KJS_CHECKEXCEPTIONVALUE
+    v = valueForReadModifyAssignment(exec, v1, m_right.get(), m_operator);
+
+    KJS_CHECKEXCEPTIONVALUE
+
+    base->put(exec, m_ident, v);
+    return v;
+}
+
+JSValue* AssignResolveNode::evaluate(ExecState* exec)
+{
+    const ScopeChain& chain = exec->scopeChain();
+    ScopeChainIterator iter = chain.begin();
+    ScopeChainIterator end = chain.end();
+
+    // we must always have something in the scope chain
+    ASSERT(iter != end);
+
+    PropertySlot slot;
+    JSObject* base;
+    do {
+        base = *iter;
+        if (base->getPropertySlot(exec, m_ident, slot)) {
+            // See the comment in PostIncResolveNode::evaluate().
+
+            base = *iter;
+            goto found;
+        }
+
+        ++iter;
+    } while (iter != end);
+
+found:
+    JSValue* v = m_right->evaluate(exec);
+
+    KJS_CHECKEXCEPTIONVALUE
+
+    base->put(exec, m_ident, v);
+    return v;
 }
 
@@ -3388 +3380 @@
 }
 
-JSValue *AssignDotNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSObject *base = baseValue->toObject(exec);
-
-  JSValue *v = m_right->evaluate(exec);
-
-  KJS_CHECKEXCEPTIONVALUE
-
-  base->put(exec, m_ident, v);
-  return v;
+JSValue* AssignDotNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSObject* base = baseValue->toObject(exec);
+
+    JSValue* v = m_right->evaluate(exec);
+
+    KJS_CHECKEXCEPTIONVALUE
+
+    base->put(exec, m_ident, v);
+    return v;
 }
 
@@ -3408 +3400 @@
 }
 
-JSValue *ReadModifyDotNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSObject *base = baseValue->toObject(exec);
-
-  JSValue *v;
-
-  ASSERT(m_oper != OpEqual);
-  PropertySlot slot;
-  JSValue *v1 = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-  v = valueForReadModifyAssignment(exec, v1, m_right.get(), m_oper);
-
-  KJS_CHECKEXCEPTIONVALUE
-
-  base->put(exec, m_ident, v);
-  return v;
+JSValue* ReadModifyDotNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSObject* base = baseValue->toObject(exec);
+
+    JSValue* v;
+
+    ASSERT(m_operator != OpEqual);
+    PropertySlot slot;
+    JSValue* v1 = base->getPropertySlot(exec, m_ident, slot) ? slot.getValue(exec, base, m_ident) : jsUndefined();
+    KJS_CHECKEXCEPTIONVALUE
+    v = valueForReadModifyAssignment(exec, v1, m_right.get(), m_operator);
+
+    KJS_CHECKEXCEPTIONVALUE
+
+    base->put(exec, m_ident, v);
+    return v;
 }
 
@@ -3446 +3438 @@
 }
 
-JSValue *AssignBracketNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSValue *subscript = m_subscript->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *base = baseValue->toObject(exec);
-
-  uint32_t propertyIndex;
-  if (subscript->getUInt32(propertyIndex)) {
-    JSValue *v = m_right->evaluate(exec);
-    KJS_CHECKEXCEPTIONVALUE
-
-    base->put(exec, propertyIndex, v);
+JSValue* AssignBracketNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSValue* subscript = m_subscript->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* base = baseValue->toObject(exec);
+
+    uint32_t propertyIndex;
+    if (subscript->getUInt32(propertyIndex)) {
+        JSValue* v = m_right->evaluate(exec);
+        KJS_CHECKEXCEPTIONVALUE
+
+        base->put(exec, propertyIndex, v);
+        return v;
+    }
+
+    Identifier propertyName(subscript->toString(exec));
+    JSValue* v = m_right->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    base->put(exec, propertyName, v);
     return v;
-  }
-
-  Identifier propertyName(subscript->toString(exec));
-  JSValue *v = m_right->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  base->put(exec, propertyName, v);
-  return v;
 }
 void ReadModifyBracketNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
@@ -3478 +3470 @@
 }
 
-JSValue *ReadModifyBracketNode::evaluate(ExecState *exec)
-{
-  JSValue *baseValue = m_base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSValue *subscript = m_subscript->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSObject *base = baseValue->toObject(exec);
-
-  uint32_t propertyIndex;
-  if (subscript->getUInt32(propertyIndex)) {
-    JSValue *v;
-    ASSERT(m_oper != OpEqual);
+JSValue* ReadModifyBracketNode::evaluate(ExecState* exec)
+{
+    JSValue* baseValue = m_base->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    JSValue* subscript = m_subscript->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    JSObject* base = baseValue->toObject(exec);
+
+    uint32_t propertyIndex;
+    if (subscript->getUInt32(propertyIndex)) {
+        JSValue* v;
+        ASSERT(m_operator != OpEqual);
+        PropertySlot slot;
+        JSValue* v1 = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
+        KJS_CHECKEXCEPTIONVALUE
+        v = valueForReadModifyAssignment(exec, v1, m_right.get(), m_operator);
+
+        KJS_CHECKEXCEPTIONVALUE
+
+        base->put(exec, propertyIndex, v);
+        return v;
+    }
+
+    Identifier propertyName(subscript->toString(exec));
+    JSValue* v;
+
+    ASSERT(m_operator != OpEqual);
     PropertySlot slot;
-    JSValue *v1 = base->getPropertySlot(exec, propertyIndex, slot) ? slot.getValue(exec, base, propertyIndex) : jsUndefined();
-    KJS_CHECKEXCEPTIONVALUE
-    v = valueForReadModifyAssignment(exec, v1, m_right.get(), m_oper);
-
-    KJS_CHECKEXCEPTIONVALUE
-
-    base->put(exec, propertyIndex, v);
+    JSValue* v1 = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
+    KJS_CHECKEXCEPTIONVALUE
+    v = valueForReadModifyAssignment(exec, v1, m_right.get(), m_operator);
+
+    KJS_CHECKEXCEPTIONVALUE
+
+    base->put(exec, propertyName, v);
     return v;
-  }
-
-  Identifier propertyName(subscript->toString(exec));
-  JSValue *v;
-
-  ASSERT(m_oper != OpEqual);
-  PropertySlot slot;
-  JSValue *v1 = base->getPropertySlot(exec, propertyName, slot) ? slot.getValue(exec, base, propertyName) : jsUndefined();
-  KJS_CHECKEXCEPTIONVALUE
-  v = valueForReadModifyAssignment(exec, v1, m_right.get(), m_oper);
-
-  KJS_CHECKEXCEPTIONVALUE
-
-  base->put(exec, propertyName, v);
-  return v;
 }
 
@@ -3526 +3518 @@
 
 // ECMA 11.14
-JSValue* CommaNode::evaluate(ExecState *exec)
+JSValue* CommaNode::evaluate(ExecState* exec)
 {
     m_expr1->evaluate(exec);
@@ -3553 +3545 @@
     ScopeChainIterator iter = chain.begin();
     ScopeChainIterator end = chain.end();
-    
-    // we must always have something in the scope chain
+
+    // We must always have something in the scope chain
     ASSERT(iter != end);
-    
+
     PropertySlot slot;
     JSObject* base;
-    
+
     do {
         base = *iter;
         if (base->getPropertySlot(exec, m_ident, slot))
             break;
-        
+
         ++iter;
     } while (iter != end);
-    
+
     unsigned flags = 0;
     base->getPropertyAttributes(m_ident, flags);
     flags |= ReadOnly;
-    
+
     base->put(exec, m_ident, val, flags);
 }
@@ -3599 +3591 @@
 
             // if the variable object is the top of the scope chain, then that must
-            // be where this variable is declared, processVarDecls would have put 
+            // be where this variable is declared, processVarDecls would have put
             // it there. Don't search the scope chain, to optimize this very common case.
             if (chain.top() != variableObject)
@@ -3607 +3599 @@
             variableObject->getPropertyAttributes(m_ident, flags);
             flags |= ReadOnly;
-            
+
             variableObject->put(exec, m_ident, val, flags);
         }
@@ -3658 +3650 @@
 static inline Node* statementListInitializeVariableAccessStack(StatementVector& statements, DeclarationStacks::NodeStack& stack)
 {
-    if (!statements.size())
+    if (statements.isEmpty())
         return 0;
 
@@ -3664 +3656 @@
     StatementVector::iterator begin = statements.begin();
     StatementVector::iterator beginPlusOne = begin + 1;
-    
+
     while (it != beginPlusOne) {
         --it;
@@ -3780 +3772 @@
     if (b)
         return m_ifBlock->execute(exec);
-
     return m_elseBlock->execute(exec);
 }
@@ -3816 +3807 @@
         }
 
-continueDoWhileLoop:
+    continueDoWhileLoop:
         bool b = m_expr->evaluateToBoolean(exec);
         KJS_CHECKEXCEPTION
@@ -3851 +3842 @@
         if (exec->dynamicGlobalObject()->timedOut())
             return exec->setInterruptedCompletion();
-    
+
         if (statementValue)
             value = statementValue;
@@ -3878 +3869 @@
 
 // ECMA 12.6.3
-JSValue* ForNode::execute(ExecState *exec)
+JSValue* ForNode::execute(ExecState* exec)
 {
     JSValue* value = 0;
@@ -3908 +3899 @@
         }
 
-continueForLoop:
+    continueForLoop:
         m_expr3->evaluate(exec);
         KJS_CHECKEXCEPTION
     }
-  
+
     return exec->setNormalCompletion(value);
 }
@@ -3934 +3925 @@
     , m_identIsVarDecl(true)
 {
-  if (in)
-      m_init = new AssignResolveNode(ident, in);
-  // for( var foo = bar in baz )
+    if (in)
+        m_init = new AssignResolveNode(ident, in);
+    // for( var foo = bar in baz )
 }
 
@@ -3951 +3942 @@
 JSValue* ForInNode::execute(ExecState* exec)
 {
-  JSValue* value = 0;
-
-  if (m_init) {
-    m_init->evaluate(exec);
+    JSValue* value = 0;
+
+    if (m_init) {
+        m_init->evaluate(exec);
+        KJS_CHECKEXCEPTION
+    }
+
+    JSValue* e = m_expr->evaluate(exec);
     KJS_CHECKEXCEPTION
-  }
-
-  JSValue* e = m_expr->evaluate(exec);
-  KJS_CHECKEXCEPTION
-
-  // For Null and Undefined, we want to make sure not to go through
-  // the loop at all, because toObject will throw an exception.
-  if (e->isUndefinedOrNull())
-    return exec->setNormalCompletion();
-
-  JSObject* v = e->toObject(exec);
-  PropertyNameArray propertyNames;
-  v->getPropertyNames(exec, propertyNames);
-  
-  PropertyNameArray::const_iterator end = propertyNames.end();
-  for (PropertyNameArray::const_iterator it = propertyNames.begin(); it != end; ++it) {
-      const Identifier& name = *it;
-      if (!v->hasProperty(exec, name))
-          continue;
-
-      JSValue *str = jsOwnedString(name.ustring());
-
-      if (m_lexpr->isResolveNode()) {
-        const Identifier& ident = static_cast<ResolveNode*>(m_lexpr.get())->identifier();
-
-        const ScopeChain& chain = exec->scopeChain();
-        ScopeChainIterator iter = chain.begin();
-        ScopeChainIterator end = chain.end();
-  
-        // we must always have something in the scope chain
-        ASSERT(iter != end);
-
-        PropertySlot slot;
-        JSObject *o;
-        do { 
-            o = *iter;
-            if (o->getPropertySlot(exec, ident, slot)) {
+
+    // For Null and Undefined, we want to make sure not to go through
+    // the loop at all, because toObject will throw an exception.
+    if (e->isUndefinedOrNull())
+        return exec->setNormalCompletion();
+
+    JSObject* v = e->toObject(exec);
+    PropertyNameArray propertyNames;
+    v->getPropertyNames(exec, propertyNames);
+
+    PropertyNameArray::const_iterator end = propertyNames.end();
+    for (PropertyNameArray::const_iterator it = propertyNames.begin(); it != end; ++it) {
+        const Identifier& name = *it;
+        if (!v->hasProperty(exec, name))
+            continue;
+
+        JSValue* str = jsOwnedString(name.ustring());
+
+        if (m_lexpr->isResolveNode()) {
+            const Identifier& ident = static_cast<ResolveNode*>(m_lexpr.get())->identifier();
+
+            const ScopeChain& chain = exec->scopeChain();
+            ScopeChainIterator iter = chain.begin();
+            ScopeChainIterator end = chain.end();
+
+            // we must always have something in the scope chain
+            ASSERT(iter != end);
+
+            PropertySlot slot;
+            JSObject* o;
+            do {
+                o = *iter;
+                if (o->getPropertySlot(exec, ident, slot)) {
+                    o->put(exec, ident, str);
+                    break;
+                }
+                ++iter;
+            } while (iter != end);
+
+            if (iter == end)
                 o->put(exec, ident, str);
+        } else if (m_lexpr->isDotAccessorNode()) {
+            const Identifier& ident = static_cast<DotAccessorNode*>(m_lexpr.get())->identifier();
+            JSValue* v = static_cast<DotAccessorNode*>(m_lexpr.get())->base()->evaluate(exec);
+            KJS_CHECKEXCEPTION
+            JSObject* o = v->toObject(exec);
+
+            o->put(exec, ident, str);
+        } else {
+            ASSERT(m_lexpr->isBracketAccessorNode());
+            JSValue* v = static_cast<BracketAccessorNode*>(m_lexpr.get())->base()->evaluate(exec);
+            KJS_CHECKEXCEPTION
+            JSValue* v2 = static_cast<BracketAccessorNode*>(m_lexpr.get())->subscript()->evaluate(exec);
+            KJS_CHECKEXCEPTION
+            JSObject* o = v->toObject(exec);
+
+            uint32_t i;
+            if (v2->getUInt32(i))
+                o->put(exec, i, str);
+            o->put(exec, Identifier(v2->toString(exec)), str);
+        }
+
+        KJS_CHECKEXCEPTION
+
+        exec->pushIteration();
+        JSValue* statementValue = m_statement->execute(exec);
+        exec->popIteration();
+        if (statementValue)
+            value = statementValue;
+
+        if (exec->completionType() != Normal) {
+            if (exec->completionType() == Continue && m_labelStack.contains(exec->breakOrContinueTarget()))
+                continue;
+            if (exec->completionType() == Break && m_labelStack.contains(exec->breakOrContinueTarget()))
                 break;
-            }
-            ++iter;
-        } while (iter != end);
-        
-        if (iter == end)
-            o->put(exec, ident, str);
-    } else if (m_lexpr->isDotAccessorNode()) {
-        const Identifier& ident = static_cast<DotAccessorNode*>(m_lexpr.get())->identifier();
-        JSValue* v = static_cast<DotAccessorNode*>(m_lexpr.get())->base()->evaluate(exec);
-        KJS_CHECKEXCEPTION
-        JSObject *o = v->toObject(exec);
-
-        o->put(exec, ident, str);
-    } else {
-        ASSERT(m_lexpr->isBracketAccessorNode());
-        JSValue* v = static_cast<BracketAccessorNode*>(m_lexpr.get())->base()->evaluate(exec);
-        KJS_CHECKEXCEPTION
-        JSValue* v2 = static_cast<BracketAccessorNode*>(m_lexpr.get())->subscript()->evaluate(exec);
-        KJS_CHECKEXCEPTION
-        JSObject *o = v->toObject(exec);
-
-        uint32_t i;
-        if (v2->getUInt32(i))
-            o->put(exec, i, str);
-        o->put(exec, Identifier(v2->toString(exec)), str);
-    }
-
-    KJS_CHECKEXCEPTION
-
-    exec->pushIteration();
-    JSValue* statementValue = m_statement->execute(exec);
-    exec->popIteration();
-    if (statementValue)
-      value = statementValue;
-
-    if (exec->completionType() != Normal) {
-        if (exec->completionType() == Continue && m_labelStack.contains(exec->breakOrContinueTarget()))
-            continue;
-        if (exec->completionType() == Break && m_labelStack.contains(exec->breakOrContinueTarget()))
-            break;
-        return statementValue;
-    }
-  }
-
-  return exec->setNormalCompletion(value);
+            return statementValue;
+        }
+    }
+
+    return exec->setNormalCompletion(value);
 }
 
@@ -4047 +4038 @@
 JSValue* ContinueNode::execute(ExecState* exec)
 {
-  if (m_ident.isEmpty() && !exec->inIteration())
-    return setErrorCompletion(exec, SyntaxError, "Invalid continue statement.");
-  if (!m_ident.isEmpty() && !exec->seenLabels().contains(m_ident))
-    return setErrorCompletion(exec, SyntaxError, "Label %s not found.", m_ident);
-  return exec->setContinueCompletion(&m_ident);
+    if (m_ident.isEmpty() && !exec->inIteration())
+        return setErrorCompletion(exec, SyntaxError, "Invalid continue statement.");
+    if (!m_ident.isEmpty() && !exec->seenLabels().contains(m_ident))
+        return setErrorCompletion(exec, SyntaxError, "Label %s not found.", m_ident);
+    return exec->setContinueCompletion(&m_ident);
 }
 
@@ -4057 +4048 @@
 
 // ECMA 12.8
-JSValue* BreakNode::execute(ExecState *exec)
-{
-  if (m_ident.isEmpty() && !exec->inIteration() && !exec->inSwitch())
-    return setErrorCompletion(exec, SyntaxError, "Invalid break statement.");
-  if (!m_ident.isEmpty() && !exec->seenLabels().contains(m_ident))
-    return setErrorCompletion(exec, SyntaxError, "Label %s not found.");
-  return exec->setBreakCompletion(&m_ident);
+JSValue* BreakNode::execute(ExecState* exec)
+{
+    if (m_ident.isEmpty() && !exec->inIteration() && !exec->inSwitch())
+        return setErrorCompletion(exec, SyntaxError, "Invalid break statement.");
+    if (!m_ident.isEmpty() && !exec->seenLabels().contains(m_ident))
+        return setErrorCompletion(exec, SyntaxError, "Label %s not found.");
+    return exec->setBreakCompletion(&m_ident);
 }
 
@@ -4077 +4068 @@
 JSValue* ReturnNode::execute(ExecState* exec)
 {
-  CodeType codeType = exec->codeType();
-  if (codeType != FunctionCode)
-    return setErrorCompletion(exec, SyntaxError, "Invalid return statement.");
-
-  if (!m_value)
-    return exec->setReturnValueCompletion(jsUndefined());
-
-  JSValue* v = m_value->evaluate(exec);
-  KJS_CHECKEXCEPTION
-
-  return exec->setReturnValueCompletion(v);
+    CodeType codeType = exec->codeType();
+    if (codeType != FunctionCode)
+        return setErrorCompletion(exec, SyntaxError, "Invalid return statement.");
+
+    if (!m_value)
+        return exec->setReturnValueCompletion(jsUndefined());
+
+    JSValue* v = m_value->evaluate(exec);
+    KJS_CHECKEXCEPTION
+
+    return exec->setReturnValueCompletion(v);
 }
 
@@ -4099 +4090 @@
 
 // ECMA 12.10
-JSValue* WithNode::execute(ExecState *exec)
-{
-  JSValue *v = m_expr->evaluate(exec);
-  KJS_CHECKEXCEPTION
-  JSObject *o = v->toObject(exec);
-  KJS_CHECKEXCEPTION
-  exec->dynamicGlobalObject()->tearOffActivation(exec);
-  exec->pushScope(o);
-  JSValue* value = m_statement->execute(exec);
-  exec->popScope();
-
-  return value;
-}
-    
+JSValue* WithNode::execute(ExecState* exec)
+{
+    JSValue* v = m_expr->evaluate(exec);
+    KJS_CHECKEXCEPTION
+    JSObject* o = v->toObject(exec);
+    KJS_CHECKEXCEPTION
+    exec->dynamicGlobalObject()->tearOffActivation(exec);
+    exec->pushScope(o);
+    JSValue* value = m_statement->execute(exec);
+    exec->popScope();
+
+    return value;
+}
+
 // ------------------------------ CaseClauseNode -------------------------------
 
@@ -4123 +4114 @@
 
 // ECMA 12.11
-JSValue *CaseClauseNode::evaluate(ExecState *exec)
-{
-  JSValue *v = m_expr->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  return v;
+JSValue* CaseClauseNode::evaluate(ExecState* exec)
+{
+    JSValue* v = m_expr->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+
+    return v;
 }
 
@@ -4154 +4145 @@
 {
 }
- 
+
 void CaseBlockNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
@@ -4168 +4159 @@
 JSValue* CaseBlockNode::executeBlock(ExecState* exec, JSValue* input)
 {
-  ClauseListNode* a = m_list1.get();
+    ClauseListNode* a = m_list1.get();
     while (a) {
-      CaseClauseNode* clause = a->getClause();
-      a = a->getNext();
-      JSValue* v = clause->evaluate(exec);
-      KJS_CHECKEXCEPTION
-      if (strictEqual(exec, input, v)) {
+        CaseClauseNode* clause = a->getClause();
+        a = a->getNext();
+        JSValue* v = clause->evaluate(exec);
+        KJS_CHECKEXCEPTION
+        if (strictEqual(exec, input, v)) {
+            JSValue* res = clause->executeStatements(exec);
+            if (exec->completionType() != Normal)
+                return res;
+            for (; a; a = a->getNext()) {
+                JSValue* res = a->getClause()->executeStatements(exec);
+                if (exec->completionType() != Normal)
+                    return res;
+            }
+            break;
+        }
+    }
+
+    ClauseListNode* b = m_list2.get();
+    while (b) {
+        CaseClauseNode* clause = b->getClause();
+        b = b->getNext();
+        JSValue* v = clause->evaluate(exec);
+        KJS_CHECKEXCEPTION
+        if (strictEqual(exec, input, v)) {
+            JSValue* res = clause->executeStatements(exec);
+            if (exec->completionType() != Normal)
+                return res;
+            goto step18;
+        }
+    }
+
+    // default clause
+    if (m_defaultClause) {
+        JSValue* res = m_defaultClause->executeStatements(exec);
+        if (exec->completionType() != Normal)
+            return res;
+    }
+    b = m_list2.get();
+step18:
+    while (b) {
+        CaseClauseNode* clause = b->getClause();
         JSValue* res = clause->executeStatements(exec);
         if (exec->completionType() != Normal)
-          return res;
-        for (; a; a = a->getNext()) {
-          JSValue* res = a->getClause()->executeStatements(exec);
-          if (exec->completionType() != Normal)
             return res;
-        }
-        break;
-      }
-    }
-
-  ClauseListNode* b = m_list2.get();
-  while (b) {
-    CaseClauseNode* clause = b->getClause();
-    b = b->getNext();
-    JSValue* v = clause->evaluate(exec);
+        b = b->getNext();
+    }
+
+    // bail out on error
     KJS_CHECKEXCEPTION
-    if (strictEqual(exec, input, v)) {
-      JSValue* res = clause->executeStatements(exec);
-      if (exec->completionType() != Normal)
-        return res;
-      goto step18;
-    }
-  }
-
-  // default clause
-  if (m_defaultClause) {
-    JSValue* res = m_defaultClause->executeStatements(exec);
-    if (exec->completionType() != Normal)
-      return res;
-  }
-  b = m_list2.get();
- step18:
-  while (b) {
-    CaseClauseNode* clause = b->getClause();
-    JSValue* res = clause->executeStatements(exec);
-    if (exec->completionType() != Normal)
-      return res;
-    b = b->getNext();
-  }
-
-  // bail out on error
-  KJS_CHECKEXCEPTION
-
-  return exec->setNormalCompletion();
+
+    return exec->setNormalCompletion();
 }
 
@@ -4234 +4225 @@
 JSValue* SwitchNode::execute(ExecState* exec)
 {
-  JSValue *v = m_expr->evaluate(exec);
-  KJS_CHECKEXCEPTION
-
-  exec->pushSwitch();
-  JSValue* result = m_block->executeBlock(exec, v);
-  exec->popSwitch();
-
-  if (exec->completionType() == Break && m_labelStack.contains(exec->breakOrContinueTarget()))
-    exec->setCompletionType(Normal);
-  return result;
+    JSValue* v = m_expr->evaluate(exec);
+    KJS_CHECKEXCEPTION
+
+    exec->pushSwitch();
+    JSValue* result = m_block->executeBlock(exec, v);
+    exec->popSwitch();
+
+    if (exec->completionType() == Break && m_labelStack.contains(exec->breakOrContinueTarget()))
+        exec->setCompletionType(Normal);
+    return result;
 }
 
@@ -4256 +4247 @@
 JSValue* LabelNode::execute(ExecState* exec)
 {
-  if (!exec->seenLabels().push(m_label))
-    return setErrorCompletion(exec, SyntaxError, "Duplicated label %s found.", m_label);
-  JSValue* result = m_statement->execute(exec);
-  exec->seenLabels().pop();
-
-  if (exec->completionType() == Break && exec->breakOrContinueTarget() == m_label)
-    exec->setCompletionType(Normal);
-  return result;
+    if (!exec->seenLabels().push(m_label))
+        return setErrorCompletion(exec, SyntaxError, "Duplicated label %s found.", m_label);
+    JSValue* result = m_statement->execute(exec);
+    exec->seenLabels().pop();
+
+    if (exec->completionType() == Break && exec->breakOrContinueTarget() == m_label)
+        exec->setCompletionType(Normal);
+    return result;
 }
 
@@ -4276 +4267 @@
 JSValue* ThrowNode::execute(ExecState* exec)
 {
-  JSValue *v = m_expr->evaluate(exec);
-  KJS_CHECKEXCEPTION
-
-  handleException(exec, v);
-  return exec->setThrowCompletion(v);
+    JSValue* v = m_expr->evaluate(exec);
+    KJS_CHECKEXCEPTION
+
+    handleException(exec, v);
+    return exec->setThrowCompletion(v);
 }
 
@@ -4296 +4287 @@
 JSValue* TryNode::execute(ExecState* exec)
 {
-  JSValue* result = m_tryBlock->execute(exec);
-
-  if (Collector::isOutOfMemory())
-      return result; // don't try to catch an out of memory exception thrown by the collector
-  
-  if (m_catchBlock && exec->completionType() == Throw) {
-    JSObject* obj = new JSObject;
-    obj->put(exec, m_exceptionIdent, result, DontDelete);
-    exec->dynamicGlobalObject()->tearOffActivation(exec);
-    exec->pushScope(obj);
-    result = m_catchBlock->execute(exec);
-    exec->popScope();
-  }
-
-  if (m_finallyBlock) {
-    ComplType savedCompletionType = exec->completionType();
-    JSValue* finallyResult = m_finallyBlock->execute(exec);
-    if (exec->completionType() != Normal)
-        result = finallyResult;
-    else
-        exec->setCompletionType(savedCompletionType);
-  }
-
-  return result;
+    JSValue* result = m_tryBlock->execute(exec);
+
+    if (Collector::isOutOfMemory())
+        return result; // don't try to catch an out of memory exception thrown by the collector
+
+    if (m_catchBlock && exec->completionType() == Throw) {
+        JSObject* obj = new JSObject;
+        obj->put(exec, m_exceptionIdent, result, DontDelete);
+        exec->dynamicGlobalObject()->tearOffActivation(exec);
+        exec->pushScope(obj);
+        result = m_catchBlock->execute(exec);
+        exec->popScope();
+    }
+
+    if (m_finallyBlock) {
+        ComplType savedCompletionType = exec->completionType();
+        JSValue* finallyResult = m_finallyBlock->execute(exec);
+        if (exec->completionType() != Normal)
+            result = finallyResult;
+        else
+            exec->setCompletionType(savedCompletionType);
+    }
+
+    return result;
 }
 
@@ -4377 +4368 @@
 {
     SymbolTable& symbolTable = exec->variableObject()->symbolTable();
-    ASSERT(!symbolTable.size());
+    ASSERT(symbolTable.isEmpty());
 
     size_t localStorageIndex = 0;
@@ -4408 +4399 @@
     // FunctionBodyNode::initializeSymbolTable, which knows that no bindings
     // have yet been made.
-    
+
     JSVariableObject* variableObject = exec->variableObject();
     SymbolTable& symbolTable = variableObject->symbolTable();
@@ -4416 +4407 @@
 
     // Order must match the order in processDeclarations.
-    
+
     size = m_functionStack.size();
     m_functionIndexes.resize(size);
@@ -4454 +4445 @@
     if (!node)
         return;
-    
+
     const SymbolTable& symbolTable = exec->variableObject()->symbolTable();
     const LocalStorage& localStorage = exec->variableObject()->localStorage();
     while (true) {
         node->optimizeVariableAccess(symbolTable, localStorage, nodeStack);
-        
+
         size_t size = nodeStack.size();
         if (!size)
@@ -4474 +4465 @@
         initializeSymbolTable(exec);
 
-    if (m_functionStack.size() != 0)
+    if (!m_functionStack.isEmpty())
         exec->dynamicGlobalObject()->tearOffActivation(exec);
 
     LocalStorage& localStorage = exec->variableObject()->localStorage();
-    
+
     // We can't just resize localStorage here because that would temporarily
     // leave uninitialized entries, which would crash GC during the mark phase.
@@ -4484 +4475 @@
     if (totalSize > localStorage.capacity()) // Doing this check inline avoids function call overhead.
         localStorage.reserveCapacity(totalSize);
-    
+
     int minAttributes = Internal | DontDelete;
-    
-    // In order for our localStorage indexes to be correct, we must match the 
+
+    // In order for our localStorage indexes to be correct, we must match the
     // order of addition in initializeSymbolTable().
 
@@ -4507 +4498 @@
 
     if (!m_initialized) {
-        optimizeVariableAccess(exec);        
+        optimizeVariableAccess(exec);
         m_initialized = true;
     }
@@ -4523 +4514 @@
     // increase in L2 cache misses. FIXME: <rdar://problem/5657439> WTF?
     gccIsCrazy();
-    
+
     initializeSymbolTable(exec);
 
@@ -4559 +4550 @@
             attributes |= ReadOnly;
         LocalStorageEntry entry = LocalStorageEntry(jsUndefined(), attributes);
-            
+
         ASSERT(index == localStorage.size());
         localStorage.uncheckedAppend(entry);
@@ -4572 +4563 @@
     // reports that to be a net loss.
 
-    size_t i, size;
+    size_t i;
+    size_t size;
 
     JSVariableObject* variableObject = exec->variableObject();
-    
+
     int minAttributes = Internal;
 
@@ -4596 +4588 @@
 UString FunctionBodyNode::paramString() const
 {
-  UString s("");
-  size_t count = m_parameters.size();
-  for (size_t pos = 0; pos < count; ++pos) {
-    if (!s.isEmpty())
-        s += ", ";
-    s += m_parameters[pos].ustring();
-  }
-
-  return s;
+    UString s("");
+    size_t count = m_parameters.size();
+    for (size_t pos = 0; pos < count; ++pos) {
+        if (!s.isEmpty())
+            s += ", ";
+        s += m_parameters[pos].ustring();
+    }
+
+    return s;
 }
 
@@ -4627 +4619 @@
 // ------------------------------ FunctionBodyNodeWithDebuggerHooks ---------------------------------
 
-FunctionBodyNodeWithDebuggerHooks::FunctionBodyNodeWithDebuggerHooks(SourceElements* children,
-        DeclarationStacks::VarStack* varStack, DeclarationStacks::FunctionStack* funcStack)
+FunctionBodyNodeWithDebuggerHooks::FunctionBodyNodeWithDebuggerHooks(SourceElements* children, DeclarationStacks::VarStack* varStack, DeclarationStacks::FunctionStack* funcStack)
     : FunctionBodyNode(children, varStack, funcStack)
 {
@@ -4658 +4649 @@
 // ------------------------------ FuncDeclNode ---------------------------------
 
-void FuncDeclNode::addParams() 
-{
-  for (ParameterNode *p = m_parameter.get(); p != 0L; p = p->nextParam())
-    m_body->parameters().append(p->ident());
+void FuncDeclNode::addParams()
+{
+    for (ParameterNode* p = m_parameter.get(); p; p = p->nextParam())
+        m_body->parameters().append(p->ident());
 }
 
 FunctionImp* FuncDeclNode::makeFunction(ExecState* exec)
 {
-  FunctionImp *func = new FunctionImp(exec, m_ident, m_body.get(), exec->scopeChain());
-
-  JSObject* proto = exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
-  proto->put(exec, exec->propertyNames().constructor, func, ReadOnly | DontDelete | DontEnum);
-  func->put(exec, exec->propertyNames().prototype, proto, Internal|DontDelete);
-
-  func->put(exec, exec->propertyNames().length, jsNumber(m_body->parameters().size()), ReadOnly|DontDelete|DontEnum);
-  return func;
+    FunctionImp* func = new FunctionImp(exec, m_ident, m_body.get(), exec->scopeChain());
+
+    JSObject* proto = exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
+    proto->put(exec, exec->propertyNames().constructor, func, ReadOnly | DontDelete | DontEnum);
+    func->put(exec, exec->propertyNames().prototype, proto, Internal|DontDelete);
+
+    func->put(exec, exec->propertyNames().length, jsNumber(m_body->parameters().size()), ReadOnly|DontDelete|DontEnum);
+    return func;
 }
 
@@ -4686 +4677 @@
 void FuncExprNode::addParams()
 {
-  for (ParameterNode* p = m_parameter.get(); p != 0L; p = p->nextParam())
-    m_body->parameters().append(p->ident());
-}
-
-JSValue *FuncExprNode::evaluate(ExecState *exec)
-{
-  exec->dynamicGlobalObject()->tearOffActivation(exec);
-  
-  bool named = !m_ident.isNull();
-  JSObject *functionScopeObject = 0;
-
-  if (named) {
-    // named FunctionExpressions can recursively call themselves,
-    // but they won't register with the current scope chain and should
-    // be contained as single property in an anonymous object.
-    functionScopeObject = new JSObject;
-    exec->pushScope(functionScopeObject);
-  }
-
-  FunctionImp* func = new FunctionImp(exec, m_ident, m_body.get(), exec->scopeChain());
-  JSObject* proto = exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
-  proto->put(exec, exec->propertyNames().constructor, func, ReadOnly | DontDelete | DontEnum);
-  func->put(exec, exec->propertyNames().prototype, proto, Internal | DontDelete);
-
-  if (named) {
-    functionScopeObject->put(exec, m_ident, func, Internal | ReadOnly | (exec->codeType() == EvalCode ? 0 : DontDelete));
-    exec->popScope();
-  }
-
-  return func;
+    for (ParameterNode* p = m_parameter.get(); p; p = p->nextParam())
+        m_body->parameters().append(p->ident());
+}
+
+JSValue* FuncExprNode::evaluate(ExecState* exec)
+{
+    exec->dynamicGlobalObject()->tearOffActivation(exec);
+
+    bool named = !m_ident.isNull();
+    JSObject* functionScopeObject = 0;
+
+    if (named) {
+        // named FunctionExpressions can recursively call themselves,
+        // but they won't register with the current scope chain and should
+        // be contained as single property in an anonymous object.
+        functionScopeObject = new JSObject;
+        exec->pushScope(functionScopeObject);
+    }
+
+    FunctionImp* func = new FunctionImp(exec, m_ident, m_body.get(), exec->scopeChain());
+    JSObject* proto = exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
+    proto->put(exec, exec->propertyNames().constructor, func, ReadOnly | DontDelete | DontEnum);
+    func->put(exec, exec->propertyNames().prototype, proto, Internal | DontDelete);
+
+    if (named) {
+        functionScopeObject->put(exec, m_ident, func, Internal | ReadOnly | (exec->codeType() == EvalCode ? 0 : DontDelete));
+        exec->popScope();
+    }
+
+    return func;
 }
 

trunk/JavaScriptCore/kjs/nodes.h

@@ -2 +2 @@
  *  Copyright (C) 1999-2000 Harri Porten ([email protected])
  *  Copyright (C) 2001 Peter Kelly ([email protected])
- *  Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
+ *  Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *  Copyright (C) 2007 Cameron Zwarich ([email protected])
  *  Copyright (C) 2007 Maks Orlovich
@@ -43 +43 @@
 namespace KJS {
 
+    class ConstDeclNode;
     class FuncDeclNode;
     class Node;
     class PropertyListNode;
     class SourceStream;
-    class ConstDeclNode;
 
     enum Operator {
@@ -87 +87 @@
         PrecExpression
     };
-  
-  struct DeclarationStacks {
-      typedef Vector<Node*, 16> NodeStack;
-      enum { IsConstant = 1, HasInitializer = 2 } VarAttrs;
-      typedef Vector<std::pair<Identifier, unsigned>, 16> VarStack;
-      typedef Vector<FuncDeclNode*, 16> FunctionStack;
-      
-      DeclarationStacks(ExecState* e, NodeStack& n, VarStack& v, FunctionStack& f)
-        : exec(e)
-        , nodeStack(n)
-        , varStack(v)
-        , functionStack(f)
-      {
-      }
-
-      ExecState* exec;
-      NodeStack& nodeStack;
-      VarStack& varStack; 
-      FunctionStack& functionStack;
-  };
-
-  class ParserRefCounted : Noncopyable {
-  protected:
-    ParserRefCounted() KJS_FAST_CALL;
-    ParserRefCounted(PlacementNewAdoptType) KJS_FAST_CALL { }
-    
-  public:
-    void ref() KJS_FAST_CALL;
-    void deref() KJS_FAST_CALL;
-    unsigned refcount() KJS_FAST_CALL;
-    
-    static void deleteNewObjects() KJS_FAST_CALL;
-  
-    virtual ~ParserRefCounted();
-  };
-
-  class Node : public ParserRefCounted {
-  public:
-    typedef DeclarationStacks::NodeStack NodeStack;
-    typedef DeclarationStacks::VarStack VarStack;
-    typedef DeclarationStacks::FunctionStack FunctionStack;
-
-    Node() KJS_FAST_CALL;
-    Node(PlacementNewAdoptType placementAdopt) KJS_FAST_CALL
-    : ParserRefCounted(placementAdopt) { }
-
-    UString toString() const KJS_FAST_CALL;
-    int lineNo() const KJS_FAST_CALL { return m_line; }
-
-    // Serialization.
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL = 0;
-    virtual Precedence precedence() const = 0;
-    virtual bool needsParensIfLeftmost() const { return false; }
-
-    // Used for iterative, depth-first traversal of the node tree. Does not cross function call boundaries.
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL { }
-
-  protected:
-    Node(JSType) KJS_FAST_CALL; // used by ExpressionNode
-
-    // for use in execute()
-    JSValue* setErrorCompletion(ExecState*, ErrorType, const char* msg) KJS_FAST_CALL;
-    JSValue* setErrorCompletion(ExecState*, ErrorType, const char* msg, const Identifier&) KJS_FAST_CALL;
-
-    // for use in evaluate()
-    JSValue* throwError(ExecState*, ErrorType, const char* msg) KJS_FAST_CALL;
-    JSValue* throwError(ExecState*, ErrorType, const char* msg, const char*) KJS_FAST_CALL;
-    JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*) KJS_FAST_CALL;
-    JSValue* throwError(ExecState*, ErrorType, const char* msg, const Identifier&) KJS_FAST_CALL;
-    JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, const Identifier&) KJS_FAST_CALL;
-    JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*, Node*) KJS_FAST_CALL;
-    JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*, const Identifier&) KJS_FAST_CALL;
-
-    JSValue* throwUndefinedVariableError(ExecState*, const Identifier&) KJS_FAST_CALL;
-
-    void handleException(ExecState*) KJS_FAST_CALL;
-    void handleException(ExecState*, JSValue*) KJS_FAST_CALL;
-
-    // for use in execute()
-    JSValue* rethrowException(ExecState*) KJS_FAST_CALL;
-
-    int m_line : 28;
-    unsigned m_expectedReturnType : 3; // JSType
-  };
-    
+
+    struct DeclarationStacks {
+        typedef Vector<Node*, 16> NodeStack;
+        enum { IsConstant = 1, HasInitializer = 2 } VarAttrs;
+        typedef Vector<std::pair<Identifier, unsigned>, 16> VarStack;
+        typedef Vector<FuncDeclNode*, 16> FunctionStack;
+
+        DeclarationStacks(ExecState* e, NodeStack& n, VarStack& v, FunctionStack& f)
+            : exec(e)
+            , nodeStack(n)
+            , varStack(v)
+            , functionStack(f)
+        {
+        }
+
+        ExecState* exec;
+        NodeStack& nodeStack;
+        VarStack& varStack;
+        FunctionStack& functionStack;
+    };
+
+    class ParserRefCounted : Noncopyable {
+    protected:
+        ParserRefCounted() KJS_FAST_CALL;
+        ParserRefCounted(PlacementNewAdoptType) KJS_FAST_CALL
+        {
+        }
+
+    public:
+        void ref() KJS_FAST_CALL;
+        void deref() KJS_FAST_CALL;
+        unsigned refcount() KJS_FAST_CALL;
+
+        static void deleteNewObjects() KJS_FAST_CALL;
+
+        virtual ~ParserRefCounted();
+    };
+
+    class Node : public ParserRefCounted {
+    public:
+        typedef DeclarationStacks::NodeStack NodeStack;
+        typedef DeclarationStacks::VarStack VarStack;
+        typedef DeclarationStacks::FunctionStack FunctionStack;
+
+        Node() KJS_FAST_CALL;
+        Node(PlacementNewAdoptType placementAdopt) KJS_FAST_CALL
+            : ParserRefCounted(placementAdopt)
+        {
+        }
+
+        UString toString() const KJS_FAST_CALL;
+        int lineNo() const KJS_FAST_CALL { return m_line; }
+
+        // Serialization.
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL = 0;
+        virtual Precedence precedence() const = 0;
+        virtual bool needsParensIfLeftmost() const { return false; }
+
+        // Used for iterative, depth-first traversal of the node tree. Does not cross function call boundaries.
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL { }
+
+    protected:
+        Node(JSType) KJS_FAST_CALL; // used by ExpressionNode
+
+        // for use in execute()
+        JSValue* setErrorCompletion(ExecState*, ErrorType, const char* msg) KJS_FAST_CALL;
+        JSValue* setErrorCompletion(ExecState*, ErrorType, const char* msg, const Identifier&) KJS_FAST_CALL;
+
+        // for use in evaluate()
+        JSValue* throwError(ExecState*, ErrorType, const char* msg) KJS_FAST_CALL;
+        JSValue* throwError(ExecState*, ErrorType, const char* msg, const char*) KJS_FAST_CALL;
+        JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*) KJS_FAST_CALL;
+        JSValue* throwError(ExecState*, ErrorType, const char* msg, const Identifier&) KJS_FAST_CALL;
+        JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, const Identifier&) KJS_FAST_CALL;
+        JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*, Node*) KJS_FAST_CALL;
+        JSValue* throwError(ExecState*, ErrorType, const char* msg, JSValue*, Node*, const Identifier&) KJS_FAST_CALL;
+
+        JSValue* throwUndefinedVariableError(ExecState*, const Identifier&) KJS_FAST_CALL;
+
+        void handleException(ExecState*) KJS_FAST_CALL;
+        void handleException(ExecState*, JSValue*) KJS_FAST_CALL;
+
+        // for use in execute()
+        JSValue* rethrowException(ExecState*) KJS_FAST_CALL;
+
+        int m_line : 28;
+        unsigned m_expectedReturnType : 3; // JSType
+    };
+
     class ExpressionNode : public Node {
     public:
         ExpressionNode() KJS_FAST_CALL : Node() {}
         ExpressionNode(JSType expectedReturn) KJS_FAST_CALL
-            : Node(expectedReturn) {}
-        
+            : Node(expectedReturn)
+        {
+        }
+
         // Special constructor for cases where we overwrite an object in place.
         ExpressionNode(PlacementNewAdoptType) KJS_FAST_CALL
-            : Node(PlacementNewAdopt) {}
-        
+            : Node(PlacementNewAdopt)
+        {
+        }
+
         virtual bool isNumber() const KJS_FAST_CALL { return false; }
         virtual bool isLocation() const KJS_FAST_CALL { return false; }
@@ -187 +195 @@
         virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return false; }
         virtual bool isDotAccessorNode() const KJS_FAST_CALL { return false; }
-        
+
         JSType expectedReturnType() const KJS_FAST_CALL { return static_cast<JSType>(m_expectedReturnType); }
-        
+
         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL = 0;
         virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
@@ -198 +206 @@
         // Used to optimize those nodes that do extra work when returning a result, even if the result has no semantic relevance
         virtual void optimizeForUnnecessaryResult() { }
-   };
-
-  class StatementNode : public Node {
-  public:
-    StatementNode() KJS_FAST_CALL;
-    void setLoc(int line0, int line1) KJS_FAST_CALL;
-    int firstLine() const KJS_FAST_CALL { return lineNo(); }
-    int lastLine() const KJS_FAST_CALL { return m_lastLine; }
-    virtual JSValue* execute(ExecState *exec) KJS_FAST_CALL = 0;
-    void pushLabel(const Identifier& ident) KJS_FAST_CALL { m_labelStack.push(ident); }
-    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-    virtual bool isEmptyStatement() const KJS_FAST_CALL { return false; }
-  protected:
-    LabelStack m_labelStack;
-  private:
-    int m_lastLine;
-  };
-
-  class NullNode : public ExpressionNode {
-  public:
-    NullNode() KJS_FAST_CALL : ExpressionNode(NullType) {}
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPrimary; }
-  };
-
-  class FalseNode : public ExpressionNode {
-  public:
-    FalseNode() KJS_FAST_CALL : ExpressionNode(BooleanType) {}
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL { return false; }
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPrimary; }
-  };
-
-  class TrueNode : public ExpressionNode {
-  public:
-    TrueNode() KJS_FAST_CALL : ExpressionNode(BooleanType) {}
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL { return true; }
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPrimary; }
-  };
-
-  class PlaceholderTrueNode : public TrueNode {
-  public:
-    // Like TrueNode, but does not serialize as "true".
-    PlaceholderTrueNode() KJS_FAST_CALL : TrueNode() { }
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  };
-
-  class NumberNode : public ExpressionNode {
-  public:
-    NumberNode(double v) KJS_FAST_CALL : ExpressionNode(NumberType), m_double(v) {}
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return signbit(m_double) ? PrecUnary : PrecPrimary; }
-
-    virtual bool isNumber() const KJS_FAST_CALL { return true; }
-    double value() const KJS_FAST_CALL { return m_double; }
-    virtual void setValue(double d) KJS_FAST_CALL { m_double = d; }
-
-  protected:
-    double m_double;
-  };
-  
-  class ImmediateNumberNode : public NumberNode {
-  public:
-      ImmediateNumberNode(JSValue* v, double d) KJS_FAST_CALL : NumberNode(d), m_value(v) { ASSERT(v == JSImmediate::from(d)); }
-      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-      virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-      virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-      
-      virtual void setValue(double d) KJS_FAST_CALL { m_double = d; m_value = JSImmediate::from(d); ASSERT(m_value); }
-  private:
-      JSValue* m_value; // This is never a JSCell, only JSImmediate, thus no ProtectedPtr
-  };
-
-  class StringNode : public ExpressionNode {
-  public:
-    StringNode(const UString* v) KJS_FAST_CALL : ExpressionNode(StringType), m_value(*v) {}
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPrimary; }
-
-  private:
-    UString m_value;
-  };
-
-  class RegExpNode : public ExpressionNode {
-  public:
-    RegExpNode(const UString& pattern, const UString& flags) KJS_FAST_CALL 
-        : m_regExp(new RegExp(pattern, flags))
-    {
-    }
-    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPrimary; }
-  private:
-    RefPtr<RegExp> m_regExp;
-  };
-
-  class ThisNode : public ExpressionNode {
-  public:
-    ThisNode() KJS_FAST_CALL {}
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPrimary; }
- };
-
-  class ResolveNode : public ExpressionNode {
-  public:
-    ResolveNode(const Identifier& ident) KJS_FAST_CALL 
-        : m_ident(ident)
-    { 
-    }
-
-    // Special constructor for cases where we overwrite an object in place.
-    ResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-        : ExpressionNode(PlacementNewAdopt)
-        , m_ident(PlacementNewAdopt)
-    {
-    }
-
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPrimary; }
-
-    virtual bool isLocation() const KJS_FAST_CALL { return true; }
-    virtual bool isResolveNode() const KJS_FAST_CALL { return true; }
-    const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
-
-  protected:
-    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-    Identifier m_ident;
-    size_t m_index; // Used by LocalVarAccessNode.
-  };
-
-  class LocalVarAccessNode : public ResolveNode {
-  public:
-    // Overwrites a ResolveNode in place.
-    LocalVarAccessNode(size_t i) KJS_FAST_CALL
-        : ResolveNode(PlacementNewAdopt)
-    {
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-  private:
-    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-  };
-
-  class ElementNode : public Node {
-  public:
-    ElementNode(int elision, ExpressionNode* node) KJS_FAST_CALL
-      : m_elision(elision), m_node(node) { }
-    ElementNode(ElementNode* l, int elision, ExpressionNode* node) KJS_FAST_CALL
-      : m_elision(elision), m_node(node) { l->m_next = this; }
-    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-
-    PassRefPtr<ElementNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
-
-    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-
-  private:
-    friend class ArrayNode;
-    ListRefPtr<ElementNode> m_next;
-    int m_elision;
-    RefPtr<ExpressionNode> m_node;
-  };
-
-  class ArrayNode : public ExpressionNode {
-  public:
-    ArrayNode(int e) KJS_FAST_CALL
-      : m_elision(e), m_opt(true) { }
-    ArrayNode(ElementNode* element) KJS_FAST_CALL
-      : m_element(element), m_elision(0), m_opt(false) { }
-    ArrayNode(int elision, ElementNode* element) KJS_FAST_CALL
-      : m_element(element), m_elision(elision), m_opt(true) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPrimary; }
-  private:
-    RefPtr<ElementNode> m_element;
-    int m_elision;
-    bool m_opt;
-  };
-
-  class PropertyNode : public Node {
-  public:
-    enum Type { Constant, Getter, Setter };
-    PropertyNode(const Identifier& n, ExpressionNode* a, Type t) KJS_FAST_CALL
-      : m_name(n), m_assign(a), m_type(t) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-
-    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    const Identifier& name() const { return m_name; }
-
-  private:
-    friend class PropertyListNode;
-    Identifier m_name;
-    RefPtr<ExpressionNode> m_assign;
-    Type m_type;
-  };
-  
-  class PropertyListNode : public Node {
-  public:
-    PropertyListNode(PropertyNode* node) KJS_FAST_CALL
-      : m_node(node) { }
-    PropertyListNode(PropertyNode* node, PropertyListNode* list) KJS_FAST_CALL
-      : m_node(node) { list->m_next = this; }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-
-    JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    PassRefPtr<PropertyListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
-
-  private:
-    friend class ObjectLiteralNode;
-    RefPtr<PropertyNode> m_node;
-    ListRefPtr<PropertyListNode> m_next;
-  };
-
-  class ObjectLiteralNode : public ExpressionNode {
-  public:
-    ObjectLiteralNode() KJS_FAST_CALL { }
-    ObjectLiteralNode(PropertyListNode* list) KJS_FAST_CALL : m_list(list) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPrimary; }
-    virtual bool needsParensIfLeftmost() const { return true; }
-  private:
-    RefPtr<PropertyListNode> m_list;
-  };
-
-  class BracketAccessorNode : public ExpressionNode {
-  public:
-    BracketAccessorNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
-      : m_base(base), m_subscript(subscript) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecMember; }
-
-    virtual bool isLocation() const KJS_FAST_CALL { return true; }
-    virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return true; }
-    ExpressionNode* base() KJS_FAST_CALL { return m_base.get(); }
-    ExpressionNode* subscript() KJS_FAST_CALL { return m_subscript.get(); }
-
-  private:
-    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-    RefPtr<ExpressionNode> m_base;
-    RefPtr<ExpressionNode> m_subscript;
-  };
-
-  class DotAccessorNode : public ExpressionNode {
-  public:
-    DotAccessorNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL : m_base(base), m_ident(ident) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecMember; }
-
-    virtual bool isLocation() const KJS_FAST_CALL { return true; }
-    virtual bool isDotAccessorNode() const KJS_FAST_CALL { return true; }
-    ExpressionNode* base() const KJS_FAST_CALL { return m_base.get(); }
-    const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
-
-  private:
-    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-    RefPtr<ExpressionNode> m_base;
-    Identifier m_ident;
-  };
-
-  class ArgumentListNode : public Node {
-  public:
-    ArgumentListNode(ExpressionNode* expr) KJS_FAST_CALL
-      : m_expr(expr) { }
-    ArgumentListNode(ArgumentListNode* listNode, ExpressionNode* expr) KJS_FAST_CALL 
-      : m_expr(expr) { listNode->m_next = this; }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-
-    void evaluateList(ExecState*, List&) KJS_FAST_CALL;
-    PassRefPtr<ArgumentListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
-
-  private:
-    friend class ArgumentsNode;
-    ListRefPtr<ArgumentListNode> m_next;
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class ArgumentsNode : public Node {
-  public:
-    ArgumentsNode() KJS_FAST_CALL { }
-    ArgumentsNode(ArgumentListNode* listNode) KJS_FAST_CALL
-      : m_listNode(listNode) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-
-    void evaluateList(ExecState* exec, List& list) KJS_FAST_CALL { if (m_listNode) m_listNode->evaluateList(exec, list); }
-
-  private:
-    RefPtr<ArgumentListNode> m_listNode;
-  };
-
-  class NewExprNode : public ExpressionNode {
-  public:
-    NewExprNode(ExpressionNode* expr) KJS_FAST_CALL
-      : m_expr(expr) { }
-    NewExprNode(ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL
-      : m_expr(expr), m_args(args) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecLeftHandSide; }
-  private:
-    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-    RefPtr<ExpressionNode> m_expr;
-    RefPtr<ArgumentsNode> m_args;
-  };
-
-  class FunctionCallValueNode : public ExpressionNode {
-  public:
-    FunctionCallValueNode(ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL
-      : m_expr(expr), m_args(args) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecCall; }
-  private:
-    RefPtr<ExpressionNode> m_expr;
-    RefPtr<ArgumentsNode> m_args;
-  };
-
-  class FunctionCallResolveNode : public ExpressionNode {
-  public:
-    FunctionCallResolveNode(const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
-        : m_ident(ident)
-        , m_args(args)
-    {
-    }
-
-    FunctionCallResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-        : ExpressionNode(PlacementNewAdopt)
-        , m_ident(PlacementNewAdopt)
-        , m_args(PlacementNewAdopt)
-    {
-    }
-
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecCall; }
-
-  protected:
-    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-    Identifier m_ident;
-    RefPtr<ArgumentsNode> m_args;
-    size_t m_index; // Used by LocalVarFunctionCallNode.
-  };
-
-  class LocalVarFunctionCallNode : public FunctionCallResolveNode {
-  public:
-    LocalVarFunctionCallNode(size_t i) KJS_FAST_CALL
-        : FunctionCallResolveNode(PlacementNewAdopt)
-    {
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-  private:
-    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-  };
-
-  class FunctionCallBracketNode : public ExpressionNode {
-  public:
-    FunctionCallBracketNode(ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args) KJS_FAST_CALL
-      : m_base(base), m_subscript(subscript), m_args(args) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecCall; }
-  protected:
-    RefPtr<ExpressionNode> m_base;
-    RefPtr<ExpressionNode> m_subscript;
-    RefPtr<ArgumentsNode> m_args;
-  };
-
-  class FunctionCallDotNode : public ExpressionNode {
-  public:
-    FunctionCallDotNode(ExpressionNode* base, const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
-      : m_base(base), m_ident(ident), m_args(args) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecCall; }
-  private:
-    ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-    RefPtr<ExpressionNode> m_base;
-    Identifier m_ident;
-    RefPtr<ArgumentsNode> m_args;
-  };
-
-  class PrePostResolveNode : public ExpressionNode {
-  public:
-    PrePostResolveNode(const Identifier& i) KJS_FAST_CALL : ExpressionNode(NumberType), m_ident(i) {}
-      
-    PrePostResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-        : ExpressionNode(PlacementNewAdopt)
-        , m_ident(PlacementNewAdopt)
-    {
-    }
-      
-  protected:
-      Identifier m_ident;
-      size_t m_index; // Used by LocalVarPostfixNode.      
-  };
-    
-  class PostIncResolveNode : public PrePostResolveNode {
-  public:
-    PostIncResolveNode(const Identifier& i) KJS_FAST_CALL : PrePostResolveNode(i) {}
-
-    PostIncResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-        : PrePostResolveNode(PlacementNewAdopt)
-    {
-    }
-
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPostfix; }
-    virtual void optimizeForUnnecessaryResult();
-  };
-
-  class PostIncLocalVarNode : public PostIncResolveNode {
-  public:
-    PostIncLocalVarNode(size_t i) KJS_FAST_CALL
-        : PostIncResolveNode(PlacementNewAdopt)
-    {
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void optimizeForUnnecessaryResult();
-  };
-
-  class PostIncConstNode : public PostIncResolveNode {
-  public:
-    PostIncConstNode(size_t i) KJS_FAST_CALL
-        : PostIncResolveNode(PlacementNewAdopt)
-    {
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-
-  class PostDecResolveNode : public PrePostResolveNode {
-  public:
-    PostDecResolveNode(const Identifier& i) KJS_FAST_CALL : PrePostResolveNode(i) {}
-
-    PostDecResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-        : PrePostResolveNode(PlacementNewAdopt)
-    {
-    }
-
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPostfix; }
-    virtual void optimizeForUnnecessaryResult();
-  };
-
-  class PostDecLocalVarNode : public PostDecResolveNode {
-  public:
-    PostDecLocalVarNode(size_t i) KJS_FAST_CALL
-        : PostDecResolveNode(PlacementNewAdopt)
-    {
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void optimizeForUnnecessaryResult();
-  private:
-    ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
-  };
-
-  class PostDecConstNode : public PostDecResolveNode {
-  public:
-    PostDecConstNode(size_t i) KJS_FAST_CALL
-        : PostDecResolveNode(PlacementNewAdopt)
-    {
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-
-  class PostfixBracketNode : public ExpressionNode {
-  public:
-    PostfixBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
-      : m_base(base), m_subscript(subscript) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPostfix; }
-  protected:
-    RefPtr<ExpressionNode> m_base;
-    RefPtr<ExpressionNode> m_subscript;
-  };
-
-  class PostIncBracketNode : public PostfixBracketNode {
-  public:
-    PostIncBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
-      : PostfixBracketNode(base, subscript) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  };
-
-  class PostDecBracketNode : public PostfixBracketNode {
-  public:
-    PostDecBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
-      : PostfixBracketNode(base, subscript) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  };
-
-    class PostfixDotNode : public ExpressionNode {
-  public:
-    PostfixDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
-      : m_base(base), m_ident(ident) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPostfix; }
-  protected:
-    RefPtr<ExpressionNode> m_base;
-    Identifier m_ident;
-  };
-
-  class PostIncDotNode : public PostfixDotNode {
-  public:
-    PostIncDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
-      : PostfixDotNode(base, ident) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  };
-
-  class PostDecDotNode : public PostfixDotNode {
-  public:
-    PostDecDotNode(ExpressionNode*  base, const Identifier& ident) KJS_FAST_CALL
-      : PostfixDotNode(base, ident) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  };
-
-  class PostfixErrorNode : public ExpressionNode {
-  public:
-    PostfixErrorNode(ExpressionNode* expr, Operator oper) KJS_FAST_CALL
-      : m_expr(expr), m_oper(oper) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPostfix; }
-  private:
-    RefPtr<ExpressionNode> m_expr;
-    Operator m_oper;
-  };
-
-  class DeleteResolveNode : public ExpressionNode {
-  public:
-    DeleteResolveNode(const Identifier& ident) KJS_FAST_CALL
-        : m_ident(ident)
-    {
-    }
-    DeleteResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-        : ExpressionNode(PlacementNewAdopt)
-        , m_ident(PlacementNewAdopt)
-    {
-    }
-
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    Identifier m_ident;
-  };
-
-  class LocalVarDeleteNode : public DeleteResolveNode {
-  public:
-    LocalVarDeleteNode() KJS_FAST_CALL
-        : DeleteResolveNode(PlacementNewAdopt)
-    {
-    }
-
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-
-  class DeleteBracketNode : public ExpressionNode {
-  public:
-    DeleteBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
-      : m_base(base), m_subscript(subscript) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    RefPtr<ExpressionNode> m_base;
-    RefPtr<ExpressionNode> m_subscript;
-  };
-
-  class DeleteDotNode : public ExpressionNode {
-  public:
-    DeleteDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
-      : m_base(base), m_ident(ident) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    RefPtr<ExpressionNode> m_base;
-    Identifier m_ident;
-  };
-
-  class DeleteValueNode : public ExpressionNode {
-  public:
-    DeleteValueNode(ExpressionNode* expr) KJS_FAST_CALL
-      : m_expr(expr) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class VoidNode : public ExpressionNode {
-  public:
-    VoidNode(ExpressionNode* expr) KJS_FAST_CALL
-      : m_expr(expr) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class TypeOfResolveNode : public ExpressionNode {
-  public:
-    TypeOfResolveNode(const Identifier& ident) KJS_FAST_CALL 
-        : ExpressionNode(StringType)
-        , m_ident(ident)
-    {
-    }
-    
-    TypeOfResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-        : ExpressionNode(PlacementNewAdopt)
-        , m_ident(PlacementNewAdopt) 
-    {
-        m_expectedReturnType = StringType;
-    }
-
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-
-    const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
-
-  protected:
-    Identifier m_ident;
-    size_t m_index; // Used by LocalTypeOfNode.
-  };
-    
-  class LocalVarTypeOfNode : public TypeOfResolveNode {
-  public:
-    LocalVarTypeOfNode(size_t i) KJS_FAST_CALL 
-        : TypeOfResolveNode(PlacementNewAdopt)
-    {
-        m_expectedReturnType = StringType;
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-
-  class TypeOfValueNode : public ExpressionNode {
-  public:
-    TypeOfValueNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(StringType), m_expr(e) {}
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class PreIncResolveNode : public PrePostResolveNode {
-  public:
-    PreIncResolveNode(const Identifier& ident) KJS_FAST_CALL 
-        : PrePostResolveNode(ident)
-    { 
-    }
-    
-    PreIncResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-        : PrePostResolveNode(PlacementNewAdopt)
-    {
-    }
-    
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  };
-
-  class PreIncLocalVarNode : public PreIncResolveNode {
-  public:
-    PreIncLocalVarNode(size_t i) KJS_FAST_CALL 
-        : PreIncResolveNode(PlacementNewAdopt)
-    { 
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-    
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-  
-  class PreIncConstNode : public PreIncResolveNode {
-  public:
-    PreIncConstNode(size_t i) KJS_FAST_CALL
-        : PreIncResolveNode(PlacementNewAdopt)
-    {
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-
-  class PreDecResolveNode : public PrePostResolveNode {
-  public:
-    PreDecResolveNode(const Identifier& ident) KJS_FAST_CALL 
-        : PrePostResolveNode(ident)
-    { 
-    }
-    
-    PreDecResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-        : PrePostResolveNode(PlacementNewAdopt)
-    {
-    }
-    
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  };
-
-  class PreDecLocalVarNode : public PreDecResolveNode {
-  public:
-    PreDecLocalVarNode(size_t i) KJS_FAST_CALL 
-        : PreDecResolveNode(PlacementNewAdopt)
-    { 
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-    
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-  
-  class PreDecConstNode : public PreDecResolveNode {
-  public:
-    PreDecConstNode(size_t i) KJS_FAST_CALL
-        : PreDecResolveNode(PlacementNewAdopt)
-    {
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-
-  class PrefixBracketNode : public ExpressionNode {
-  public:
-    PrefixBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
-      : m_base(base), m_subscript(subscript) { }
-
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  protected:
-    RefPtr<ExpressionNode> m_base;
-    RefPtr<ExpressionNode> m_subscript;
-  };
-  
-  class PreIncBracketNode : public PrefixBracketNode {
-  public:
-    PreIncBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
-      : PrefixBracketNode(base, subscript) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  };
-  
-  class PreDecBracketNode : public PrefixBracketNode {
-  public:
-    PreDecBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
-      : PrefixBracketNode(base, subscript) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  };
-
-  class PrefixDotNode : public ExpressionNode {
-  public:
-    PrefixDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
-      : m_base(base), m_ident(ident) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecPostfix; }
-  protected:
-    RefPtr<ExpressionNode> m_base;
-    Identifier m_ident;
-  };
-
-  class PreIncDotNode : public PrefixDotNode {
-  public:
-    PreIncDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
-      : PrefixDotNode(base, ident) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  };
-
-  class PreDecDotNode : public PrefixDotNode {
-  public:
-    PreDecDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
-      : PrefixDotNode(base, ident) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  };
-
-  class PrefixErrorNode : public ExpressionNode {
-  public:
-    PrefixErrorNode(ExpressionNode* expr, Operator oper) KJS_FAST_CALL
-      : m_expr(expr), m_oper(oper) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    RefPtr<ExpressionNode> m_expr;
-    Operator m_oper;
-  };
-
-  class UnaryPlusNode : public ExpressionNode {
-  public:
-    UnaryPlusNode(ExpressionNode* expr) KJS_FAST_CALL
-      : ExpressionNode(NumberType), m_expr(expr) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class NegateNode : public ExpressionNode {
-  public:
-    NegateNode(ExpressionNode* expr) KJS_FAST_CALL
-      : ExpressionNode(NumberType), m_expr(expr) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class BitwiseNotNode : public ExpressionNode {
-  public:
-    BitwiseNotNode(ExpressionNode* expr) KJS_FAST_CALL
-      : ExpressionNode(NumberType), m_expr(expr) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class LogicalNotNode : public ExpressionNode {
-  public:
-    LogicalNotNode(ExpressionNode* expr) KJS_FAST_CALL
-      : ExpressionNode(BooleanType), m_expr(expr) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecUnary; }
-  private:
-    RefPtr<ExpressionNode> m_expr;
-  };
-  
-  class MultNode : public ExpressionNode {
-  public:
-      MultNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-        : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
-      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-      virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-      virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-      virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-      virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-      virtual Precedence precedence() const { return PrecMultiplicitave; }
-  private:
-      ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
-      RefPtr<ExpressionNode> m_term1;
-      RefPtr<ExpressionNode> m_term2;
-  };
-  
-  class DivNode : public ExpressionNode {
-  public:
-      DivNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-        : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
-      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-      virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-      virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-      virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-      virtual Precedence precedence() const { return PrecMultiplicitave; }
-  private:
-      ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
-      RefPtr<ExpressionNode> m_term1;
-      RefPtr<ExpressionNode> m_term2;
-  };
-  
-  class ModNode : public ExpressionNode {
-  public:
-      ModNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-        : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
-      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-      virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-      virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-      virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-      virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-      virtual Precedence precedence() const { return PrecMultiplicitave; }
-  private:
-      ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
-      RefPtr<ExpressionNode> m_term1;
-      RefPtr<ExpressionNode> m_term2;
-  };
-
-  class AddNode : public ExpressionNode {
-  public:
-    AddNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-      : m_term1(term1), m_term2(term2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecAdditive; }
-  protected:
-    AddNode(ExpressionNode* term1, ExpressionNode* term2, JSType expectedReturn) KJS_FAST_CALL
-      : ExpressionNode(expectedReturn), m_term1(term1), m_term2(term2) { }
-    RefPtr<ExpressionNode> m_term1;
-    RefPtr<ExpressionNode> m_term2;
-  private:
-    ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
-  };
-
-    class AddNumbersNode : public AddNode {
-    public:
-        AddNumbersNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-          : AddNode(term1, term2, NumberType) { }
-        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class StatementNode : public Node {
+    public:
+        StatementNode() KJS_FAST_CALL;
+        void setLoc(int line0, int line1) KJS_FAST_CALL;
+        int firstLine() const KJS_FAST_CALL { return lineNo(); }
+        int lastLine() const KJS_FAST_CALL { return m_lastLine; }
+        virtual JSValue* execute(ExecState *exec) KJS_FAST_CALL = 0;
+        void pushLabel(const Identifier& ident) KJS_FAST_CALL { m_labelStack.push(ident); }
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+        virtual bool isEmptyStatement() const KJS_FAST_CALL { return false; }
+
+    protected:
+        LabelStack m_labelStack;
+
+    private:
+        int m_lastLine;
+    };
+
+    class NullNode : public ExpressionNode {
+    public:
+        NullNode() KJS_FAST_CALL : ExpressionNode(NullType) {}
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPrimary; }
+    };
+
+    class FalseNode : public ExpressionNode {
+    public:
+        FalseNode() KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL { return false; }
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPrimary; }
+    };
+
+    class TrueNode : public ExpressionNode {
+    public:
+        TrueNode() KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL { return true; }
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPrimary; }
+    };
+
+    class PlaceholderTrueNode : public TrueNode {
+    public:
+        // Like TrueNode, but does not serialize as "true".
+        PlaceholderTrueNode() KJS_FAST_CALL
+            : TrueNode()
+        {
+        }
+
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+    };
+
+    class NumberNode : public ExpressionNode {
+    public:
+        NumberNode(double v) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_double(v)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return signbit(m_double) ? PrecUnary : PrecPrimary; }
+
+        virtual bool isNumber() const KJS_FAST_CALL { return true; }
+        double value() const KJS_FAST_CALL { return m_double; }
+        virtual void setValue(double d) KJS_FAST_CALL { m_double = d; }
+
+    protected:
+        double m_double;
+    };
+
+    class ImmediateNumberNode : public NumberNode {
+    public:
+        ImmediateNumberNode(JSValue* v, double d) KJS_FAST_CALL
+            : NumberNode(d)
+            , m_value(v)
+        {
+            ASSERT(v == JSImmediate::from(d));
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+
+        virtual void setValue(double d) KJS_FAST_CALL { m_double = d; m_value = JSImmediate::from(d); ASSERT(m_value); }
+
+    private:
+        JSValue* m_value; // This is never a JSCell, only JSImmediate, thus no ProtectedPtr
+    };
+
+    class StringNode : public ExpressionNode {
+    public:
+        StringNode(const UString* v) KJS_FAST_CALL
+            : ExpressionNode(StringType)
+            , m_value(*v)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPrimary; }
+
+    private:
+        UString m_value;
+    };
+
+    class RegExpNode : public ExpressionNode {
+    public:
+        RegExpNode(const UString& pattern, const UString& flags) KJS_FAST_CALL
+            : m_regExp(new RegExp(pattern, flags))
+        {
+        }
+
+        JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPrimary; }
+
+    private:
+        RefPtr<RegExp> m_regExp;
+    };
+
+    class ThisNode : public ExpressionNode {
+    public:
+        ThisNode() KJS_FAST_CALL
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPrimary; }
+    };
+
+    class ResolveNode : public ExpressionNode {
+    public:
+        ResolveNode(const Identifier& ident) KJS_FAST_CALL
+            : m_ident(ident)
+        {
+        }
+
+        // Special constructor for cases where we overwrite an object in place.
+        ResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : ExpressionNode(PlacementNewAdopt)
+            , m_ident(PlacementNewAdopt)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
         virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
         virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
         virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPrimary; }
+
+        virtual bool isLocation() const KJS_FAST_CALL { return true; }
+        virtual bool isResolveNode() const KJS_FAST_CALL { return true; }
+        const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
+
+    protected:
+        ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
+        Identifier m_ident;
+        size_t m_index; // Used by LocalVarAccessNode.
+    };
+
+    class LocalVarAccessNode : public ResolveNode {
+    public:
+        // Overwrites a ResolveNode in place.
+        LocalVarAccessNode(size_t i) KJS_FAST_CALL
+            : ResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+
+    private:
+        ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
+    };
+
+    class ElementNode : public Node {
+    public:
+        ElementNode(int elision, ExpressionNode* node) KJS_FAST_CALL
+            : m_elision(elision)
+            , m_node(node)
+        {
+        }
+
+        ElementNode(ElementNode* l, int elision, ExpressionNode* node) KJS_FAST_CALL
+            : m_elision(elision)
+            , m_node(node)
+        {
+            l->m_next = this;
+        }
+
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+
+        PassRefPtr<ElementNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
+
+        JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+
+    private:
+        friend class ArrayNode;
+        ListRefPtr<ElementNode> m_next;
+        int m_elision;
+        RefPtr<ExpressionNode> m_node;
+    };
+
+    class ArrayNode : public ExpressionNode {
+    public:
+        ArrayNode(int elision) KJS_FAST_CALL
+            : m_elision(elision)
+            , m_optional(true)
+        {
+        }
+
+        ArrayNode(ElementNode* element) KJS_FAST_CALL
+            : m_element(element)
+            , m_elision(0)
+            , m_optional(false)
+        {
+        }
+
+        ArrayNode(int elision, ElementNode* element) KJS_FAST_CALL
+            : m_element(element)
+            , m_elision(elision)
+            , m_optional(true)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPrimary; }
+
+    private:
+        RefPtr<ElementNode> m_element;
+        int m_elision;
+        bool m_optional;
+    };
+
+    class PropertyNode : public Node {
+    public:
+        enum Type { Constant, Getter, Setter };
+
+        PropertyNode(const Identifier& name, ExpressionNode* assign, Type type) KJS_FAST_CALL
+            : m_name(name)
+            , m_assign(assign)
+            , m_type(type)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+
+        JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        const Identifier& name() const { return m_name; }
+
+    private:
+        friend class PropertyListNode;
+        Identifier m_name;
+        RefPtr<ExpressionNode> m_assign;
+        Type m_type;
+    };
+
+    class PropertyListNode : public Node {
+    public:
+        PropertyListNode(PropertyNode* node) KJS_FAST_CALL
+            : m_node(node)
+        {
+        }
+
+        PropertyListNode(PropertyNode* node, PropertyListNode* list) KJS_FAST_CALL
+            : m_node(node)
+        {
+            list->m_next = this;
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+
+        JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        PassRefPtr<PropertyListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
+
+    private:
+        friend class ObjectLiteralNode;
+        RefPtr<PropertyNode> m_node;
+        ListRefPtr<PropertyListNode> m_next;
+    };
+
+    class ObjectLiteralNode : public ExpressionNode {
+    public:
+        ObjectLiteralNode() KJS_FAST_CALL
+        {
+        }
+
+        ObjectLiteralNode(PropertyListNode* list) KJS_FAST_CALL
+            : m_list(list)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPrimary; }
+        virtual bool needsParensIfLeftmost() const { return true; }
+
+    private:
+        RefPtr<PropertyListNode> m_list;
+    };
+
+    class BracketAccessorNode : public ExpressionNode {
+    public:
+        BracketAccessorNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
+            : m_base(base)
+            , m_subscript(subscript)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecMember; }
+
+        virtual bool isLocation() const KJS_FAST_CALL { return true; }
+        virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return true; }
+        ExpressionNode* base() KJS_FAST_CALL { return m_base.get(); }
+        ExpressionNode* subscript() KJS_FAST_CALL { return m_subscript.get(); }
+
+    private:
+        ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
+
+        RefPtr<ExpressionNode> m_base;
+        RefPtr<ExpressionNode> m_subscript;
+    };
+
+    class DotAccessorNode : public ExpressionNode {
+    public:
+        DotAccessorNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
+            : m_base(base)
+            , m_ident(ident)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecMember; }
+
+        virtual bool isLocation() const KJS_FAST_CALL { return true; }
+        virtual bool isDotAccessorNode() const KJS_FAST_CALL { return true; }
+        ExpressionNode* base() const KJS_FAST_CALL { return m_base.get(); }
+        const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
+
+    private:
+        ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
+
+        RefPtr<ExpressionNode> m_base;
+        Identifier m_ident;
+    };
+
+    class ArgumentListNode : public Node {
+    public:
+        ArgumentListNode(ExpressionNode* expr) KJS_FAST_CALL
+            : m_expr(expr)
+        {
+        }
+
+        ArgumentListNode(ArgumentListNode* listNode, ExpressionNode* expr) KJS_FAST_CALL
+            : m_expr(expr)
+        {
+            listNode->m_next = this;
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+
+        void evaluateList(ExecState*, List&) KJS_FAST_CALL;
+        PassRefPtr<ArgumentListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
+
+    private:
+        friend class ArgumentsNode;
+        ListRefPtr<ArgumentListNode> m_next;
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class ArgumentsNode : public Node {
+    public:
+        ArgumentsNode() KJS_FAST_CALL
+        {
+        }
+
+        ArgumentsNode(ArgumentListNode* listNode) KJS_FAST_CALL
+            : m_listNode(listNode)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+
+        void evaluateList(ExecState* exec, List& list) KJS_FAST_CALL { if (m_listNode) m_listNode->evaluateList(exec, list); }
+
+    private:
+        RefPtr<ArgumentListNode> m_listNode;
+    };
+
+    class NewExprNode : public ExpressionNode {
+    public:
+        NewExprNode(ExpressionNode* expr) KJS_FAST_CALL
+            : m_expr(expr)
+        {
+        }
+
+        NewExprNode(ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL
+            : m_expr(expr)
+            , m_args(args)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecLeftHandSide; }
+
+    private:
+        ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr;
+        RefPtr<ArgumentsNode> m_args;
+    };
+
+    class FunctionCallValueNode : public ExpressionNode {
+    public:
+        FunctionCallValueNode(ExpressionNode* expr, ArgumentsNode* args) KJS_FAST_CALL
+            : m_expr(expr)
+            , m_args(args)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecCall; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+        RefPtr<ArgumentsNode> m_args;
+    };
+
+    class FunctionCallResolveNode : public ExpressionNode {
+    public:
+        FunctionCallResolveNode(const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
+            : m_ident(ident)
+            , m_args(args)
+        {
+        }
+
+        FunctionCallResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : ExpressionNode(PlacementNewAdopt)
+            , m_ident(PlacementNewAdopt)
+            , m_args(PlacementNewAdopt)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecCall; }
+
+    protected:
+        ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
+
+        Identifier m_ident;
+        RefPtr<ArgumentsNode> m_args;
+        size_t m_index; // Used by LocalVarFunctionCallNode.
+    };
+
+    class LocalVarFunctionCallNode : public FunctionCallResolveNode {
+    public:
+        LocalVarFunctionCallNode(size_t i) KJS_FAST_CALL
+            : FunctionCallResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+
+    private:
+        ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
+    };
+
+    class FunctionCallBracketNode : public ExpressionNode {
+    public:
+        FunctionCallBracketNode(ExpressionNode* base, ExpressionNode* subscript, ArgumentsNode* args) KJS_FAST_CALL
+            : m_base(base)
+            , m_subscript(subscript)
+            , m_args(args)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecCall; }
+
+    protected:
+        RefPtr<ExpressionNode> m_base;
+        RefPtr<ExpressionNode> m_subscript;
+        RefPtr<ArgumentsNode> m_args;
+    };
+
+    class FunctionCallDotNode : public ExpressionNode {
+    public:
+        FunctionCallDotNode(ExpressionNode* base, const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
+            : m_base(base)
+            , m_ident(ident)
+            , m_args(args)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecCall; }
+
+    private:
+        ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
+
+        RefPtr<ExpressionNode> m_base;
+        Identifier m_ident;
+        RefPtr<ArgumentsNode> m_args;
+    };
+
+    class PrePostResolveNode : public ExpressionNode {
+    public:
+        PrePostResolveNode(const Identifier& ident) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_ident(ident)
+        {
+        }
+
+        PrePostResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : ExpressionNode(PlacementNewAdopt)
+            , m_ident(PlacementNewAdopt)
+        {
+        }
+
+    protected:
+        Identifier m_ident;
+        size_t m_index; // Used by LocalVarPostfixNode.
+    };
+
+    class PostIncResolveNode : public PrePostResolveNode {
+    public:
+        PostIncResolveNode(const Identifier& ident) KJS_FAST_CALL
+            : PrePostResolveNode(ident)
+        {
+        }
+
+        PostIncResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : PrePostResolveNode(PlacementNewAdopt)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPostfix; }
+        virtual void optimizeForUnnecessaryResult();
+    };
+
+    class PostIncLocalVarNode : public PostIncResolveNode {
+    public:
+        PostIncLocalVarNode(size_t i) KJS_FAST_CALL
+            : PostIncResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void optimizeForUnnecessaryResult();
+    };
+
+    class PostIncConstNode : public PostIncResolveNode {
+    public:
+        PostIncConstNode(size_t i) KJS_FAST_CALL
+            : PostIncResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class PostDecResolveNode : public PrePostResolveNode {
+    public:
+        PostDecResolveNode(const Identifier& ident) KJS_FAST_CALL
+            : PrePostResolveNode(ident)
+        {
+        }
+
+        PostDecResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : PrePostResolveNode(PlacementNewAdopt)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPostfix; }
+        virtual void optimizeForUnnecessaryResult();
+    };
+
+    class PostDecLocalVarNode : public PostDecResolveNode {
+    public:
+        PostDecLocalVarNode(size_t i) KJS_FAST_CALL
+            : PostDecResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void optimizeForUnnecessaryResult();
+
+    private:
+        ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
+    };
+
+    class PostDecConstNode : public PostDecResolveNode {
+    public:
+        PostDecConstNode(size_t i) KJS_FAST_CALL
+            : PostDecResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class PostfixBracketNode : public ExpressionNode {
+    public:
+        PostfixBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
+            : m_base(base)
+            , m_subscript(subscript)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPostfix; }
+
+    protected:
+        RefPtr<ExpressionNode> m_base;
+        RefPtr<ExpressionNode> m_subscript;
+    };
+
+    class PostIncBracketNode : public PostfixBracketNode {
+    public:
+        PostIncBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
+            : PostfixBracketNode(base, subscript)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+    };
+
+    class PostDecBracketNode : public PostfixBracketNode {
+    public:
+        PostDecBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
+            : PostfixBracketNode(base, subscript)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+    };
+
+    class PostfixDotNode : public ExpressionNode {
+    public:
+        PostfixDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
+            : m_base(base)
+            , m_ident(ident)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPostfix; }
+
+    protected:
+        RefPtr<ExpressionNode> m_base;
+        Identifier m_ident;
+    };
+
+    class PostIncDotNode : public PostfixDotNode {
+    public:
+        PostIncDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
+            : PostfixDotNode(base, ident)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+    };
+
+    class PostDecDotNode : public PostfixDotNode {
+    public:
+        PostDecDotNode(ExpressionNode*  base, const Identifier& ident) KJS_FAST_CALL
+            : PostfixDotNode(base, ident)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+    };
+
+    class PostfixErrorNode : public ExpressionNode {
+    public:
+        PostfixErrorNode(ExpressionNode* expr, Operator oper) KJS_FAST_CALL
+            : m_expr(expr)
+            , m_operator(oper)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPostfix; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+        Operator m_operator;
+    };
+
+    class DeleteResolveNode : public ExpressionNode {
+    public:
+        DeleteResolveNode(const Identifier& ident) KJS_FAST_CALL
+            : m_ident(ident)
+        {
+        }
+
+        DeleteResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : ExpressionNode(PlacementNewAdopt)
+            , m_ident(PlacementNewAdopt)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        Identifier m_ident;
+    };
+
+    class LocalVarDeleteNode : public DeleteResolveNode {
+    public:
+        LocalVarDeleteNode() KJS_FAST_CALL
+            : DeleteResolveNode(PlacementNewAdopt)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class DeleteBracketNode : public ExpressionNode {
+    public:
+        DeleteBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
+            : m_base(base)
+            , m_subscript(subscript)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        RefPtr<ExpressionNode> m_base;
+        RefPtr<ExpressionNode> m_subscript;
+    };
+
+    class DeleteDotNode : public ExpressionNode {
+    public:
+        DeleteDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
+            : m_base(base)
+            , m_ident(ident)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        RefPtr<ExpressionNode> m_base;
+        Identifier m_ident;
+    };
+
+    class DeleteValueNode : public ExpressionNode {
+    public:
+        DeleteValueNode(ExpressionNode* expr) KJS_FAST_CALL
+            : m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class VoidNode : public ExpressionNode {
+    public:
+        VoidNode(ExpressionNode* expr) KJS_FAST_CALL
+            : m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class TypeOfResolveNode : public ExpressionNode {
+    public:
+        TypeOfResolveNode(const Identifier& ident) KJS_FAST_CALL
+            : ExpressionNode(StringType)
+            , m_ident(ident)
+        {
+        }
+
+        TypeOfResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : ExpressionNode(PlacementNewAdopt)
+            , m_ident(PlacementNewAdopt)
+        {
+            m_expectedReturnType = StringType;
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+        const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
+
+    protected:
+        Identifier m_ident;
+        size_t m_index; // Used by LocalTypeOfNode.
+    };
+
+    class LocalVarTypeOfNode : public TypeOfResolveNode {
+    public:
+        LocalVarTypeOfNode(size_t i) KJS_FAST_CALL
+            : TypeOfResolveNode(PlacementNewAdopt)
+        {
+            m_expectedReturnType = StringType;
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class TypeOfValueNode : public ExpressionNode {
+    public:
+        TypeOfValueNode(ExpressionNode* expr) KJS_FAST_CALL
+            : ExpressionNode(StringType)
+            , m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class PreIncResolveNode : public PrePostResolveNode {
+    public:
+        PreIncResolveNode(const Identifier& ident) KJS_FAST_CALL
+            : PrePostResolveNode(ident)
+        {
+        }
+
+        PreIncResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : PrePostResolveNode(PlacementNewAdopt)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+    };
+
+    class PreIncLocalVarNode : public PreIncResolveNode {
+    public:
+        PreIncLocalVarNode(size_t i) KJS_FAST_CALL
+            : PreIncResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class PreIncConstNode : public PreIncResolveNode {
+    public:
+        PreIncConstNode(size_t i) KJS_FAST_CALL
+            : PreIncResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class PreDecResolveNode : public PrePostResolveNode {
+    public:
+        PreDecResolveNode(const Identifier& ident) KJS_FAST_CALL
+            : PrePostResolveNode(ident)
+        {
+        }
+
+        PreDecResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : PrePostResolveNode(PlacementNewAdopt)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+    };
+
+    class PreDecLocalVarNode : public PreDecResolveNode {
+    public:
+        PreDecLocalVarNode(size_t i) KJS_FAST_CALL
+            : PreDecResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class PreDecConstNode : public PreDecResolveNode {
+    public:
+        PreDecConstNode(size_t i) KJS_FAST_CALL
+            : PreDecResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class PrefixBracketNode : public ExpressionNode {
+    public:
+        PrefixBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
+            : m_base(base)
+            , m_subscript(subscript)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    protected:
+        RefPtr<ExpressionNode> m_base;
+        RefPtr<ExpressionNode> m_subscript;
+    };
+
+    class PreIncBracketNode : public PrefixBracketNode {
+    public:
+        PreIncBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
+            : PrefixBracketNode(base, subscript)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+    };
+
+    class PreDecBracketNode : public PrefixBracketNode {
+    public:
+        PreDecBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL
+            : PrefixBracketNode(base, subscript)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+    };
+
+    class PrefixDotNode : public ExpressionNode {
+    public:
+        PrefixDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
+            : m_base(base)
+            , m_ident(ident)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecPostfix; }
+
+    protected:
+        RefPtr<ExpressionNode> m_base;
+        Identifier m_ident;
+    };
+
+    class PreIncDotNode : public PrefixDotNode {
+    public:
+        PreIncDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
+            : PrefixDotNode(base, ident)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+    };
+
+    class PreDecDotNode : public PrefixDotNode {
+    public:
+        PreDecDotNode(ExpressionNode* base, const Identifier& ident) KJS_FAST_CALL
+            : PrefixDotNode(base, ident)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+    };
+
+    class PrefixErrorNode : public ExpressionNode {
+    public:
+        PrefixErrorNode(ExpressionNode* expr, Operator oper) KJS_FAST_CALL
+            : m_expr(expr)
+            , m_operator(oper)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+        Operator m_operator;
+    };
+
+    class UnaryPlusNode : public ExpressionNode {
+    public:
+        UnaryPlusNode(ExpressionNode* expr) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class NegateNode : public ExpressionNode {
+    public:
+        NegateNode(ExpressionNode* expr) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class BitwiseNotNode : public ExpressionNode {
+    public:
+        BitwiseNotNode(ExpressionNode* expr) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class LogicalNotNode : public ExpressionNode {
+    public:
+        LogicalNotNode(ExpressionNode* expr) KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+            , m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecUnary; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class MultNode : public ExpressionNode {
+    public:
+        MultNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_term1(term1)
+            , m_term2(term2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecMultiplicitave; }
+
+    private:
+        ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
+
+        RefPtr<ExpressionNode> m_term1;
+        RefPtr<ExpressionNode> m_term2;
+    };
+
+    class DivNode : public ExpressionNode {
+    public:
+        DivNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_term1(term1)
+            , m_term2(term2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecMultiplicitave; }
+
+    private:
+        ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
+
+        RefPtr<ExpressionNode> m_term1;
+        RefPtr<ExpressionNode> m_term2;
+    };
+
+    class ModNode : public ExpressionNode {
+    public:
+        ModNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_term1(term1)
+            , m_term2(term2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecMultiplicitave; }
+
+    private:
+        ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
+
+        RefPtr<ExpressionNode> m_term1;
+        RefPtr<ExpressionNode> m_term2;
+    };
+
+    class AddNode : public ExpressionNode {
+    public:
+        AddNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+            : m_term1(term1)
+            , m_term2(term2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecAdditive; }
+
+    protected:
+        AddNode(ExpressionNode* term1, ExpressionNode* term2, JSType expectedReturn) KJS_FAST_CALL
+            : ExpressionNode(expectedReturn)
+            , m_term1(term1)
+            , m_term2(term2)
+        {
+        }
+
+        RefPtr<ExpressionNode> m_term1;
+        RefPtr<ExpressionNode> m_term2;
+
+    private:
+        ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
+    };
+
+    class AddNumbersNode : public AddNode {
+    public:
+        AddNumbersNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+            : AddNode(term1, term2, NumberType)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+
     private:
         ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*) KJS_FAST_CALL;
@@ -1249 +1544 @@
     public:
         AddStringLeftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-          : AddNode(term1, term2, StringType) { }
+            : AddNode(term1, term2, StringType)
+        {
+        }
+
         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     };
@@ -1256 +1554 @@
     public:
         AddStringRightNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-          : AddNode(term1, term2, StringType) { }
+            : AddNode(term1, term2, StringType)
+        {
+        }
+
         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     };
@@ -1263 +1564 @@
     public:
         AddStringsNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-          : AddNode(term1, term2, StringType) { }
-        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    };
-
-  class SubNode : public ExpressionNode {
-  public:
-      SubNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-        : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
-      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-      virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-      virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-      virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-      virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-      virtual Precedence precedence() const { return PrecAdditive; }
-  private:
-      ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
-      RefPtr<ExpressionNode> m_term1;
-      RefPtr<ExpressionNode> m_term2;
-  };
-
-  class LeftShiftNode : public ExpressionNode {
-  public:
-    LeftShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-      : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecShift; }
-  private:
-    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> m_term1;
-    RefPtr<ExpressionNode> m_term2;
-  };
-
-  class RightShiftNode : public ExpressionNode {
-  public:
-    RightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-      : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecShift; }
-  private:
-    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> m_term1;
-    RefPtr<ExpressionNode> m_term2;
-  };
-
-  class UnsignedRightShiftNode : public ExpressionNode {
-  public:
-    UnsignedRightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
-      : ExpressionNode(NumberType), m_term1(term1), m_term2(term2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecShift; }
-  private:
-    ALWAYS_INLINE uint32_t inlineEvaluateToUInt32(ExecState*);
-    RefPtr<ExpressionNode> m_term1;
-    RefPtr<ExpressionNode> m_term2;
-  };
-
-  class LessNode : public ExpressionNode {
-  public:
-    LessNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-      : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) {}
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecRelational; }
-  private:
-    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-  protected:
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
+            : AddNode(term1, term2, StringType)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class SubNode : public ExpressionNode {
+    public:
+        SubNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_term1(term1)
+            , m_term2(term2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecAdditive; }
+
+    private:
+        ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
+
+        RefPtr<ExpressionNode> m_term1;
+        RefPtr<ExpressionNode> m_term2;
+    };
+
+    class LeftShiftNode : public ExpressionNode {
+    public:
+        LeftShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_term1(term1)
+            , m_term2(term2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecShift; }
+
+    private:
+        ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
+
+        RefPtr<ExpressionNode> m_term1;
+        RefPtr<ExpressionNode> m_term2;
+    };
+
+    class RightShiftNode : public ExpressionNode {
+    public:
+        RightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_term1(term1)
+            , m_term2(term2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecShift; }
+
+    private:
+        ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
+
+        RefPtr<ExpressionNode> m_term1;
+        RefPtr<ExpressionNode> m_term2;
+    };
+
+    class UnsignedRightShiftNode : public ExpressionNode {
+    public:
+        UnsignedRightShiftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_term1(term1)
+            , m_term2(term2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecShift; }
+    private:
+        ALWAYS_INLINE uint32_t inlineEvaluateToUInt32(ExecState*);
+
+        RefPtr<ExpressionNode> m_term1;
+        RefPtr<ExpressionNode> m_term2;
+    };
+
+    class LessNode : public ExpressionNode {
+    public:
+        LessNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecRelational; }
+
+    private:
+        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
+
+    protected:
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
 
     class LessNumbersNode : public LessNode {
     public:
         LessNumbersNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-            : LessNode(expr1, expr2) { }
-        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+            : LessNode(expr1, expr2)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+
     private:
         ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
@@ -1364 +1706 @@
     public:
         LessStringsNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-            : LessNode(expr1, expr2) { }
-        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+            : LessNode(expr1, expr2)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+
     private:
         ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
     };
 
-  class GreaterNode : public ExpressionNode {
-  public:
-    GreaterNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
-      m_expr1(e1), m_expr2(e2) {}
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecRelational; }
-  private:
-    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
-
-  class LessEqNode : public ExpressionNode {
-  public:
-    LessEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-      : m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecRelational; }
-  private:
-    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
-
-  class GreaterEqNode : public ExpressionNode {
-  public:
-    GreaterEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-      : m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecRelational; }
-  private:
-    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
+    class GreaterNode : public ExpressionNode {
+    public:
+        GreaterNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecRelational; }
+
+    private:
+        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
+
+    class LessEqNode : public ExpressionNode {
+    public:
+        LessEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecRelational; }
+
+    private:
+        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
+
+    class GreaterEqNode : public ExpressionNode {
+    public:
+        GreaterEqNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecRelational; }
+
+    private:
+        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
 
     class InstanceOfNode : public ExpressionNode {
-  public:
-    InstanceOfNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecRelational; }
-  private:
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
+    public:
+        InstanceOfNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecRelational; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
 
     class InNode : public ExpressionNode {
-  public:
-    InNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-      : m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecRelational; }
-  private:
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
+    public:
+        InNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecRelational; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
 
     class EqualNode : public ExpressionNode {
-  public:
-    EqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecEquality; }
-  private:
-    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
+    public:
+        EqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecEquality; }
+
+    private:
+        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
 
     class NotEqualNode : public ExpressionNode {
-  public:
-    NotEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecEquality; }
-  private:
-    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
+    public:
+        NotEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecEquality; }
+
+    private:
+        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
 
     class StrictEqualNode : public ExpressionNode {
-  public:
-    StrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecEquality; }
-  private:
-    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
+    public:
+        StrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecEquality; }
+
+    private:
+        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
 
     class NotStrictEqualNode : public ExpressionNode {
-  public:
-    NotStrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecEquality; }
-  private:
-    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
+    public:
+        NotStrictEqualNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecEquality; }
+
+    private:
+        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
 
     class BitAndNode : public ExpressionNode {
-  public:
-    BitAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : ExpressionNode(NumberType), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecBitwiseAnd; }
-  private:
-    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
+    public:
+        BitAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecBitwiseAnd; }
+
+    private:
+        ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
 
     class BitOrNode : public ExpressionNode {
-  public:
-    BitOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : ExpressionNode(NumberType), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecBitwiseOr; }
-  private:
-    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
-
-  class BitXOrNode : public ExpressionNode {
-  public:
-    BitXOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : ExpressionNode(NumberType), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecBitwiseXor; }
-  private:
-    ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
-
-  /**
-   * m_expr1 && m_expr2, m_expr1 || m_expr2
-   */
+    public:
+        BitOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecBitwiseOr; }
+
+    private:
+        ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
+
+    class BitXOrNode : public ExpressionNode {
+    public:
+        BitXOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(NumberType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecBitwiseXor; }
+
+    private:
+        ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
+
+    /**
+     * m_expr1 && m_expr2, m_expr1 || m_expr2
+     */
     class LogicalAndNode : public ExpressionNode {
-  public:
-    LogicalAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecLogicalAnd; }
-  private:
-    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
-  
+    public:
+        LogicalAndNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecLogicalAnd; }
+
+    private:
+        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
+
     class LogicalOrNode : public ExpressionNode {
-  public:
-    LogicalOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecLogicalOr; }
-  private:
-    ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
-
-  /**
-   * The ternary operator, "m_logical ? m_expr1 : m_expr2"
-   */
-  class ConditionalNode : public ExpressionNode {
-  public:
-    ConditionalNode(ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-      : m_logical(logical), m_expr1(expr1), m_expr2(expr2) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
-    virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
-    virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
-    virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecConditional; }
-  private:
-    RefPtr<ExpressionNode> m_logical;
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
-
-  class ReadModifyResolveNode : public ExpressionNode {
-  public:
-    ReadModifyResolveNode(const Identifier& ident, Operator oper, ExpressionNode*  right) KJS_FAST_CALL
-      : m_ident(ident)
-      , m_oper(oper)
-      , m_right(right) 
+    public:
+        LogicalOrNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : ExpressionNode(BooleanType)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecLogicalOr; }
+
+    private:
+        ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
+
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
+
+    /**
+     * The ternary operator, "m_logical ? m_expr1 : m_expr2"
+     */
+    class ConditionalNode : public ExpressionNode {
+    public:
+        ConditionalNode(ExpressionNode* logical, ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : m_logical(logical)
+            , m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual bool evaluateToBoolean(ExecState*) KJS_FAST_CALL;
+        virtual double evaluateToNumber(ExecState*) KJS_FAST_CALL;
+        virtual int32_t evaluateToInt32(ExecState*) KJS_FAST_CALL;
+        virtual uint32_t evaluateToUInt32(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecConditional; }
+
+    private:
+        RefPtr<ExpressionNode> m_logical;
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
+
+    class ReadModifyResolveNode : public ExpressionNode {
+    public:
+        ReadModifyResolveNode(const Identifier& ident, Operator oper, ExpressionNode*  right) KJS_FAST_CALL
+            : m_ident(ident)
+            , m_operator(oper)
+            , m_right(right)
+        {
+        }
+
+        ReadModifyResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : ExpressionNode(PlacementNewAdopt)
+            , m_ident(PlacementNewAdopt)
+            , m_right(PlacementNewAdopt)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecAssignment; }
+
+    protected:
+        Identifier m_ident;
+        Operator m_operator;
+        RefPtr<ExpressionNode> m_right;
+        size_t m_index; // Used by ReadModifyLocalVarNode.
+    };
+
+    class ReadModifyLocalVarNode : public ReadModifyResolveNode {
+    public:
+        ReadModifyLocalVarNode(size_t i) KJS_FAST_CALL
+            : ReadModifyResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class ReadModifyConstNode : public ReadModifyResolveNode {
+    public:
+        ReadModifyConstNode(size_t i) KJS_FAST_CALL
+            : ReadModifyResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class AssignResolveNode : public ExpressionNode {
+    public:
+        AssignResolveNode(const Identifier& ident, ExpressionNode* right) KJS_FAST_CALL
+            : m_ident(ident)
+            , m_right(right)
+        {
+        }
+
+        AssignResolveNode(PlacementNewAdoptType) KJS_FAST_CALL
+            : ExpressionNode(PlacementNewAdopt)
+            , m_ident(PlacementNewAdopt)
+            , m_right(PlacementNewAdopt)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecAssignment; }
+
+    protected:
+        Identifier m_ident;
+        RefPtr<ExpressionNode> m_right;
+        size_t m_index; // Used by ReadModifyLocalVarNode.
+    };
+
+    class AssignLocalVarNode : public AssignResolveNode {
+    public:
+        AssignLocalVarNode(size_t i) KJS_FAST_CALL
+            : AssignResolveNode(PlacementNewAdopt)
+        {
+            ASSERT(i != missingSymbolMarker());
+            m_index = i;
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class AssignConstNode : public AssignResolveNode {
+    public:
+        AssignConstNode() KJS_FAST_CALL
+            : AssignResolveNode(PlacementNewAdopt)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+    };
+
+    class ReadModifyBracketNode : public ExpressionNode {
+    public:
+        ReadModifyBracketNode(ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right) KJS_FAST_CALL
+            : m_base(base)
+            , m_subscript(subscript)
+            , m_operator(oper)
+            , m_right(right)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecAssignment; }
+
+    protected:
+        RefPtr<ExpressionNode> m_base;
+        RefPtr<ExpressionNode> m_subscript;
+        Operator m_operator;
+        RefPtr<ExpressionNode> m_right;
+    };
+
+    class AssignBracketNode : public ExpressionNode {
+    public:
+        AssignBracketNode(ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right) KJS_FAST_CALL
+            : m_base(base)
+            , m_subscript(subscript)
+            , m_right(right)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecAssignment; }
+
+    protected:
+        RefPtr<ExpressionNode> m_base;
+        RefPtr<ExpressionNode> m_subscript;
+        RefPtr<ExpressionNode> m_right;
+    };
+
+    class AssignDotNode : public ExpressionNode {
+    public:
+        AssignDotNode(ExpressionNode* base, const Identifier& ident, ExpressionNode* right) KJS_FAST_CALL
+            : m_base(base)
+            , m_ident(ident)
+            , m_right(right)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecAssignment; }
+
+    protected:
+        RefPtr<ExpressionNode> m_base;
+        Identifier m_ident;
+        RefPtr<ExpressionNode> m_right;
+    };
+
+    class ReadModifyDotNode : public ExpressionNode {
+    public:
+        ReadModifyDotNode(ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right) KJS_FAST_CALL
+            : m_base(base)
+            , m_ident(ident)
+            , m_operator(oper)
+            , m_right(right)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecAssignment; }
+
+    protected:
+        RefPtr<ExpressionNode> m_base;
+        Identifier m_ident;
+        Operator m_operator;
+        RefPtr<ExpressionNode> m_right;
+    };
+
+    class AssignErrorNode : public ExpressionNode {
+    public:
+        AssignErrorNode(ExpressionNode* left, Operator oper, ExpressionNode* right) KJS_FAST_CALL
+            : m_left(left)
+            , m_operator(oper)
+            , m_right(right)
+        {
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecAssignment; }
+
+    protected:
+        RefPtr<ExpressionNode> m_left;
+        Operator m_operator;
+        RefPtr<ExpressionNode> m_right;
+    };
+
+    class CommaNode : public ExpressionNode {
+    public:
+        CommaNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
+            : m_expr1(expr1)
+            , m_expr2(expr2)
+        {
+            m_expr1->optimizeForUnnecessaryResult();
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecExpression; }
+
+    private:
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+    };
+
+    class ConstDeclNode : public ExpressionNode {
+    public:
+        ConstDeclNode(const Identifier& ident, ExpressionNode* in) KJS_FAST_CALL;
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual KJS::JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        void evaluateSingle(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+        PassRefPtr<ConstDeclNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
+
+        Identifier m_ident;
+        ListRefPtr<ConstDeclNode> m_next;
+        RefPtr<ExpressionNode> m_init;
+
+    private:
+        void handleSlowCase(ExecState*, const ScopeChain&, JSValue*) KJS_FAST_CALL NEVER_INLINE;
+    };
+
+    class ConstStatementNode : public StatementNode {
+    public:
+        ConstStatementNode(ConstDeclNode* next) KJS_FAST_CALL
+            : m_next(next)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<ConstDeclNode> m_next;
+    };
+
+    typedef Vector<RefPtr<StatementNode> > StatementVector;
+
+    class SourceElements : public ParserRefCounted {
+    public:
+        void append(PassRefPtr<StatementNode>);
+        void releaseContentsIntoVector(StatementVector& destination)
+        {
+            ASSERT(destination.isEmpty());
+            m_statements.swap(destination);
+        }
+
+    private:
+        StatementVector m_statements;
+    };
+
+    class BlockNode : public StatementNode {
+    public:
+        BlockNode(SourceElements* children) KJS_FAST_CALL;
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    protected:
+        StatementVector m_children;
+    };
+
+    class EmptyStatementNode : public StatementNode {
+    public:
+        EmptyStatementNode() KJS_FAST_CALL // debug
+        {
+        }
+
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual bool isEmptyStatement() const KJS_FAST_CALL { return true; }
+    };
+
+    class ExprStatementNode : public StatementNode {
+    public:
+        ExprStatementNode(ExpressionNode* expr) KJS_FAST_CALL
+            : m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class VarStatementNode : public StatementNode {
+    public:
+        VarStatementNode(ExpressionNode* expr) KJS_FAST_CALL
+            : m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class IfNode : public StatementNode {
+    public:
+        IfNode(ExpressionNode* condition, StatementNode* ifBlock) KJS_FAST_CALL
+            : m_condition(condition)
+            , m_ifBlock(ifBlock)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    protected:
+        RefPtr<ExpressionNode> m_condition;
+        RefPtr<StatementNode> m_ifBlock;
+    };
+
+    class IfElseNode : public IfNode {
+    public:
+        IfElseNode(ExpressionNode* condtion, StatementNode* ifBlock, StatementNode* elseBlock) KJS_FAST_CALL
+            : IfNode(condtion, ifBlock)
+            , m_elseBlock(elseBlock)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<StatementNode> m_elseBlock;
+    };
+
+    class DoWhileNode : public StatementNode {
+    public:
+        DoWhileNode(StatementNode* statement, ExpressionNode* expr) KJS_FAST_CALL
+            : m_statement(statement)
+            , m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<StatementNode> m_statement;
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class WhileNode : public StatementNode {
+    public:
+        WhileNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
+            : m_expr(expr)
+            , m_statement(statement)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+        RefPtr<StatementNode> m_statement;
+    };
+
+    class ForNode : public StatementNode {
+    public:
+        ForNode(ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl) KJS_FAST_CALL
+            : m_expr1(expr1 ? expr1 : new PlaceholderTrueNode)
+            , m_expr2(expr2 ? expr2 : new PlaceholderTrueNode)
+            , m_expr3(expr3 ? expr3 : new PlaceholderTrueNode)
+            , m_statement(statement)
+            , m_expr1WasVarDecl(expr1 && expr1WasVarDecl)
+        {
+            ASSERT(m_expr1);
+            ASSERT(m_expr2);
+            ASSERT(m_expr3);
+            ASSERT(statement);
+
+            m_expr1->optimizeForUnnecessaryResult();
+            m_expr3->optimizeForUnnecessaryResult();
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<ExpressionNode> m_expr1;
+        RefPtr<ExpressionNode> m_expr2;
+        RefPtr<ExpressionNode> m_expr3;
+        RefPtr<StatementNode> m_statement;
+        bool m_expr1WasVarDecl;
+    };
+
+    class ForInNode : public StatementNode {
+    public:
+        ForInNode(ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
+        ForInNode(const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        Identifier m_ident;
+        RefPtr<ExpressionNode> m_init;
+        RefPtr<ExpressionNode> m_lexpr;
+        RefPtr<ExpressionNode> m_expr;
+        RefPtr<StatementNode> m_statement;
+        bool m_identIsVarDecl;
+    };
+
+    class ContinueNode : public StatementNode {
+    public:
+        ContinueNode() KJS_FAST_CALL
+        {
+        }
+
+        ContinueNode(const Identifier& ident) KJS_FAST_CALL
+            : m_ident(ident)
+        {
+        }
+
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        Identifier m_ident;
+    };
+
+    class BreakNode : public StatementNode {
+    public:
+        BreakNode() KJS_FAST_CALL
+        {
+        }
+
+        BreakNode(const Identifier& ident) KJS_FAST_CALL
+            : m_ident(ident)
+        {
+        }
+
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        Identifier m_ident;
+    };
+
+    class ReturnNode : public StatementNode {
+    public:
+        ReturnNode(ExpressionNode* value) KJS_FAST_CALL
+            : m_value(value)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<ExpressionNode> m_value;
+    };
+
+    class WithNode : public StatementNode {
+    public:
+        WithNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
+            : m_expr(expr)
+            , m_statement(statement)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+        RefPtr<StatementNode> m_statement;
+    };
+
+    class LabelNode : public StatementNode {
+    public:
+        LabelNode(const Identifier& label, StatementNode* statement) KJS_FAST_CALL
+            : m_label(label)
+            , m_statement(statement)
     {
     }
 
-    ReadModifyResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-      : ExpressionNode(PlacementNewAdopt)
-      , m_ident(PlacementNewAdopt) 
-      , m_right(PlacementNewAdopt) 
-    {
-    }
-
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecAssignment; }
-  protected:
-    Identifier m_ident;
-    Operator m_oper;
-    RefPtr<ExpressionNode> m_right;
-    size_t m_index; // Used by ReadModifyLocalVarNode.
-  };
-
-  class ReadModifyLocalVarNode : public ReadModifyResolveNode {
-  public:
-    ReadModifyLocalVarNode(size_t i) KJS_FAST_CALL 
-        : ReadModifyResolveNode(PlacementNewAdopt)
-    { 
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-    
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-
-  class ReadModifyConstNode : public ReadModifyResolveNode {
-  public:
-    ReadModifyConstNode(size_t i) KJS_FAST_CALL 
-        : ReadModifyResolveNode(PlacementNewAdopt)
-    {
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-
-  class AssignResolveNode : public ExpressionNode {
-  public:
-     AssignResolveNode(const Identifier& ident, ExpressionNode* right) KJS_FAST_CALL
-      : m_ident(ident)
-      , m_right(right) 
-      {
-      }
-
-    AssignResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
-      : ExpressionNode(PlacementNewAdopt)
-      , m_ident(PlacementNewAdopt) 
-      , m_right(PlacementNewAdopt) 
-    {
-    }
-
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecAssignment; }
-  protected:
-    Identifier m_ident;
-    RefPtr<ExpressionNode> m_right;
-    size_t m_index; // Used by ReadModifyLocalVarNode.
-  };
-
-  class AssignLocalVarNode : public AssignResolveNode {
-  public:
-    AssignLocalVarNode(size_t i) KJS_FAST_CALL 
-        : AssignResolveNode(PlacementNewAdopt)
-    { 
-        ASSERT(i != missingSymbolMarker());
-        m_index = i;
-    }
-    
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-
-  class AssignConstNode : public AssignResolveNode {
-  public:
-    AssignConstNode() KJS_FAST_CALL 
-        : AssignResolveNode(PlacementNewAdopt)
-    { 
-    }    
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-  };
-
-  class ReadModifyBracketNode : public ExpressionNode {
-  public:
-    ReadModifyBracketNode(ExpressionNode* base, ExpressionNode* subscript, Operator oper, ExpressionNode* right) KJS_FAST_CALL
-      : m_base(base), m_subscript(subscript), m_oper(oper), m_right(right) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecAssignment; }
-  protected:
-    RefPtr<ExpressionNode> m_base;
-    RefPtr<ExpressionNode> m_subscript;
-    Operator m_oper;
-    RefPtr<ExpressionNode> m_right;
-  };
-
-  class AssignBracketNode : public ExpressionNode {
-  public:
-    AssignBracketNode(ExpressionNode* base, ExpressionNode* subscript, ExpressionNode* right) KJS_FAST_CALL
-      : m_base(base), m_subscript(subscript), m_right(right) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecAssignment; }
-  protected:
-    RefPtr<ExpressionNode> m_base;
-    RefPtr<ExpressionNode> m_subscript;
-    RefPtr<ExpressionNode> m_right;
-  };
-
-  class AssignDotNode : public ExpressionNode {
-  public:
-    AssignDotNode(ExpressionNode* base, const Identifier& ident, ExpressionNode* right) KJS_FAST_CALL
-      : m_base(base), m_ident(ident), m_right(right) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecAssignment; }
-  protected:
-    RefPtr<ExpressionNode> m_base;
-    Identifier m_ident;
-    RefPtr<ExpressionNode> m_right;
-  };
-
-  class ReadModifyDotNode : public ExpressionNode {
-  public:
-    ReadModifyDotNode(ExpressionNode* base, const Identifier& ident, Operator oper, ExpressionNode* right) KJS_FAST_CALL
-      : m_base(base), m_ident(ident), m_oper(oper), m_right(right) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecAssignment; }
-  protected:
-    RefPtr<ExpressionNode> m_base;
-    Identifier m_ident;
-    Operator m_oper;
-    RefPtr<ExpressionNode> m_right;
-  };
-
-  class AssignErrorNode : public ExpressionNode {
-  public:
-    AssignErrorNode(ExpressionNode* left, Operator oper, ExpressionNode* right) KJS_FAST_CALL
-      : m_left(left), m_oper(oper), m_right(right) { }
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecAssignment; }
-  protected:
-    RefPtr<ExpressionNode> m_left;
-    Operator m_oper;
-    RefPtr<ExpressionNode> m_right;
-  };
-
-  class CommaNode : public ExpressionNode {
-  public:
-    CommaNode(ExpressionNode* expr1, ExpressionNode* expr2) KJS_FAST_CALL
-        : m_expr1(expr1)
-        , m_expr2(expr2)
-    {
-        m_expr1->optimizeForUnnecessaryResult();
-    }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecExpression; }
-  private:
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-  };
-
-  class ConstDeclNode : public ExpressionNode {
-  public:
-    ConstDeclNode(const Identifier& ident, ExpressionNode* in) KJS_FAST_CALL;
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual KJS::JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    void evaluateSingle(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-    PassRefPtr<ConstDeclNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
-
-    Identifier m_ident;
-    ListRefPtr<ConstDeclNode> m_next;
-    RefPtr<ExpressionNode> m_init;
-  private:
-    void handleSlowCase(ExecState*, const ScopeChain&, JSValue*) KJS_FAST_CALL NEVER_INLINE;
-  };
-
-  class ConstStatementNode : public StatementNode {
-  public:
-    ConstStatementNode(ConstDeclNode* next) KJS_FAST_CALL
-      : m_next(next) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    RefPtr<ConstDeclNode> m_next;
-  };
-
-  typedef Vector<RefPtr<StatementNode> > StatementVector;
-
-    class SourceElements : public ParserRefCounted {
-    public:
-        void append(PassRefPtr<StatementNode>);
-        void releaseContentsIntoVector(StatementVector& destination)
-        {
-            ASSERT(destination.isEmpty());
-            m_statements.swap(destination);
-        }
-    private:
-        StatementVector m_statements;
-    };
-
-  class BlockNode : public StatementNode {
-  public:
-    BlockNode(SourceElements* children) KJS_FAST_CALL;
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  protected:
-    StatementVector m_children;
-  };
-
-  class EmptyStatementNode : public StatementNode {
-  public:
-    EmptyStatementNode() KJS_FAST_CALL { } // debug
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual bool isEmptyStatement() const KJS_FAST_CALL { return true; }
-  };
-
-  class ExprStatementNode : public StatementNode {
-  public:
-    ExprStatementNode(ExpressionNode* expr) KJS_FAST_CALL
-      : m_expr(expr) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class VarStatementNode : public StatementNode {
-  public:
-    VarStatementNode(ExpressionNode* e) KJS_FAST_CALL : m_expr(e) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class IfNode : public StatementNode {
-  public:
-    IfNode(ExpressionNode* condition, StatementNode* ifBlock) KJS_FAST_CALL
-      : m_condition(condition), m_ifBlock(ifBlock) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  protected:
-    RefPtr<ExpressionNode> m_condition;
-    RefPtr<StatementNode> m_ifBlock;
-  };
-
-    class IfElseNode : public IfNode {
-    public:
-        IfElseNode(ExpressionNode* condtion, StatementNode* ifBlock, StatementNode* elseBlock) KJS_FAST_CALL
-            : IfNode(condtion, ifBlock), m_elseBlock(elseBlock) { }
         virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
         virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    private:
-        RefPtr<StatementNode> m_elseBlock;
-    };
-
-  class DoWhileNode : public StatementNode {
-  public:
-    DoWhileNode(StatementNode* statement, ExpressionNode* expr) KJS_FAST_CALL
-      : m_statement(statement), m_expr(expr) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    RefPtr<StatementNode> m_statement;
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class WhileNode : public StatementNode {
-  public:
-    WhileNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
-      : m_expr(expr), m_statement(statement) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    RefPtr<ExpressionNode> m_expr;
-    RefPtr<StatementNode> m_statement;
-  };
-
-  class ForNode : public StatementNode {
-  public:
-      ForNode(ExpressionNode* expr1, ExpressionNode* expr2, ExpressionNode* expr3, StatementNode* statement, bool expr1WasVarDecl) KJS_FAST_CALL
-        : m_expr1(expr1 ? expr1 : new PlaceholderTrueNode)
-        , m_expr2(expr2 ? expr2 : new PlaceholderTrueNode)
-        , m_expr3(expr3 ? expr3 : new PlaceholderTrueNode)
-        , m_statement(statement)
-        , m_expr1WasVarDecl(expr1 && expr1WasVarDecl)
-    {
-        ASSERT(m_expr1);
-        ASSERT(m_expr2);
-        ASSERT(m_expr3);
-        ASSERT(statement);
-
-        m_expr1->optimizeForUnnecessaryResult();
-        m_expr3->optimizeForUnnecessaryResult();
-    }
-
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    RefPtr<ExpressionNode> m_expr1;
-    RefPtr<ExpressionNode> m_expr2;
-    RefPtr<ExpressionNode> m_expr3;
-    RefPtr<StatementNode> m_statement;
-    bool m_expr1WasVarDecl;
-  };
-
-  class ForInNode : public StatementNode {
-  public:
-    ForInNode(ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
-    ForInNode(const Identifier&, ExpressionNode*, ExpressionNode*, StatementNode*) KJS_FAST_CALL;
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    Identifier m_ident;
-    RefPtr<ExpressionNode> m_init;
-    RefPtr<ExpressionNode> m_lexpr;
-    RefPtr<ExpressionNode> m_expr;
-    RefPtr<StatementNode> m_statement;
-    bool m_identIsVarDecl;
-  };
-
-  class ContinueNode : public StatementNode {
-  public:
-    ContinueNode() KJS_FAST_CALL { }
-    ContinueNode(const Identifier& ident) KJS_FAST_CALL
-      : m_ident(ident) { }
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    Identifier m_ident;
-  };
-
-  class BreakNode : public StatementNode {
-  public:
-    BreakNode() KJS_FAST_CALL { }
-    BreakNode(const Identifier& ident) KJS_FAST_CALL
-      : m_ident(ident) { }
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    Identifier m_ident;
-  };
-
-  class ReturnNode : public StatementNode {
-  public:
-    ReturnNode(ExpressionNode* value) KJS_FAST_CALL
-      : m_value(value) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    RefPtr<ExpressionNode> m_value;
-  };
-
-  class WithNode : public StatementNode {
-  public:
-    WithNode(ExpressionNode* expr, StatementNode* statement) KJS_FAST_CALL
-      : m_expr(expr), m_statement(statement) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    RefPtr<ExpressionNode> m_expr;
-    RefPtr<StatementNode> m_statement;
-  };
-
-  class LabelNode : public StatementNode {
-  public:
-    LabelNode(const Identifier& label, StatementNode* statement) KJS_FAST_CALL
-      : m_label(label), m_statement(statement) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    Identifier m_label;
-    RefPtr<StatementNode> m_statement;
-  };
-
-  class ThrowNode : public StatementNode {
-  public:
-    ThrowNode(ExpressionNode* expr) KJS_FAST_CALL
-      : m_expr(expr) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    RefPtr<ExpressionNode> m_expr;
-  };
-
-  class TryNode : public StatementNode {
-  public:
-    TryNode(StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock) KJS_FAST_CALL
-      : m_tryBlock(tryBlock), m_exceptionIdent(exceptionIdent), m_catchBlock(catchBlock), m_finallyBlock(finallyBlock) { }
-    virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-    RefPtr<StatementNode> m_tryBlock;
-    Identifier m_exceptionIdent;
-    RefPtr<StatementNode> m_catchBlock;
-    RefPtr<StatementNode> m_finallyBlock;
-  };
-
-  class ParameterNode : public Node {
-  public:
-    ParameterNode(const Identifier& ident) KJS_FAST_CALL
-      : m_ident(ident) { }
-    ParameterNode(ParameterNode* l, const Identifier& ident) KJS_FAST_CALL
-      : m_ident(ident) { l->m_next = this; }
-    Identifier ident() KJS_FAST_CALL { return m_ident; }
-    ParameterNode *nextParam() KJS_FAST_CALL { return m_next.get(); }
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    PassRefPtr<ParameterNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
-    virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-  private:
-    friend class FuncDeclNode;
-    friend class FuncExprNode;
-    Identifier m_ident;
-    ListRefPtr<ParameterNode> m_next;
-  };
-
-  class ScopeNode : public BlockNode {
-  public:
-    ScopeNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
-
-    int sourceId() const KJS_FAST_CALL { return m_sourceId; }
-    const UString& sourceURL() const KJS_FAST_CALL { return m_sourceURL; }
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-
-  protected:
-    void optimizeVariableAccess(ExecState*) KJS_FAST_CALL;
-
-    VarStack m_varStack;
-    FunctionStack m_functionStack;
-
-  private:
-    UString m_sourceURL;
-    int m_sourceId;
-  };
-
-  class ProgramNode : public ScopeNode {
-  public:
-    static ProgramNode* create(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    
-  private:
-    ProgramNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
-    void initializeSymbolTable(ExecState*) KJS_FAST_CALL;
-    ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL;
-
-    Vector<size_t> m_varIndexes; // Storage indexes belonging to the nodes in m_varStack. (Recorded to avoid double lookup.)
-    Vector<size_t> m_functionIndexes; // Storage indexes belonging to the nodes in m_functionStack. (Recorded to avoid double lookup.)
-  };
-
-  class EvalNode : public ScopeNode {
-  public:
-    static EvalNode* create(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    
-  private:
-    EvalNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
-    ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL;
-  };
-
-  class FunctionBodyNode : public ScopeNode {
-  public:
-    static FunctionBodyNode* create(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
-
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-
-    SymbolTable& symbolTable() KJS_FAST_CALL { return m_symbolTable; }
-
-    Vector<Identifier>& parameters() KJS_FAST_CALL { return m_parameters; }
-    UString paramString() const KJS_FAST_CALL;
-
-  protected:
-    FunctionBodyNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
-
-  private:
-    void initializeSymbolTable(ExecState*) KJS_FAST_CALL;
-    ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL;
-
-    bool m_initialized;
-    Vector<Identifier> m_parameters;
-    SymbolTable m_symbolTable;
-  };
-
-  class FuncExprNode : public ExpressionNode {
-  public:
-    FuncExprNode(const Identifier& ident, FunctionBodyNode* body, ParameterNode* parameter = 0) KJS_FAST_CALL 
-      : m_ident(ident), m_parameter(parameter), m_body(body) { addParams(); }
-    virtual JSValue *evaluate(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    virtual Precedence precedence() const { return PrecMember; }
-    virtual bool needsParensIfLeftmost() const { return true; }
-  private:
-    void addParams() KJS_FAST_CALL;
-    // Used for streamTo
-    friend class PropertyNode;
-    Identifier m_ident;
-    RefPtr<ParameterNode> m_parameter;
-    RefPtr<FunctionBodyNode> m_body;
-  };
-
-  class FuncDeclNode : public StatementNode {
-  public:
-    FuncDeclNode(const Identifier& ident, FunctionBodyNode* body) KJS_FAST_CALL
-      : m_ident(ident), m_body(body) { addParams(); }
-    FuncDeclNode(const Identifier& ident, ParameterNode* parameter, FunctionBodyNode* body) KJS_FAST_CALL
-      : m_ident(ident), m_parameter(parameter), m_body(body) { addParams(); }
-    virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    ALWAYS_INLINE FunctionImp* makeFunction(ExecState*) KJS_FAST_CALL;
-    Identifier m_ident;
-  private:
-    void addParams() KJS_FAST_CALL;
-    RefPtr<ParameterNode> m_parameter;
-    RefPtr<FunctionBodyNode> m_body;
-  };
-
-  class CaseClauseNode : public Node {
-  public:
-      CaseClauseNode(ExpressionNode* e) KJS_FAST_CALL
-        : m_expr(e) { }
-      CaseClauseNode(ExpressionNode* e, SourceElements* children) KJS_FAST_CALL
-        : m_expr(e) { if (children) children->releaseContentsIntoVector(m_children); }
-      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-      virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-
-      JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-      JSValue* executeStatements(ExecState*) KJS_FAST_CALL;
-
-  private:
-      RefPtr<ExpressionNode> m_expr;
-      StatementVector m_children;
-  };
-  
-  class ClauseListNode : public Node {
-  public:
-      ClauseListNode(CaseClauseNode* clause) KJS_FAST_CALL
-        : m_clause(clause) { }
-      ClauseListNode(ClauseListNode* clauseList, CaseClauseNode* clause) KJS_FAST_CALL
-        : m_clause(clause) { clauseList->m_next = this; }
-      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-      CaseClauseNode* getClause() const KJS_FAST_CALL { return m_clause.get(); }
-      ClauseListNode* getNext() const KJS_FAST_CALL { return m_next.get(); }
-      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-      PassRefPtr<ClauseListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
-      virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-  private:
-      friend class CaseBlockNode;
-      RefPtr<CaseClauseNode> m_clause;
-      ListRefPtr<ClauseListNode> m_next;
-  };
-  
-  class CaseBlockNode : public Node {
-  public:
-      CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2) KJS_FAST_CALL;
-      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-      JSValue* executeBlock(ExecState*, JSValue *input) KJS_FAST_CALL;
-      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-      virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-  private:
-      RefPtr<ClauseListNode> m_list1;
-      RefPtr<CaseClauseNode> m_defaultClause;
-      RefPtr<ClauseListNode> m_list2;
-  };
-  
-  class SwitchNode : public StatementNode {
-  public:
-      SwitchNode(ExpressionNode* expr, CaseBlockNode* block) KJS_FAST_CALL
-        : m_expr(expr), m_block(block) { }
-      virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
-      virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
-      virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-  private:
-      RefPtr<ExpressionNode> m_expr;
-      RefPtr<CaseBlockNode> m_block;
-  };
+
+    private:
+        Identifier m_label;
+        RefPtr<StatementNode> m_statement;
+    };
+
+    class ThrowNode : public StatementNode {
+    public:
+        ThrowNode(ExpressionNode* expr) KJS_FAST_CALL
+            : m_expr(expr)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+    };
+
+    class TryNode : public StatementNode {
+    public:
+        TryNode(StatementNode* tryBlock, const Identifier& exceptionIdent, StatementNode* catchBlock, StatementNode* finallyBlock) KJS_FAST_CALL
+            : m_tryBlock(tryBlock)
+            , m_exceptionIdent(exceptionIdent)
+            , m_catchBlock(catchBlock)
+            , m_finallyBlock(finallyBlock)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<StatementNode> m_tryBlock;
+        Identifier m_exceptionIdent;
+        RefPtr<StatementNode> m_catchBlock;
+        RefPtr<StatementNode> m_finallyBlock;
+    };
+
+    class ParameterNode : public Node {
+    public:
+        ParameterNode(const Identifier& ident) KJS_FAST_CALL
+            : m_ident(ident)
+        {
+        }
+
+        ParameterNode(ParameterNode* l, const Identifier& ident) KJS_FAST_CALL
+            : m_ident(ident)
+        {
+            l->m_next = this;
+        }
+
+        Identifier ident() KJS_FAST_CALL { return m_ident; }
+        ParameterNode *nextParam() KJS_FAST_CALL { return m_next.get(); }
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        PassRefPtr<ParameterNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+
+    private:
+        friend class FuncDeclNode;
+        friend class FuncExprNode;
+        Identifier m_ident;
+        ListRefPtr<ParameterNode> m_next;
+    };
+
+    class ScopeNode : public BlockNode {
+    public:
+        ScopeNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
+
+        int sourceId() const KJS_FAST_CALL { return m_sourceId; }
+        const UString& sourceURL() const KJS_FAST_CALL { return m_sourceURL; }
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    protected:
+        void optimizeVariableAccess(ExecState*) KJS_FAST_CALL;
+
+        VarStack m_varStack;
+        FunctionStack m_functionStack;
+
+    private:
+        UString m_sourceURL;
+        int m_sourceId;
+    };
+
+    class ProgramNode : public ScopeNode {
+    public:
+        static ProgramNode* create(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
+
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+
+    private:
+        ProgramNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
+
+        void initializeSymbolTable(ExecState*) KJS_FAST_CALL;
+        ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL;
+
+        Vector<size_t> m_varIndexes; // Storage indexes belonging to the nodes in m_varStack. (Recorded to avoid double lookup.)
+        Vector<size_t> m_functionIndexes; // Storage indexes belonging to the nodes in m_functionStack. (Recorded to avoid double lookup.)
+    };
+
+    class EvalNode : public ScopeNode {
+    public:
+        static EvalNode* create(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
+
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+
+    private:
+        EvalNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
+
+        ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL;
+    };
+
+    class FunctionBodyNode : public ScopeNode {
+    public:
+        static FunctionBodyNode* create(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
+
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+
+        SymbolTable& symbolTable() KJS_FAST_CALL { return m_symbolTable; }
+
+        Vector<Identifier>& parameters() KJS_FAST_CALL { return m_parameters; }
+        UString paramString() const KJS_FAST_CALL;
+
+    protected:
+        FunctionBodyNode(SourceElements*, VarStack*, FunctionStack*) KJS_FAST_CALL;
+
+    private:
+        void initializeSymbolTable(ExecState*) KJS_FAST_CALL;
+        ALWAYS_INLINE void processDeclarations(ExecState*) KJS_FAST_CALL;
+
+        bool m_initialized;
+        Vector<Identifier> m_parameters;
+        SymbolTable m_symbolTable;
+    };
+
+    class FuncExprNode : public ExpressionNode {
+    public:
+        FuncExprNode(const Identifier& ident, FunctionBodyNode* body, ParameterNode* parameter = 0) KJS_FAST_CALL
+            : m_ident(ident)
+            , m_parameter(parameter)
+            , m_body(body)
+        {
+            addParams();
+        }
+
+        virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { return PrecMember; }
+        virtual bool needsParensIfLeftmost() const { return true; }
+
+    private:
+        void addParams() KJS_FAST_CALL;
+
+        // Used for streamTo
+        friend class PropertyNode;
+        Identifier m_ident;
+        RefPtr<ParameterNode> m_parameter;
+        RefPtr<FunctionBodyNode> m_body;
+    };
+
+    class FuncDeclNode : public StatementNode {
+    public:
+        FuncDeclNode(const Identifier& ident, FunctionBodyNode* body) KJS_FAST_CALL
+            : m_ident(ident)
+            , m_body(body)
+        {
+            addParams();
+        }
+
+        FuncDeclNode(const Identifier& ident, ParameterNode* parameter, FunctionBodyNode* body) KJS_FAST_CALL
+            : m_ident(ident)
+            , m_parameter(parameter)
+            , m_body(body)
+        {
+            addParams();
+        }
+
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        ALWAYS_INLINE FunctionImp* makeFunction(ExecState*) KJS_FAST_CALL;
+
+        Identifier m_ident;
+
+    private:
+        void addParams() KJS_FAST_CALL;
+
+        RefPtr<ParameterNode> m_parameter;
+        RefPtr<FunctionBodyNode> m_body;
+    };
+
+    class CaseClauseNode : public Node {
+    public:
+        CaseClauseNode(ExpressionNode* expr) KJS_FAST_CALL
+            : m_expr(expr)
+        {
+        }
+
+        CaseClauseNode(ExpressionNode* expr, SourceElements* children) KJS_FAST_CALL
+            : m_expr(expr)
+        {
+            if (children)
+                children->releaseContentsIntoVector(m_children);
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+
+        JSValue* evaluate(ExecState*) KJS_FAST_CALL;
+        JSValue* executeStatements(ExecState*) KJS_FAST_CALL;
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+        StatementVector m_children;
+    };
+
+    class ClauseListNode : public Node {
+    public:
+        ClauseListNode(CaseClauseNode* clause) KJS_FAST_CALL
+            : m_clause(clause)
+        {
+        }
+
+        ClauseListNode(ClauseListNode* clauseList, CaseClauseNode* clause) KJS_FAST_CALL
+            : m_clause(clause)
+        {
+            clauseList->m_next = this;
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        CaseClauseNode* getClause() const KJS_FAST_CALL { return m_clause.get(); }
+        ClauseListNode* getNext() const KJS_FAST_CALL { return m_next.get(); }
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        PassRefPtr<ClauseListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+
+    private:
+        friend class CaseBlockNode;
+        RefPtr<CaseClauseNode> m_clause;
+        ListRefPtr<ClauseListNode> m_next;
+    };
+
+    class CaseBlockNode : public Node {
+    public:
+        CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2) KJS_FAST_CALL;
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        JSValue* executeBlock(ExecState*, JSValue *input) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+        virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
+
+    private:
+        RefPtr<ClauseListNode> m_list1;
+        RefPtr<CaseClauseNode> m_defaultClause;
+        RefPtr<ClauseListNode> m_list2;
+    };
+
+    class SwitchNode : public StatementNode {
+    public:
+        SwitchNode(ExpressionNode* expr, CaseBlockNode* block) KJS_FAST_CALL
+            : m_expr(expr)
+            , m_block(block)
+        {
+        }
+
+        virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+        virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
+        virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
+
+    private:
+        RefPtr<ExpressionNode> m_expr;
+        RefPtr<CaseBlockNode> m_block;
+    };
 
     class BreakpointCheckStatement : public StatementNode {
     public:
         BreakpointCheckStatement(PassRefPtr<StatementNode>) KJS_FAST_CALL;
+
         virtual JSValue* execute(ExecState*) KJS_FAST_CALL;
         virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
         virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
+
     private:
         RefPtr<StatementNode> m_statement;
     };
 
-  struct ElementList {
-      ElementNode* head;
-      ElementNode* tail;
-  };
-
-  struct PropertyList {
-      PropertyListNode* head;
-      PropertyListNode* tail;
-  };
-
-  struct ArgumentList {
-      ArgumentListNode* head;
-      ArgumentListNode* tail;
-  };
-
-  struct ConstDeclList {
-      ConstDeclNode* head;
-      ConstDeclNode* tail;
-  };
-
-  struct ParameterList {
-      ParameterNode* head;
-      ParameterNode* tail;
-  };
-
-  struct ClauseList {
-      ClauseListNode* head;
-      ClauseListNode* tail;
-  };
+    struct ElementList {
+        ElementNode* head;
+        ElementNode* tail;
+    };
+
+    struct PropertyList {
+        PropertyListNode* head;
+        PropertyListNode* tail;
+    };
+
+    struct ArgumentList {
+        ArgumentListNode* head;
+        ArgumentListNode* tail;
+    };
+
+    struct ConstDeclList {
+        ConstDeclNode* head;
+        ConstDeclNode* tail;
+    };
+
+    struct ParameterList {
+        ParameterNode* head;
+        ParameterNode* tail;
+    };
+
+    struct ClauseList {
+        ClauseListNode* head;
+        ClauseListNode* tail;
+    };
 
 } // namespace KJS

trunk/JavaScriptCore/kjs/nodes2string.cpp

@@ -42 +42 @@
 class SourceStream {
 public:
-    SourceStream() : m_numberNeedsParens(false), m_atStartOfStatement(true), m_precedence(PrecExpression) { }
+    SourceStream()
+        : m_numberNeedsParens(false)
+        , m_atStartOfStatement(true)
+        , m_precedence(PrecExpression)
+    {
+    }
+
     UString toString() const { return m_string; }
+
     SourceStream& operator<<(const Identifier&);
     SourceStream& operator<<(const UString&);
@@ -100 +107 @@
     }
 
-    return escapedString;    
+    return escapedString;
 }
 
@@ -315 +322 @@
 
 void RegExpNode::streamTo(SourceStream& s) const
-{ 
+{
     s << '/' <<  m_regExp->pattern() << '/' << m_regExp->flags();
 }
@@ -345 +352 @@
     for (int i = 0; i < m_elision; i++)
         s << ',';
-    // Parser consumes one elision comma if there's array elements 
+    // Parser consumes one elision comma if there's array elements
     // present in the expression.
-    if (m_opt && m_element)
+    if (m_optional && m_element)
         s << ',';
     s << ']';
@@ -383 +390 @@
             const FuncExprNode* func = static_cast<const FuncExprNode*>(m_assign.get());
             if (m_type == Getter)
-                s << "get "; 
+                s << "get ";
             else
                 s << "set ";
@@ -479 +486 @@
 {
     s << PrecLeftHandSide << m_expr;
-    if (m_oper == OpPlusPlus)
+    if (m_operator == OpPlusPlus)
         s << "++";
     else
@@ -558 +565 @@
 void PrefixErrorNode::streamTo(SourceStream& s) const
 {
-    if (m_oper == OpPlusPlus)
+    if (m_operator == OpPlusPlus)
         s << "++" << PrecUnary << m_expr;
     else
@@ -708 +715 @@
 void ReadModifyResolveNode::streamTo(SourceStream& s) const
 {
-    s << m_ident << ' ' << operatorString(m_oper) << ' ' << PrecAssignment << m_right;
+    s << m_ident << ' ' << operatorString(m_operator) << ' ' << PrecAssignment << m_right;
 }
 
@@ -719 +726 @@
 {
     bracketNodeStreamTo(s, m_base, m_subscript);
-    s << ' ' << operatorString(m_oper) << ' ' << PrecAssignment << m_right;
+    s << ' ' << operatorString(m_operator) << ' ' << PrecAssignment << m_right;
 }
 
@@ -731 +738 @@
 {
     dotNodeStreamTo(s, m_base, m_ident);
-    s << ' ' << operatorString(m_oper) << ' ' << PrecAssignment << m_right;
+    s << ' ' << operatorString(m_operator) << ' ' << PrecAssignment << m_right;
 }
 
@@ -743 +750 @@
 {
     s << PrecLeftHandSide << m_left << ' '
-        << operatorString(m_oper) << ' ' << PrecAssignment << m_right;
+        << operatorString(m_operator) << ' ' << PrecAssignment << m_right;
 }
 
@@ -773 +780 @@
         s << *ptr;
 }
-    
+
 void BlockNode::streamTo(SourceStream& s) const
 {
     s << Endl << "{" << Indent;
-    statementListStreamTo(m_children, s); 
+    statementListStreamTo(m_children, s);
     s << Unindent << Endl << "}";
 }
@@ -799 +806 @@
         s << ';';
 
-    statementListStreamTo(m_children, s); 
+    statementListStreamTo(m_children, s);
     s << Unindent << Endl << "}";
 }