Changeset 29825 in webkit for trunk/JavaScriptCore

Timestamp:

Jan 27, 2008, 4:14:24 PM (17 years ago)

Author:

[email protected]

Message:

Reviewed by Oliver Hunt.

Patch for ​http://bugs.webkit.org/show_bug.cgi?id=17025
nodes.h/cpp has been rolling around in the mud - lets hose it down

• Rename member variables to use the m_ prefix.

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

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

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• kjs/grammar.y (modified) (2 diffs)
• kjs/nodes.cpp (modified) (165 diffs)
• kjs/nodes.h (modified) (104 diffs)
• kjs/nodes2string.cpp (modified) (22 diffs)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2008-01-27  Sam Weinig  <[email protected]>
+
+        Reviewed by Oliver Hunt.
+
+        Patch for http://bugs.webkit.org/show_bug.cgi?id=17025
+        nodes.h/cpp has been rolling around in the mud - lets hose it down
+
+        - Rename member variables to use the m_ prefix.
+
+        (NOTE: Specific changed functions elided for space and clarity)
+        * kjs/grammar.y:
+        * kjs/nodes.cpp:
+        * kjs/nodes.h:
+        * kjs/nodes2string.cpp:
+
 2008-01-27  Darin Adler  <[email protected]>
 

trunk/JavaScriptCore/kjs/grammar.y

@@ -128 +128 @@
 {
     unsigned attrs = DeclarationStacks::IsConstant;
-    if (decl->init)
+    if (decl->m_init)
         attrs |= DeclarationStacks::HasInitializer;        
-    appendToVarDeclarationList(varDecls, decl->ident, attrs);
+    appendToVarDeclarationList(varDecls, decl->m_ident, attrs);
 }
 
@@ -792 +792 @@
   | ConstDeclarationList ',' ConstDeclaration
                                         {  $$.m_node.head = $1.m_node.head;
-                                          $1.m_node.tail->next = $3;
+                                          $1.m_node.tail->m_next = $3;
                                           $$.m_node.tail = $3;
                                           $$.m_varDeclarations = $1.m_varDeclarations;

trunk/JavaScriptCore/kjs/nodes.cpp

@@ -536 +536 @@
 {
   // Check for missed optimization opportunity.
-  ASSERT(!canSkipLookup(exec, ident));
+  ASSERT(!canSkipLookup(exec, m_ident));
 
   const ScopeChain& chain = exec->scopeChain();
@@ -549 +549 @@
     JSObject *o = *iter;
 
-    if (o->getPropertySlot(exec, ident, slot))
-      return slot.getValue(exec, o, ident);
+    if (o->getPropertySlot(exec, m_ident, slot))
+      return slot.getValue(exec, o, m_ident);
     
     ++iter;
   } while (iter != end);
 
-  return throwUndefinedVariableError(exec, ident);
+  return throwUndefinedVariableError(exec, m_ident);
 }
 
@@ -593 +593 @@
 void ResolveNode::optimizeVariableAccess(const SymbolTable& symbolTable, const LocalStorage&, NodeStack&)
 {
-    size_t index = symbolTable.get(ident.ustring().rep());
+    size_t index = symbolTable.get(m_ident.ustring().rep());
     if (index != missingSymbolMarker())
         new (this) LocalVarAccessNode(index);
@@ -601 +601 @@
 {
     ASSERT(exec->variableObject() == exec->scopeChain().top());
-    return exec->localStorage()[index].value;
+    return exec->localStorage()[m_index].value;
 }
 
@@ -633 +633 @@
 void ElementNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (next)
-        nodeStack.append(next.get());
-    ASSERT(node);
-    nodeStack.append(node.get());
+    if (m_next)
+        nodeStack.append(m_next.get());
+    ASSERT(m_node);
+    nodeStack.append(m_node.get());
 }
 
@@ -644 +644 @@
   JSObject* array = exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, exec->emptyList());
   int length = 0;
-  for (ElementNode *n = this; n; n = n->next.get()) {
-    JSValue *val = n->node->evaluate(exec);
+  for (ElementNode *n = this; n; n = n->m_next.get()) {
+    JSValue *val = n->m_node->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    length += n->elision;
+    length += n->m_elision;
     array->put(exec, length++, val);
   }
@@ -657 +657 @@
 void ArrayNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (element)
-        nodeStack.append(element.get());
+    if (m_element)
+        nodeStack.append(m_element.get());
 }
 
@@ -668 +668 @@
   int length;
 
-  if (element) {
-    array = static_cast<JSObject*>(element->evaluate(exec));
+  if (m_element) {
+    array = static_cast<JSObject*>(m_element->evaluate(exec));
     KJS_CHECKEXCEPTIONVALUE
-    length = opt ? array->get(exec, exec->propertyNames().length)->toInt32(exec) : 0;
+    length = m_opt ? array->get(exec, exec->propertyNames().length)->toInt32(exec) : 0;
   } else {
     JSValue* newArr = exec->lexicalGlobalObject()->arrayConstructor()->construct(exec, exec->emptyList());
@@ -678 +678 @@
   }
 
-  if (opt)
-    array->put(exec, exec->propertyNames().length, jsNumber(elision + length), DontEnum | DontDelete);
+  if (m_opt)
+    array->put(exec, exec->propertyNames().length, jsNumber(m_elision + length), DontEnum | DontDelete);
 
   return array;
@@ -688 +688 @@
 void ObjectLiteralNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (list)
-        nodeStack.append(list.get());
+    if (m_list)
+        nodeStack.append(m_list.get());
 }
 
@@ -695 +695 @@
 JSValue *ObjectLiteralNode::evaluate(ExecState *exec)
 {
-  if (list)
-    return list->evaluate(exec);
+  if (m_list)
+    return m_list->evaluate(exec);
 
   return exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
@@ -705 +705 @@
 void PropertyListNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (next)
-        nodeStack.append(next.get());
-    nodeStack.append(node.get());
+    if (m_next)
+        nodeStack.append(m_next.get());
+    nodeStack.append(m_node.get());
 }
 
@@ -715 +715 @@
   JSObject* obj = exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
   
-  for (PropertyListNode *p = this; p; p = p->next.get()) {
-    JSValue *v = p->node->assign->evaluate(exec);
+  for (PropertyListNode *p = this; p; p = p->m_next.get()) {
+    JSValue *v = p->m_node->m_assign->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     
-    switch (p->node->type) {
+    switch (p->m_node->m_type) {
       case PropertyNode::Getter:
         ASSERT(v->isObject());
-        obj->defineGetter(exec, p->node->name(), static_cast<JSObject *>(v));
+        obj->defineGetter(exec, p->m_node->name(), static_cast<JSObject *>(v));
         break;
       case PropertyNode::Setter:
         ASSERT(v->isObject());
-        obj->defineSetter(exec, p->node->name(), static_cast<JSObject *>(v));
+        obj->defineSetter(exec, p->m_node->name(), static_cast<JSObject *>(v));
         break;
       case PropertyNode::Constant:
-        obj->put(exec, p->node->name(), v);
+        obj->put(exec, p->m_node->name(), v);
         break;
     }
@@ -741 +741 @@
 void PropertyNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(assign.get());
+    nodeStack.append(m_assign.get());
 }
 
@@ -755 +755 @@
 void BracketAccessorNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_subscript.get());
+    nodeStack.append(m_base.get());
 }
 
@@ -762 +762 @@
 JSValue* BracketAccessorNode::inlineEvaluate(ExecState* exec)
 {
-  JSValue* v1 = expr1->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-  JSValue* v2 = expr2->evaluate(exec);
+  JSValue* v1 = m_base->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  JSValue* v2 = m_subscript->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
   JSObject* o = v1->toObject(exec);
@@ -810 +810 @@
 void DotAccessorNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr.get());
+    nodeStack.append(m_base.get());
 }
 
@@ -816 +816 @@
 JSValue* DotAccessorNode::inlineEvaluate(ExecState* exec)
 {
-    JSValue* v = expr->evaluate(exec);
+    JSValue* v = m_base->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    return v->toObject(exec)->get(exec, ident);
+    return v->toObject(exec)->get(exec, m_ident);
 }
 
@@ -858 +858 @@
 void ArgumentListNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (next)
-        nodeStack.append(next.get());
-    ASSERT(expr);
-    nodeStack.append(expr.get());
+    if (m_next)
+        nodeStack.append(m_next.get());
+    ASSERT(m_expr);
+    nodeStack.append(m_expr.get());
 }
 
@@ -867 +867 @@
 void ArgumentListNode::evaluateList(ExecState* exec, List& list)
 {
-  for (ArgumentListNode *n = this; n; n = n->next.get()) {
-    JSValue *v = n->expr->evaluate(exec);
+  for (ArgumentListNode *n = this; n; n = n->m_next.get()) {
+    JSValue *v = n->m_expr->evaluate(exec);
     KJS_CHECKEXCEPTIONVOID
     list.append(v);
@@ -878 +878 @@
 void ArgumentsNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (listNode)
-        nodeStack.append(listNode.get());
+    if (m_listNode)
+        nodeStack.append(m_listNode.get());
 }
 
@@ -886 +886 @@
 void NewExprNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (args)
-        nodeStack.append(args.get());
-    nodeStack.append(expr.get());
+    if (m_args)
+        nodeStack.append(m_args.get());
+    nodeStack.append(m_expr.get());
 }
 
@@ -895 +895 @@
 JSValue* NewExprNode::inlineEvaluate(ExecState* exec)
 {
-  JSValue* v = expr->evaluate(exec);
+  JSValue* v = m_expr->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 
   List argList;
-  if (args) {
-    args->evaluateList(exec, 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, expr.get());
+    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, expr.get());
+    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);
@@ -949 +949 @@
 void FunctionCallValueNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(args.get());
-    nodeStack.append(expr.get());
+    nodeStack.append(m_args.get());
+    nodeStack.append(m_expr.get());
 }
 
@@ -956 +956 @@
 JSValue *FunctionCallValueNode::evaluate(ExecState *exec)
 {
-  JSValue *v = expr->evaluate(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, expr.get());
+    return throwError(exec, TypeError, "Value %s (result of expression %s) is not object.", v, m_expr.get());
   }
   
@@ -966 +966 @@
 
   if (!func->implementsCall()) {
-    return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, expr.get());
+    return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, m_expr.get());
   }
 
   List argList;
-  args->evaluateList(exec, argList);
+  m_args->evaluateList(exec, argList);
   KJS_CHECKEXCEPTIONVALUE
 
@@ -980 +980 @@
 void FunctionCallResolveNode::optimizeVariableAccess(const SymbolTable& symbolTable, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(args.get());
-
-    size_t index = symbolTable.get(ident.ustring().rep());
+    nodeStack.append(m_args.get());
+
+    size_t index = symbolTable.get(m_ident.ustring().rep());
     if (index != missingSymbolMarker())
         new (this) LocalVarFunctionCallNode(index);
@@ -991 +991 @@
 {
   // Check for missed optimization opportunity.
-  ASSERT(!canSkipLookup(exec, ident));
+  ASSERT(!canSkipLookup(exec, m_ident));
 
   const ScopeChain& chain = exec->scopeChain();
@@ -1001 +1001 @@
 
   PropertySlot slot;
-  JSObject *base;
+  JSObject* base;
   do { 
     base = *iter;
-    if (base->getPropertySlot(exec, ident, slot)) {
-      JSValue *v = slot.getValue(exec, base, ident);
+    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, ident);
+        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, ident);
+        return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, m_ident);
       
       List argList;
-      args->evaluateList(exec, argList);
+      m_args->evaluateList(exec, argList);
       KJS_CHECKEXCEPTIONVALUE
         
@@ -1035 +1035 @@
   } while (iter != end);
   
-  return throwUndefinedVariableError(exec, ident);
+  return throwUndefinedVariableError(exec, m_ident);
 }
 
@@ -1075 +1075 @@
     ASSERT(exec->variableObject() == exec->scopeChain().top());
 
-    JSValue* v = exec->localStorage()[index].value;
+    JSValue* v = exec->localStorage()[m_index].value;
 
     if (!v->isObject())
-        return throwError(exec, TypeError, "Value %s (result of expression %s) is not object.", v, ident);
+        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, ident);
+        return throwError(exec, TypeError, "Object %s (result of expression %s) does not allow calls.", v, m_ident);
       
     List argList;
-    args->evaluateList(exec, argList);
+    m_args->evaluateList(exec, argList);
     KJS_CHECKEXCEPTIONVALUE
 
@@ -1126 +1126 @@
 void FunctionCallBracketNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(args.get());
-    nodeStack.append(subscript.get());
-    nodeStack.append(base.get());
+    nodeStack.append(m_args.get());
+    nodeStack.append(m_subscript.get());
+    nodeStack.append(m_base.get());
 }
 
@@ -1134 +1134 @@
 JSValue *FunctionCallBracketNode::evaluate(ExecState *exec)
 {
-  JSValue *baseVal = base->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSValue *subscriptVal = subscript->evaluate(exec);
+  JSValue *baseVal = m_base->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  JSValue *subscriptVal = m_subscript->evaluate(exec);
 
   JSObject *baseObj = baseVal->toObject(exec);
@@ -1160 +1160 @@
   
   if (!funcVal->isObject()) {
-    return throwError(exec, TypeError, "Value %s (result of expression %s[%s]) is not object.", funcVal, base.get(), subscript.get());
+    return throwError(exec, TypeError, "Value %s (result of expression %s[%s]) is not object.", funcVal, m_base.get(), m_subscript.get());
   }
   
@@ -1166 +1166 @@
 
   if (!func->implementsCall()) {
-    return throwError(exec, TypeError, "Object %s (result of expression %s[%s]) does not allow calls.", funcVal, base.get(), subscript.get());
+    return throwError(exec, TypeError, "Object %s (result of expression %s[%s]) does not allow calls.", funcVal, m_base.get(), m_subscript.get());
   }
 
   List argList;
-  args->evaluateList(exec, argList);
+  m_args->evaluateList(exec, argList);
   KJS_CHECKEXCEPTIONVALUE
 
@@ -1195 +1195 @@
 void FunctionCallDotNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(args.get());
-    nodeStack.append(base.get());
+    nodeStack.append(m_args.get());
+    nodeStack.append(m_base.get());
 }
 
@@ -1202 +1202 @@
 JSValue* FunctionCallDotNode::inlineEvaluate(ExecState* exec)
 {
-  JSValue *baseVal = base->evaluate(exec);
+  JSValue *baseVal = m_base->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 
   JSObject *baseObj = baseVal->toObject(exec);
   PropertySlot slot;
-  JSValue *funcVal = baseObj->getPropertySlot(exec, ident, slot) ? slot.getValue(exec, baseObj, ident) : jsUndefined();
+  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, base.get(), ident);
+    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, base.get(), ident);
+    return throwError(exec, TypeError, dotExprDoesNotAllowCallsString(), funcVal, m_base.get(), m_ident);
 
   List argList;
-  args->evaluateList(exec, argList);
+  m_args->evaluateList(exec, argList);
   KJS_CHECKEXCEPTIONVALUE
 
@@ -1639 +1639 @@
 void VoidNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr.get());
+    nodeStack.append(m_expr.get());
 }
 
@@ -1645 +1645 @@
 JSValue *VoidNode::evaluate(ExecState *exec)
 {
-  expr->evaluate(exec);
+  m_expr->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 
@@ -2038 +2038 @@
 void NegateNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr.get());
+    nodeStack.append(m_expr.get());
 }
 
 // ECMA 11.4.7
-JSValue *NegateNode::evaluate(ExecState *exec)
+JSValue* NegateNode::evaluate(ExecState* exec)
 {
     // No need to check exception, caller will do so right after evaluate()
-    return jsNumber(-expr->evaluateToNumber(exec));
+    return jsNumber(-m_expr->evaluateToNumber(exec));
 }
 
@@ -2051 +2051 @@
 {
     // No need to check exception, caller will do so right after evaluateToNumber()
-    return -expr->evaluateToNumber(exec);
+    return -m_expr->evaluateToNumber(exec);
 }
 
@@ -2058 +2058 @@
 void BitwiseNotNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr.get());
+    nodeStack.append(m_expr.get());
 }
 
@@ -2064 +2064 @@
 int32_t BitwiseNotNode::inlineEvaluateToInt32(ExecState* exec)
 {
-    return ~expr->evaluateToInt32(exec);
+    return ~m_expr->evaluateToInt32(exec);
 }
 
@@ -2096 +2096 @@
 void LogicalNotNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr.get());
+    nodeStack.append(m_expr.get());
 }
 
@@ -2102 +2102 @@
 JSValue* LogicalNotNode::evaluate(ExecState* exec)
 {
-    return jsBoolean(!expr->evaluateToBoolean(exec));
+    return jsBoolean(!m_expr->evaluateToBoolean(exec));
 }
 
 bool LogicalNotNode::evaluateToBoolean(ExecState* exec)
 {
-    return !expr->evaluateToBoolean(exec);
+    return !m_expr->evaluateToBoolean(exec);
 }
 
@@ -2114 +2114 @@
 void MultNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(term1.get());
-    nodeStack.append(term2.get());
+    nodeStack.append(m_term1.get());
+    nodeStack.append(m_term2.get());
 }
 
@@ -2121 +2121 @@
 double MultNode::inlineEvaluateToNumber(ExecState* exec)
 {
-    double n1 = term1->evaluateToNumber(exec);
+    double n1 = m_term1->evaluateToNumber(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    double n2 = term2->evaluateToNumber(exec);
+    double n2 = m_term2->evaluateToNumber(exec);
     return n1 * n2;
 }
@@ -2154 +2154 @@
 void DivNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(term1.get());
-    nodeStack.append(term2.get());
+    nodeStack.append(m_term1.get());
+    nodeStack.append(m_term2.get());
 }
 
@@ -2161 +2161 @@
 double DivNode::inlineEvaluateToNumber(ExecState* exec)
 {
-    double n1 = term1->evaluateToNumber(exec);
+    double n1 = m_term1->evaluateToNumber(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    double n2 = term2->evaluateToNumber(exec);
+    double n2 = m_term2->evaluateToNumber(exec);
     return n1 / n2;
 }
@@ -2189 +2189 @@
 void ModNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(term1.get());
-    nodeStack.append(term2.get());
+    nodeStack.append(m_term1.get());
+    nodeStack.append(m_term2.get());
 }
 
@@ -2196 +2196 @@
 double ModNode::inlineEvaluateToNumber(ExecState* exec)
 {
-    double n1 = term1->evaluateToNumber(exec);
+    double n1 = m_term1->evaluateToNumber(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    double n2 = term2->evaluateToNumber(exec);
+    double n2 = m_term2->evaluateToNumber(exec);
     return fmod(n1, n2);
 }
@@ -2326 +2326 @@
 void AddNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(term1.get());
-    nodeStack.append(term2.get());
+    nodeStack.append(m_term1.get());
+    nodeStack.append(m_term2.get());
 }
 
@@ -2333 +2333 @@
 JSValue* AddNode::evaluate(ExecState* exec)
 {
-  JSValue* v1 = term1->evaluate(exec);
-  KJS_CHECKEXCEPTIONVALUE
-
-  JSValue* v2 = term2->evaluate(exec);
+  JSValue* v1 = m_term1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  JSValue* v2 = m_term2->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 
@@ -2344 +2344 @@
 double AddNode::inlineEvaluateToNumber(ExecState* exec)
 {
-    JSValue* v1 = term1->evaluate(exec);
+    JSValue* v1 = m_term1->evaluate(exec);
     KJS_CHECKEXCEPTIONNUMBER
     
-    JSValue* v2 = term2->evaluate(exec);
+    JSValue* v2 = m_term2->evaluate(exec);
     KJS_CHECKEXCEPTIONNUMBER
     
@@ -2370 +2370 @@
 double AddNumbersNode::inlineEvaluateToNumber(ExecState* exec)
 {
-    double n1 = term1->evaluateToNumber(exec);
+    double n1 = m_term1->evaluateToNumber(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    double n2 = term2->evaluateToNumber(exec);
+    double n2 = m_term2->evaluateToNumber(exec);
     return n1 + n2;
 }
@@ -2398 +2398 @@
 JSValue* AddStringsNode::evaluate(ExecState* exec)
 {
-    JSValue* v1 = term1->evaluate(exec);
+    JSValue* v1 = m_term1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     
-    JSValue* v2 = term2->evaluate(exec);
+    JSValue* v2 = m_term2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     
@@ -2409 +2409 @@
 JSValue* AddStringLeftNode::evaluate(ExecState* exec)
 {
-    JSValue* v1 = term1->evaluate(exec);
+    JSValue* v1 = m_term1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     
-    JSValue* v2 = term2->evaluate(exec);
+    JSValue* v2 = m_term2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     
@@ -2421 +2421 @@
 JSValue* AddStringRightNode::evaluate(ExecState* exec)
 {
-    JSValue* v1 = term1->evaluate(exec);
+    JSValue* v1 = m_term1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     
-    JSValue* v2 = term2->evaluate(exec);
+    JSValue* v2 = m_term2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     
@@ -2433 +2433 @@
 void SubNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(term1.get());
-    nodeStack.append(term2.get());
+    nodeStack.append(m_term1.get());
+    nodeStack.append(m_term2.get());
 }
 
@@ -2440 +2440 @@
 double SubNode::inlineEvaluateToNumber(ExecState* exec)
 {
-    double n1 = term1->evaluateToNumber(exec);
+    double n1 = m_term1->evaluateToNumber(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    double n2 = term2->evaluateToNumber(exec);
+    double n2 = m_term2->evaluateToNumber(exec);
     return n1 - n2;
 }
@@ -2470 +2470 @@
 void LeftShiftNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(term1.get());
-    nodeStack.append(term2.get());
+    nodeStack.append(m_term1.get());
+    nodeStack.append(m_term2.get());
 }
 
@@ -2477 +2477 @@
 int32_t LeftShiftNode::inlineEvaluateToInt32(ExecState* exec)
 {
-    int i1 = term1->evaluateToInt32(exec);
+    int i1 = m_term1->evaluateToInt32(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    unsigned int i2 = term2->evaluateToUInt32(exec) & 0x1f;
+    unsigned int i2 = m_term2->evaluateToUInt32(exec) & 0x1f;
     return (i1 << i2);
 }
@@ -2505 +2505 @@
 void RightShiftNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(term1.get());
-    nodeStack.append(term2.get());
+    nodeStack.append(m_term1.get());
+    nodeStack.append(m_term2.get());
 }
 
@@ -2512 +2512 @@
 int32_t RightShiftNode::inlineEvaluateToInt32(ExecState* exec)
 {
-    int i1 = term1->evaluateToInt32(exec);
+    int i1 = m_term1->evaluateToInt32(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    unsigned int i2 = term2->evaluateToUInt32(exec) & 0x1f;
+    unsigned int i2 = m_term2->evaluateToUInt32(exec) & 0x1f;
     return (i1 >> i2);
 }
@@ -2540 +2540 @@
 void UnsignedRightShiftNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(term1.get());
-    nodeStack.append(term2.get());
+    nodeStack.append(m_term1.get());
+    nodeStack.append(m_term2.get());
 }
 
@@ -2547 +2547 @@
 uint32_t UnsignedRightShiftNode::inlineEvaluateToUInt32(ExecState* exec)
 {
-    unsigned int i1 = term1->evaluateToUInt32(exec);
+    unsigned int i1 = m_term1->evaluateToUInt32(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    unsigned int i2 = term2->evaluateToUInt32(exec) & 0x1f;
+    unsigned int i2 = m_term2->evaluateToUInt32(exec) & 0x1f;
     return (i1 >> i2);
 }
@@ -2607 +2607 @@
 void LessNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2614 +2614 @@
 bool LessNode::inlineEvaluateToBoolean(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
     return lessThan(exec, v1, v2);
@@ -2633 +2633 @@
 bool LessNumbersNode::inlineEvaluateToBoolean(ExecState* exec)
 {
-    double n1 = expr1->evaluateToNumber(exec);
+    double n1 = m_expr1->evaluateToNumber(exec);
     KJS_CHECKEXCEPTIONVALUE
-    double n2 = expr2->evaluateToNumber(exec);
+    double n2 = m_expr2->evaluateToNumber(exec);
     return n1 < n2;
 }
@@ -2651 +2651 @@
 bool LessStringsNode::inlineEvaluateToBoolean(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     return static_cast<StringImp*>(v1)->value() < static_cast<StringImp*>(v2)->value();
 }
@@ -2669 +2669 @@
 void GreaterNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2676 +2676 @@
 bool GreaterNode::inlineEvaluateToBoolean(ExecState *exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
     return lessThan(exec, v2, v1);
@@ -2695 +2695 @@
 void LessEqNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2702 +2702 @@
 bool LessEqNode::inlineEvaluateToBoolean(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
     return lessThanEq(exec, v1, v2);
@@ -2721 +2721 @@
 void GreaterEqNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2728 +2728 @@
 bool GreaterEqNode::inlineEvaluateToBoolean(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
     return lessThanEq(exec, v2, v1);
@@ -2747 +2747 @@
 void InstanceOfNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2754 +2754 @@
 JSValue* InstanceOfNode::evaluate(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
 
     if (!v2->isObject())
-        return throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with instanceof operator.", v2, expr2.get());
+        return throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with instanceof operator.", v2, m_expr2.get());
 
     JSObject* o2 = static_cast<JSObject*>(v2);
@@ -2776 +2776 @@
 bool InstanceOfNode::evaluateToBoolean(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
 
     if (!v2->isObject()) {
-        throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with 'instanceof' operator.", v2, expr2.get());
+        throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with 'instanceof' operator.", v2, m_expr2.get());
         return false;
     }
@@ -2800 +2800 @@
 void InNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2807 +2807 @@
 JSValue* InNode::evaluate(ExecState *exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
 
     if (!v2->isObject())
-        return throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with 'in' operator.", v2, expr2.get());
+        return throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with 'in' operator.", v2, m_expr2.get());
 
     return jsBoolean(static_cast<JSObject*>(v2)->hasProperty(exec, Identifier(v1->toString(exec))));
@@ -2820 +2820 @@
 bool InNode::evaluateToBoolean(ExecState *exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
 
     if (!v2->isObject()) {
-        throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with 'in' operator.", v2, expr2.get());
+        throwError(exec, TypeError, "Value %s (result of expression %s) is not an object. Cannot be used with 'in' operator.", v2, m_expr2.get());
         return false;
     }
@@ -2837 +2837 @@
 void EqualNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2844 +2844 @@
 bool EqualNode::inlineEvaluateToBoolean(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
     
@@ -2864 +2864 @@
 void NotEqualNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2871 +2871 @@
 bool NotEqualNode::inlineEvaluateToBoolean(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
 
@@ -2891 +2891 @@
 void StrictEqualNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2898 +2898 @@
 bool StrictEqualNode::inlineEvaluateToBoolean(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
 
@@ -2918 +2918 @@
 void NotStrictEqualNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2925 +2925 @@
 bool NotStrictEqualNode::inlineEvaluateToBoolean(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
 
@@ -2947 +2947 @@
 void BitAndNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -2954 +2954 @@
 JSValue* BitAndNode::evaluate(ExecState* exec)
 {    
-    JSValue *v1 = expr1->evaluate(exec);
+    JSValue *v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    JSValue *v2 = expr2->evaluate(exec);
+    JSValue *v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
 
@@ -2964 +2964 @@
 int32_t BitAndNode::inlineEvaluateToInt32(ExecState* exec)
 {
-    int32_t i1 = expr1->evaluateToInt32(exec);
+    int32_t i1 = m_expr1->evaluateToInt32(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    int32_t i2 = expr2->evaluateToInt32(exec);
+    int32_t i2 = m_expr2->evaluateToInt32(exec);
     return (i1 & i2);
 }
@@ -2992 +2992 @@
 void BitXOrNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
 int32_t BitXOrNode::inlineEvaluateToInt32(ExecState* exec)
 {
-    int i1 = expr1->evaluateToInt32(exec);
+    int i1 = m_expr1->evaluateToInt32(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    int i2 = expr2->evaluateToInt32(exec);
+    int i2 = m_expr2->evaluateToInt32(exec);
     return (i1 ^ i2);
 }
@@ -3031 +3031 @@
 void BitOrNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
 int32_t BitOrNode::inlineEvaluateToInt32(ExecState* exec)
 {
-    int i1 = expr1->evaluateToInt32(exec);
+    int i1 = m_expr1->evaluateToInt32(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    int i2 = expr2->evaluateToInt32(exec);
+    int i2 = m_expr2->evaluateToInt32(exec);
     return (i1 | i2);
 }
@@ -3072 +3072 @@
 void LogicalAndNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -3079 +3079 @@
 JSValue* LogicalAndNode::evaluate(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     bool b1 = v1->toBoolean(exec);
@@ -3085 +3085 @@
     if (!b1)
         return v1;
-    JSValue* v2 = expr2->evaluate(exec);
+    JSValue* v2 = m_expr2->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     return v2;
@@ -3092 +3092 @@
 bool LogicalAndNode::evaluateToBoolean(ExecState* exec)
 {
-    bool b = expr1->evaluateToBoolean(exec);
+    bool b = m_expr1->evaluateToBoolean(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    return b && expr2->evaluateToBoolean(exec);
+    return b && m_expr2->evaluateToBoolean(exec);
 }
 
 void LogicalOrNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
 JSValue* LogicalOrNode::evaluate(ExecState* exec)
 {
-    JSValue* v1 = expr1->evaluate(exec);
+    JSValue* v1 = m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
     if (v1->toBoolean(exec))
         return v1;
-    return expr2->evaluate(exec);
+    return m_expr2->evaluate(exec);
 }
 
 bool LogicalOrNode::evaluateToBoolean(ExecState* exec)
 {
-    bool b = expr1->evaluateToBoolean(exec);
+    bool b = m_expr1->evaluateToBoolean(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    return b || expr2->evaluateToBoolean(exec);
+    return b || m_expr2->evaluateToBoolean(exec);
 }
 
@@ -3123 +3123 @@
 void ConditionalNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
-    nodeStack.append(logical.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
+    nodeStack.append(m_logical.get());
 }
 
@@ -3131 +3131 @@
 JSValue* ConditionalNode::evaluate(ExecState* exec)
 {
-    bool b = logical->evaluateToBoolean(exec);
+    bool b = m_logical->evaluateToBoolean(exec);
     KJS_CHECKEXCEPTIONVALUE
-    return b ? expr1->evaluate(exec) : expr2->evaluate(exec);
+    return b ? m_expr1->evaluate(exec) : m_expr2->evaluate(exec);
 }
 
 bool ConditionalNode::evaluateToBoolean(ExecState* exec)
 {
-    bool b = logical->evaluateToBoolean(exec);
+    bool b = m_logical->evaluateToBoolean(exec);
     KJS_CHECKEXCEPTIONBOOLEAN
-    return b ? expr1->evaluateToBoolean(exec) : expr2->evaluateToBoolean(exec);
+    return b ? m_expr1->evaluateToBoolean(exec) : m_expr2->evaluateToBoolean(exec);
 }
 
 double ConditionalNode::evaluateToNumber(ExecState* exec)
 {
-    bool b = logical->evaluateToBoolean(exec);
+    bool b = m_logical->evaluateToBoolean(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    return b ? expr1->evaluateToNumber(exec) : expr2->evaluateToNumber(exec);
+    return b ? m_expr1->evaluateToNumber(exec) : m_expr2->evaluateToNumber(exec);
 }
 
 int32_t ConditionalNode::evaluateToInt32(ExecState* exec)
 {
-    bool b = logical->evaluateToBoolean(exec);
+    bool b = m_logical->evaluateToBoolean(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    return b ? expr1->evaluateToInt32(exec) : expr2->evaluateToInt32(exec);
+    return b ? m_expr1->evaluateToInt32(exec) : m_expr2->evaluateToInt32(exec);
 }
 
 uint32_t ConditionalNode::evaluateToUInt32(ExecState* exec)
 {
-    bool b = logical->evaluateToBoolean(exec);
+    bool b = m_logical->evaluateToBoolean(exec);
     KJS_CHECKEXCEPTIONNUMBER
-    return b ? expr1->evaluateToUInt32(exec) : expr2->evaluateToUInt32(exec);
+    return b ? m_expr1->evaluateToUInt32(exec) : m_expr2->evaluateToUInt32(exec);
 }
 
@@ -3521 +3521 @@
 void CommaNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -3528 +3528 @@
 JSValue* CommaNode::evaluate(ExecState *exec)
 {
-    expr1->evaluate(exec);
+    m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTIONVALUE
-    return expr2->evaluate(exec);
+    return m_expr2->evaluate(exec);
 }
 
 // ------------------------------ ConstDeclNode ----------------------------------
 
-ConstDeclNode::ConstDeclNode(const Identifier& id, ExpressionNode* in)
-    : ident(id)
-    , init(in)
+ConstDeclNode::ConstDeclNode(const Identifier& ident, ExpressionNode* init)
+    : m_ident(ident)
+    , m_init(init)
 {
 }
@@ -3543 +3543 @@
 void ConstDeclNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (next)
-        nodeStack.append(next.get());
-    if (init)
-        nodeStack.append(init.get());
+    if (m_next)
+        nodeStack.append(m_next.get());
+    if (m_init)
+        nodeStack.append(m_init.get());
 }
 
@@ -3562 +3562 @@
     do {
         base = *iter;
-        if (base->getPropertySlot(exec, ident, slot))
+        if (base->getPropertySlot(exec, m_ident, slot))
             break;
         
@@ -3569 +3569 @@
     
     unsigned flags = 0;
-    base->getPropertyAttributes(ident, flags);
+    base->getPropertyAttributes(m_ident, flags);
     flags |= ReadOnly;
     
-    base->put(exec, ident, val, flags);
+    base->put(exec, m_ident, val, flags);
 }
 
@@ -3578 +3578 @@
 inline void ConstDeclNode::evaluateSingle(ExecState* exec)
 {
-    ASSERT(exec->variableObject()->hasOwnProperty(exec, ident) || exec->codeType() == EvalCode); // Guaranteed by processDeclarations.
+    ASSERT(exec->variableObject()->hasOwnProperty(exec, m_ident) || exec->codeType() == EvalCode); // Guaranteed by processDeclarations.
     const ScopeChain& chain = exec->scopeChain();
     JSObject* variableObject = exec->variableObject();
@@ -3586 +3586 @@
     bool inGlobalScope = ++chain.begin() == chain.end();
 
-    if (init) {
+    if (m_init) {
         if (inGlobalScope) {
-            JSValue* val = init->evaluate(exec);
+            JSValue* val = m_init->evaluate(exec);
             int flags = Internal;
             if (exec->codeType() != EvalCode)
                 flags |= DontDelete;
             flags |= ReadOnly;
-            variableObject->put(exec, ident, val, flags);
+            variableObject->put(exec, m_ident, val, flags);
         } else {
-            JSValue* val = init->evaluate(exec);
+            JSValue* val = m_init->evaluate(exec);
             KJS_CHECKEXCEPTIONVOID
 
@@ -3605 +3605 @@
 
             unsigned flags = 0;
-            variableObject->getPropertyAttributes(ident, flags);
+            variableObject->getPropertyAttributes(m_ident, flags);
             flags |= ReadOnly;
             
-            variableObject->put(exec, ident, val, flags);
+            variableObject->put(exec, m_ident, val, flags);
         }
     }
@@ -3617 +3617 @@
     evaluateSingle(exec);
 
-    if (ConstDeclNode* n = next.get()) {
+    if (ConstDeclNode* n = m_next.get()) {
         do {
             n->evaluateSingle(exec);
             KJS_CHECKEXCEPTIONVALUE
-            n = n->next.get();
+            n = n->m_next.get();
         } while (n);
     }
@@ -3631 +3631 @@
 void ConstStatementNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    ASSERT(next);
-    nodeStack.append(next.get());
+    ASSERT(m_next);
+    nodeStack.append(m_next.get());
 }
 
@@ -3638 +3638 @@
 JSValue* ConstStatementNode::execute(ExecState* exec)
 {
-    next->evaluate(exec);
+    m_next->evaluate(exec);
     KJS_CHECKEXCEPTION
 
@@ -3718 +3718 @@
 void ExprStatementNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    ASSERT(expr);
-    nodeStack.append(expr.get());
+    ASSERT(m_expr);
+    nodeStack.append(m_expr.get());
 }
 
@@ -3725 +3725 @@
 JSValue* ExprStatementNode::execute(ExecState* exec)
 {
-    JSValue* value = expr->evaluate(exec);
+    JSValue* value = m_expr->evaluate(exec);
     KJS_CHECKEXCEPTION
 
@@ -3735 +3735 @@
 void VarStatementNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    ASSERT(expr);
-    nodeStack.append(expr.get());
+    ASSERT(m_expr);
+    nodeStack.append(m_expr.get());
 }
 
 JSValue* VarStatementNode::execute(ExecState* exec)
 {
-    expr->evaluate(exec);
+    m_expr->evaluate(exec);
     KJS_CHECKEXCEPTION
 
@@ -3788 +3788 @@
 void DoWhileNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(statement.get());
-    nodeStack.append(expr.get());
+    nodeStack.append(m_statement.get());
+    nodeStack.append(m_expr.get());
 }
 
@@ -3799 +3799 @@
     while (1) {
         exec->pushIteration();
-        JSValue* statementValue = statement->execute(exec);
+        JSValue* statementValue = m_statement->execute(exec);
         exec->popIteration();
 
@@ -3809 +3809 @@
 
         if (exec->completionType() != Normal) {
-            if (exec->completionType() == Continue && ls.contains(exec->breakOrContinueTarget()))
+            if (exec->completionType() == Continue && m_labelStack.contains(exec->breakOrContinueTarget()))
                 goto continueDoWhileLoop;
-            if (exec->completionType() == Break && ls.contains(exec->breakOrContinueTarget()))
+            if (exec->completionType() == Break && m_labelStack.contains(exec->breakOrContinueTarget()))
                 break;
             return statementValue;
@@ -3817 +3817 @@
 
 continueDoWhileLoop:
-        bool b = expr->evaluateToBoolean(exec);
+        bool b = m_expr->evaluateToBoolean(exec);
         KJS_CHECKEXCEPTION
         if (!b)
@@ -3830 +3830 @@
 void WhileNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(statement.get());
-    nodeStack.append(expr.get());
+    nodeStack.append(m_statement.get());
+    nodeStack.append(m_expr.get());
 }
 
@@ -3840 +3840 @@
 
     while (1) {
-        bool b = expr->evaluateToBoolean(exec);
+        bool b = m_expr->evaluateToBoolean(exec);
         KJS_CHECKEXCEPTION
         if (!b)
@@ -3846 +3846 @@
 
         exec->pushIteration();
-        JSValue* statementValue = statement->execute(exec);
+        JSValue* statementValue = m_statement->execute(exec);
         exec->popIteration();
 
@@ -3856 +3856 @@
 
         if (exec->completionType() != Normal) {
-            if (exec->completionType() == Continue && ls.contains(exec->breakOrContinueTarget()))
+            if (exec->completionType() == Continue && m_labelStack.contains(exec->breakOrContinueTarget()))
                 continue;
-            if (exec->completionType() == Break && ls.contains(exec->breakOrContinueTarget()))
+            if (exec->completionType() == Break && m_labelStack.contains(exec->breakOrContinueTarget()))
                 break;
             return statementValue;
@@ -3871 +3871 @@
 void ForNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(statement.get());
-    nodeStack.append(expr3.get());
-    nodeStack.append(expr2.get());
-    nodeStack.append(expr1.get());
+    nodeStack.append(m_statement.get());
+    nodeStack.append(m_expr3.get());
+    nodeStack.append(m_expr2.get());
+    nodeStack.append(m_expr1.get());
 }
 
@@ -3882 +3882 @@
     JSValue* value = 0;
 
-    expr1->evaluate(exec);
+    m_expr1->evaluate(exec);
     KJS_CHECKEXCEPTION
 
     while (1) {
-        bool b = expr2->evaluateToBoolean(exec);
+        bool b = m_expr2->evaluateToBoolean(exec);
         KJS_CHECKEXCEPTION
         if (!b)
@@ -3892 +3892 @@
 
         exec->pushIteration();
-        JSValue* statementValue = statement->execute(exec);
+        JSValue* statementValue = m_statement->execute(exec);
         exec->popIteration();
         if (statementValue)
@@ -3901 +3901 @@
 
         if (exec->completionType() != Normal) {
-            if (exec->completionType() == Continue && ls.contains(exec->breakOrContinueTarget()))
+            if (exec->completionType() == Continue && m_labelStack.contains(exec->breakOrContinueTarget()))
                 goto continueForLoop;
-            if (exec->completionType() == Break && ls.contains(exec->breakOrContinueTarget()))
+            if (exec->completionType() == Break && m_labelStack.contains(exec->breakOrContinueTarget()))
                 break;
             return statementValue;
@@ -3909 +3909 @@
 
 continueForLoop:
-        expr3->evaluate(exec);
+        m_expr3->evaluate(exec);
         KJS_CHECKEXCEPTION
     }
@@ -3918 +3918 @@
 // ------------------------------ ForInNode ------------------------------------
 
-ForInNode::ForInNode(ExpressionNode* l, ExpressionNode* e, StatementNode* s)
-    : init(0L), lexpr(l), expr(e), statement(s), identIsVarDecl(false)
-{
-}
-
-ForInNode::ForInNode(const Identifier& i, ExpressionNode* in, ExpressionNode* e, StatementNode* s)
-    : ident(i), lexpr(new ResolveNode(i)), expr(e), statement(s), identIsVarDecl(true)
+ForInNode::ForInNode(ExpressionNode* l, ExpressionNode* expr, StatementNode* statement)
+    : m_init(0L)
+    , m_lexpr(l)
+    , m_expr(expr)
+    , m_statement(statement)
+    , m_identIsVarDecl(false)
+{
+}
+
+ForInNode::ForInNode(const Identifier& ident, ExpressionNode* in, ExpressionNode* expr, StatementNode* statement)
+    : m_ident(ident)
+    , m_lexpr(new ResolveNode(ident))
+    , m_expr(expr)
+    , m_statement(statement)
+    , m_identIsVarDecl(true)
 {
   if (in)
-      init = new AssignResolveNode(i, in);
+      m_init = new AssignResolveNode(ident, in);
   // for( var foo = bar in baz )
 }
@@ -3933 +3941 @@
 void ForInNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(statement.get());
-    nodeStack.append(expr.get());
-    nodeStack.append(lexpr.get());
-    if (init)
-        nodeStack.append(init.get());
+    nodeStack.append(m_statement.get());
+    nodeStack.append(m_expr.get());
+    nodeStack.append(m_lexpr.get());
+    if (m_init)
+        nodeStack.append(m_init.get());
 }
 
@@ -3945 +3953 @@
   JSValue* value = 0;
 
-  if (init) {
-    init->evaluate(exec);
+  if (m_init) {
+    m_init->evaluate(exec);
     KJS_CHECKEXCEPTION
   }
 
-  JSValue* e = expr->evaluate(exec);
+  JSValue* e = m_expr->evaluate(exec);
   KJS_CHECKEXCEPTION
 
@@ -3970 +3978 @@
       JSValue *str = jsOwnedString(name.ustring());
 
-      if (lexpr->isResolveNode()) {
-        const Identifier &ident = static_cast<ResolveNode *>(lexpr.get())->identifier();
+      if (m_lexpr->isResolveNode()) {
+        const Identifier& ident = static_cast<ResolveNode*>(m_lexpr.get())->identifier();
 
         const ScopeChain& chain = exec->scopeChain();
@@ -3993 +4001 @@
         if (iter == end)
             o->put(exec, ident, str);
-    } else if (lexpr->isDotAccessorNode()) {
-        const Identifier& ident = static_cast<DotAccessorNode *>(lexpr.get())->identifier();
-        JSValue *v = static_cast<DotAccessorNode *>(lexpr.get())->base()->evaluate(exec);
+    } 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);
@@ -4001 +4009 @@
         o->put(exec, ident, str);
     } else {
-        ASSERT(lexpr->isBracketAccessorNode());
-        JSValue *v = static_cast<BracketAccessorNode *>(lexpr.get())->base()->evaluate(exec);
+        ASSERT(m_lexpr->isBracketAccessorNode());
+        JSValue* v = static_cast<BracketAccessorNode*>(m_lexpr.get())->base()->evaluate(exec);
         KJS_CHECKEXCEPTION
-        JSValue *v2 = static_cast<BracketAccessorNode *>(lexpr.get())->subscript()->evaluate(exec);
+        JSValue* v2 = static_cast<BracketAccessorNode*>(m_lexpr.get())->subscript()->evaluate(exec);
         KJS_CHECKEXCEPTION
         JSObject *o = v->toObject(exec);
@@ -4017 +4025 @@
 
     exec->pushIteration();
-    JSValue* statementValue = statement->execute(exec);
+    JSValue* statementValue = m_statement->execute(exec);
     exec->popIteration();
     if (statementValue)
@@ -4023 +4031 @@
 
     if (exec->completionType() != Normal) {
-        if (exec->completionType() == Continue && ls.contains(exec->breakOrContinueTarget()))
+        if (exec->completionType() == Continue && m_labelStack.contains(exec->breakOrContinueTarget()))
             continue;
-        if (exec->completionType() == Break && ls.contains(exec->breakOrContinueTarget()))
+        if (exec->completionType() == Break && m_labelStack.contains(exec->breakOrContinueTarget()))
             break;
         return statementValue;
@@ -4039 +4047 @@
 JSValue* ContinueNode::execute(ExecState* exec)
 {
-  if (ident.isEmpty() && !exec->inIteration())
+  if (m_ident.isEmpty() && !exec->inIteration())
     return setErrorCompletion(exec, SyntaxError, "Invalid continue statement.");
-  if (!ident.isEmpty() && !exec->seenLabels().contains(ident))
-    return setErrorCompletion(exec, SyntaxError, "Label %s not found.", ident);
-  return exec->setContinueCompletion(&ident);
+  if (!m_ident.isEmpty() && !exec->seenLabels().contains(m_ident))
+    return setErrorCompletion(exec, SyntaxError, "Label %s not found.", m_ident);
+  return exec->setContinueCompletion(&m_ident);
 }
 
@@ -4051 +4059 @@
 JSValue* BreakNode::execute(ExecState *exec)
 {
-  if (ident.isEmpty() && !exec->inIteration() && !exec->inSwitch())
+  if (m_ident.isEmpty() && !exec->inIteration() && !exec->inSwitch())
     return setErrorCompletion(exec, SyntaxError, "Invalid break statement.");
-  if (!ident.isEmpty() && !exec->seenLabels().contains(ident))
+  if (!m_ident.isEmpty() && !exec->seenLabels().contains(m_ident))
     return setErrorCompletion(exec, SyntaxError, "Label %s not found.");
-  return exec->setBreakCompletion(&ident);
+  return exec->setBreakCompletion(&m_ident);
 }
 
@@ -4062 +4070 @@
 void ReturnNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (value)
-        nodeStack.append(value.get());
+    if (m_value)
+        nodeStack.append(m_value.get());
 }
 
@@ -4073 +4081 @@
     return setErrorCompletion(exec, SyntaxError, "Invalid return statement.");
 
-  if (!value)
+  if (!m_value)
     return exec->setReturnValueCompletion(jsUndefined());
 
-  JSValue* v = value->evaluate(exec);
+  JSValue* v = m_value->evaluate(exec);
   KJS_CHECKEXCEPTION
 
@@ -4087 +4095 @@
 {
     // Can't optimize within statement because "with" introduces a dynamic scope.
-    nodeStack.append(expr.get());
+    nodeStack.append(m_expr.get());
 }
 
@@ -4093 +4101 @@
 JSValue* WithNode::execute(ExecState *exec)
 {
-  JSValue *v = expr->evaluate(exec);
+  JSValue *v = m_expr->evaluate(exec);
   KJS_CHECKEXCEPTION
   JSObject *o = v->toObject(exec);
@@ -4099 +4107 @@
   exec->dynamicGlobalObject()->tearOffActivation(exec);
   exec->pushScope(o);
-  JSValue* value = statement->execute(exec);
+  JSValue* value = m_statement->execute(exec);
   exec->popScope();
 
@@ -4109 +4117 @@
 void CaseClauseNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (expr)
-        nodeStack.append(expr.get());
+    if (m_expr)
+        nodeStack.append(m_expr.get());
     statementListPushFIFO(m_children, nodeStack);
 }
@@ -4117 +4125 @@
 JSValue *CaseClauseNode::evaluate(ExecState *exec)
 {
-  JSValue *v = expr->evaluate(exec);
+  JSValue *v = m_expr->evaluate(exec);
   KJS_CHECKEXCEPTIONVALUE
 
@@ -4133 +4141 @@
 void ClauseListNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (next)
-        nodeStack.append(next.get());
-    nodeStack.append(clause.get());
+    if (m_next)
+        nodeStack.append(m_next.get());
+    nodeStack.append(m_clause.get());
 }
 
 // ------------------------------ CaseBlockNode --------------------------------
 
-CaseBlockNode::CaseBlockNode(ClauseListNode* l1, CaseClauseNode* d, ClauseListNode* l2)
-    : list1(l1)
-    , def(d)
-    , list2(l2)
+CaseBlockNode::CaseBlockNode(ClauseListNode* list1, CaseClauseNode* defaultClause, ClauseListNode* list2)
+    : m_list1(list1)
+    , m_defaultClause(defaultClause)
+    , m_list2(list2)
 {
 }
@@ -4149 +4157 @@
 void CaseBlockNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    if (list2)
-        nodeStack.append(list2.get());
-    if (def)
-        nodeStack.append(def.get());
-    if (list1)
-        nodeStack.append(list1.get());
+    if (m_list2)
+        nodeStack.append(m_list2.get());
+    if (m_defaultClause)
+        nodeStack.append(m_defaultClause.get());
+    if (m_list1)
+        nodeStack.append(m_list1.get());
 }
 
@@ -4160 +4168 @@
 JSValue* CaseBlockNode::executeBlock(ExecState* exec, JSValue* input)
 {
-  ClauseListNode* a = list1.get();
+  ClauseListNode* a = m_list1.get();
     while (a) {
       CaseClauseNode* clause = a->getClause();
@@ -4179 +4187 @@
     }
 
-  ClauseListNode* b = list2.get();
+  ClauseListNode* b = m_list2.get();
   while (b) {
     CaseClauseNode* clause = b->getClause();
@@ -4194 +4202 @@
 
   // default clause
-  if (def) {
-    JSValue* res = def->executeStatements(exec);
+  if (m_defaultClause) {
+    JSValue* res = m_defaultClause->executeStatements(exec);
     if (exec->completionType() != Normal)
       return res;
   }
-  b = list2.get();
+  b = m_list2.get();
  step18:
   while (b) {
@@ -4219 +4227 @@
 void SwitchNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(block.get());
-    nodeStack.append(expr.get());
+    nodeStack.append(m_block.get());
+    nodeStack.append(m_expr.get());
 }
 
@@ -4226 +4234 @@
 JSValue* SwitchNode::execute(ExecState* exec)
 {
-  JSValue *v = expr->evaluate(exec);
+  JSValue *v = m_expr->evaluate(exec);
   KJS_CHECKEXCEPTION
 
   exec->pushSwitch();
-  JSValue* result = block->executeBlock(exec, v);
+  JSValue* result = m_block->executeBlock(exec, v);
   exec->popSwitch();
 
-  if (exec->completionType() == Break && ls.contains(exec->breakOrContinueTarget()))
+  if (exec->completionType() == Break && m_labelStack.contains(exec->breakOrContinueTarget()))
     exec->setCompletionType(Normal);
   return result;
@@ -4242 +4250 @@
 void LabelNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(statement.get());
+    nodeStack.append(m_statement.get());
 }
 
 // ECMA 12.12
-JSValue* LabelNode::execute(ExecState *exec)
-{
-  if (!exec->seenLabels().push(label))
-    return setErrorCompletion(exec, SyntaxError, "Duplicated label %s found.", label);
-  JSValue* result = statement->execute(exec);
+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() == label)
+  if (exec->completionType() == Break && exec->breakOrContinueTarget() == m_label)
     exec->setCompletionType(Normal);
   return result;
@@ -4262 +4270 @@
 void ThrowNode::optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack& nodeStack)
 {
-    nodeStack.append(expr.get());
+    nodeStack.append(m_expr.get());
 }
 
@@ -4268 +4276 @@
 JSValue* ThrowNode::execute(ExecState* exec)
 {
-  JSValue *v = expr->evaluate(exec);
+  JSValue *v = m_expr->evaluate(exec);
   KJS_CHECKEXCEPTION
 
@@ -4280 +4288 @@
 {
     // Can't optimize within catchBlock because "catch" introduces a dynamic scope.
-    if (finallyBlock)
-        nodeStack.append(finallyBlock.get());
-    nodeStack.append(tryBlock.get());
+    if (m_finallyBlock)
+        nodeStack.append(m_finallyBlock.get());
+    nodeStack.append(m_tryBlock.get());
 }
 
 // ECMA 12.14
-JSValue* TryNode::execute(ExecState *exec)
-{
-  JSValue* result = tryBlock->execute(exec);
+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 (catchBlock && exec->completionType() == Throw) {
+  if (m_catchBlock && exec->completionType() == Throw) {
     JSObject* obj = new JSObject;
-    obj->put(exec, exceptionIdent, result, DontDelete);
+    obj->put(exec, m_exceptionIdent, result, DontDelete);
     exec->dynamicGlobalObject()->tearOffActivation(exec);
     exec->pushScope(obj);
-    result = catchBlock->execute(exec);
+    result = m_catchBlock->execute(exec);
     exec->popScope();
   }
 
-  if (finallyBlock) {
+  if (m_finallyBlock) {
     ComplType savedCompletionType = exec->completionType();
-    JSValue* finallyResult = finallyBlock->execute(exec);
+    JSValue* finallyResult = m_finallyBlock->execute(exec);
     if (exec->completionType() != Normal)
         result = finallyResult;
@@ -4381 +4389 @@
 
     for (size_t i = 0, size = m_functionStack.size(); i < size; ++i, ++localStorageIndex) {
-        UString::Rep* rep = m_functionStack[i]->ident.ustring().rep();
+        UString::Rep* rep = m_functionStack[i]->m_ident.ustring().rep();
         symbolTable.set(rep, localStorageIndex);
     }
@@ -4412 +4420 @@
     m_functionIndexes.resize(size);
     for (size_t i = 0; i < size; ++i) {
-        UString::Rep* rep = m_functionStack[i]->ident.ustring().rep();
+        UString::Rep* rep = m_functionStack[i]->m_ident.ustring().rep();
         pair<SymbolTable::iterator, bool> result = symbolTable.add(rep, localStorageIndex);
         m_functionIndexes[i] = result.first->second;
@@ -4582 +4590 @@
     for (i = 0, size = m_functionStack.size(); i < size; ++i) {
         FuncDeclNode* node = m_functionStack[i];
-        variableObject->put(exec, node->ident, node->makeFunction(exec), minAttributes);
+        variableObject->put(exec, node->m_ident, node->makeFunction(exec), minAttributes);
     }
 }
@@ -4652 +4660 @@
 void FuncDeclNode::addParams() 
 {
-  for (ParameterNode *p = param.get(); p != 0L; p = p->nextParam())
-    body->parameters().append(p->ident());
+  for (ParameterNode *p = m_parameter.get(); p != 0L; p = p->nextParam())
+    m_body->parameters().append(p->ident());
 }
 
 FunctionImp* FuncDeclNode::makeFunction(ExecState* exec)
 {
-  FunctionImp *func = new FunctionImp(exec, ident, body.get(), exec->scopeChain());
+  FunctionImp *func = new FunctionImp(exec, m_ident, m_body.get(), exec->scopeChain());
 
   JSObject* proto = exec->lexicalGlobalObject()->objectConstructor()->construct(exec, exec->emptyList());
@@ -4664 +4672 @@
   func->put(exec, exec->propertyNames().prototype, proto, Internal|DontDelete);
 
-  func->put(exec, exec->propertyNames().length, jsNumber(body->parameters().size()), ReadOnly|DontDelete|DontEnum);
+  func->put(exec, exec->propertyNames().length, jsNumber(m_body->parameters().size()), ReadOnly|DontDelete|DontEnum);
   return func;
 }
@@ -4678 +4686 @@
 void FuncExprNode::addParams()
 {
-  for (ParameterNode *p = param.get(); p != 0L; p = p->nextParam())
-    body->parameters().append(p->ident());
+  for (ParameterNode* p = m_parameter.get(); p != 0L; p = p->nextParam())
+    m_body->parameters().append(p->ident());
 }
 
@@ -4686 +4694 @@
   exec->dynamicGlobalObject()->tearOffActivation(exec);
   
-  bool named = !ident.isNull();
+  bool named = !m_ident.isNull();
   JSObject *functionScopeObject = 0;
 
@@ -4697 +4705 @@
   }
 
-  FunctionImp* func = new FunctionImp(exec, ident, body.get(), exec->scopeChain());
+  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);
@@ -4703 +4711 @@
 
   if (named) {
-    functionScopeObject->put(exec, ident, func, Internal | ReadOnly | (exec->codeType() == EvalCode ? 0 : DontDelete));
+    functionScopeObject->put(exec, m_ident, func, Internal | ReadOnly | (exec->codeType() == EvalCode ? 0 : DontDelete));
     exec->popScope();
   }

trunk/JavaScriptCore/kjs/nodes.h

@@ -207 +207 @@
     int lastLine() const KJS_FAST_CALL { return m_lastLine; }
     virtual JSValue* execute(ExecState *exec) KJS_FAST_CALL = 0;
-    void pushLabel(const Identifier &id) KJS_FAST_CALL { ls.push(id); }
+    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 ls;
+    LabelStack m_labelStack;
   private:
     int m_lastLine;
@@ -316 +316 @@
   class ResolveNode : public ExpressionNode {
   public:
-    ResolveNode(const Identifier &s) KJS_FAST_CALL 
-        : ident(s) 
+    ResolveNode(const Identifier& ident) KJS_FAST_CALL 
+        : m_ident(ident)
     { 
     }
@@ -324 +324 @@
     ResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
         : ExpressionNode(PlacementNewAdopt)
-        , ident(PlacementNewAdopt)
+        , m_ident(PlacementNewAdopt)
     {
     }
@@ -340 +340 @@
     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 ident; }
+    const Identifier& identifier() const KJS_FAST_CALL { return m_ident; }
 
   protected:
     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-    Identifier ident;
-    size_t index; // Used by LocalVarAccessNode.
+    Identifier m_ident;
+    size_t m_index; // Used by LocalVarAccessNode.
   };
 
@@ -355 +355 @@
     {
         ASSERT(i != missingSymbolMarker());
-        index = i;
+        m_index = i;
     }
     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
@@ -368 +368 @@
   class ElementNode : public Node {
   public:
-    ElementNode(int e, ExpressionNode* n) KJS_FAST_CALL : elision(e), node(n) { }
-    ElementNode(ElementNode* l, int e, ExpressionNode* n) KJS_FAST_CALL
-      : elision(e), node(n) { l->next = this; }
+    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 next.release(); }
+    PassRefPtr<ElementNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
 
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
@@ -381 +382 @@
   private:
     friend class ArrayNode;
-    ListRefPtr<ElementNode> next;
-    int elision;
-    RefPtr<ExpressionNode> node;
+    ListRefPtr<ElementNode> m_next;
+    int m_elision;
+    RefPtr<ExpressionNode> m_node;
   };
 
   class ArrayNode : public ExpressionNode {
   public:
-    ArrayNode(int e) KJS_FAST_CALL : elision(e), opt(true) { }
-    ArrayNode(ElementNode* ele) KJS_FAST_CALL
-      : element(ele), elision(0), opt(false) { }
-    ArrayNode(int eli, ElementNode* ele) KJS_FAST_CALL
-      : element(ele), elision(eli), opt(true) { }
+    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;
@@ -398 +400 @@
     virtual Precedence precedence() const { return PrecPrimary; }
   private:
-    RefPtr<ElementNode> element;
-    int elision;
-    bool opt;
+    RefPtr<ElementNode> m_element;
+    int m_elision;
+    bool m_opt;
   };
 
@@ -407 +409 @@
     enum Type { Constant, Getter, Setter };
     PropertyNode(const Identifier& n, ExpressionNode* a, Type t) KJS_FAST_CALL
-      : m_name(n), assign(a), type(t) { }
+      : 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;
@@ -418 +420 @@
     friend class PropertyListNode;
     Identifier m_name;
-    RefPtr<ExpressionNode> assign;
-    Type type;
+    RefPtr<ExpressionNode> m_assign;
+    Type m_type;
   };
   
   class PropertyListNode : public Node {
   public:
-    PropertyListNode(PropertyNode* n) KJS_FAST_CALL
-      : node(n) { }
-    PropertyListNode(PropertyNode* n, PropertyListNode* l) KJS_FAST_CALL
-      : node(n) { l->next = this; }
+    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;
@@ -433 +435 @@
 
     JSValue* evaluate(ExecState*) KJS_FAST_CALL;
-    PassRefPtr<PropertyListNode> releaseNext() KJS_FAST_CALL { return next.release(); }
+    PassRefPtr<PropertyListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
 
   private:
     friend class ObjectLiteralNode;
-    RefPtr<PropertyNode> node;
-    ListRefPtr<PropertyListNode> next;
+    RefPtr<PropertyNode> m_node;
+    ListRefPtr<PropertyListNode> m_next;
   };
 
@@ -444 +446 @@
   public:
     ObjectLiteralNode() KJS_FAST_CALL { }
-    ObjectLiteralNode(PropertyListNode* l) KJS_FAST_CALL : list(l) { }
+    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;
@@ -451 +453 @@
     virtual bool needsParensIfLeftmost() const { return true; }
   private:
-    RefPtr<PropertyListNode> list;
+    RefPtr<PropertyListNode> m_list;
   };
 
   class BracketAccessorNode : public ExpressionNode {
   public:
-    BracketAccessorNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL : expr1(e1), expr2(e2) {}
+    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;
@@ -468 +471 @@
     virtual bool isLocation() const KJS_FAST_CALL { return true; }
     virtual bool isBracketAccessorNode() const KJS_FAST_CALL { return true; }
-    ExpressionNode* base() KJS_FAST_CALL { return expr1.get(); }
-    ExpressionNode* subscript() KJS_FAST_CALL { return expr2.get(); }
+    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> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_base;
+    RefPtr<ExpressionNode> m_subscript;
   };
 
   class DotAccessorNode : public ExpressionNode {
   public:
-    DotAccessorNode(ExpressionNode* e, const Identifier& s) KJS_FAST_CALL : expr(e), ident(s) { }
+    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;
@@ -491 +494 @@
     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 expr.get(); }
-    const Identifier& identifier() const KJS_FAST_CALL { return ident; }
+    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> expr;
-    Identifier ident;
+    RefPtr<ExpressionNode> m_base;
+    Identifier m_ident;
   };
 
   class ArgumentListNode : public Node {
   public:
-    ArgumentListNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
-    ArgumentListNode(ArgumentListNode* l, ExpressionNode* e) KJS_FAST_CALL 
-      : expr(e) { l->next = this; }
+    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;
@@ -510 +514 @@
 
     void evaluateList(ExecState*, List&) KJS_FAST_CALL;
-    PassRefPtr<ArgumentListNode> releaseNext() KJS_FAST_CALL { return next.release(); }
+    PassRefPtr<ArgumentListNode> releaseNext() KJS_FAST_CALL { return m_next.release(); }
 
   private:
     friend class ArgumentsNode;
-    ListRefPtr<ArgumentListNode> next;
-    RefPtr<ExpressionNode> expr;
+    ListRefPtr<ArgumentListNode> m_next;
+    RefPtr<ExpressionNode> m_expr;
   };
 
@@ -521 +525 @@
   public:
     ArgumentsNode() KJS_FAST_CALL { }
-    ArgumentsNode(ArgumentListNode* l) KJS_FAST_CALL
-      : listNode(l) { }
+    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 (listNode) listNode->evaluateList(exec, list); }
-
-  private:
-    RefPtr<ArgumentListNode> listNode;
+    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* e) KJS_FAST_CALL : expr(e) {}
-    NewExprNode(ExpressionNode* e, ArgumentsNode* a) KJS_FAST_CALL : expr(e), args(a) {}
+    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;
@@ -547 +553 @@
   private:
     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-    RefPtr<ExpressionNode> expr;
-    RefPtr<ArgumentsNode> args;
+    RefPtr<ExpressionNode> m_expr;
+    RefPtr<ArgumentsNode> m_args;
   };
 
   class FunctionCallValueNode : public ExpressionNode {
   public:
-    FunctionCallValueNode(ExpressionNode* e, ArgumentsNode* a) KJS_FAST_CALL : expr(e), args(a) {}
+    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;
@@ -559 +566 @@
     virtual Precedence precedence() const { return PrecCall; }
   private:
-    RefPtr<ExpressionNode> expr;
-    RefPtr<ArgumentsNode> args;
+    RefPtr<ExpressionNode> m_expr;
+    RefPtr<ArgumentsNode> m_args;
   };
 
   class FunctionCallResolveNode : public ExpressionNode {
   public:
-    FunctionCallResolveNode(const Identifier& i, ArgumentsNode* a) KJS_FAST_CALL
-        : ident(i)
-        , args(a)
+    FunctionCallResolveNode(const Identifier& ident, ArgumentsNode* args) KJS_FAST_CALL
+        : m_ident(ident)
+        , m_args(args)
     {
     }
@@ -573 +580 @@
     FunctionCallResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
         : ExpressionNode(PlacementNewAdopt)
-        , ident(PlacementNewAdopt)
-        , args(PlacementNewAdopt)
+        , m_ident(PlacementNewAdopt)
+        , m_args(PlacementNewAdopt)
     {
     }
@@ -589 +596 @@
   protected:
     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-    Identifier ident;
-    RefPtr<ArgumentsNode> args;
-    size_t index; // Used by LocalVarFunctionCallNode.
+    Identifier m_ident;
+    RefPtr<ArgumentsNode> m_args;
+    size_t m_index; // Used by LocalVarFunctionCallNode.
   };
 
@@ -600 +607 @@
     {
         ASSERT(i != missingSymbolMarker());
-        index = i;
+        m_index = i;
     }
 
@@ -614 +621 @@
   class FunctionCallBracketNode : public ExpressionNode {
   public:
-    FunctionCallBracketNode(ExpressionNode* b, ExpressionNode* s, ArgumentsNode* a) KJS_FAST_CALL : base(b), subscript(s), args(a) {}
+    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;
@@ -620 +628 @@
     virtual Precedence precedence() const { return PrecCall; }
   protected:
-    RefPtr<ExpressionNode> base;
-    RefPtr<ExpressionNode> subscript;
-    RefPtr<ArgumentsNode> args;
+    RefPtr<ExpressionNode> m_base;
+    RefPtr<ExpressionNode> m_subscript;
+    RefPtr<ArgumentsNode> m_args;
   };
 
   class FunctionCallDotNode : public ExpressionNode {
   public:
-    FunctionCallDotNode(ExpressionNode* b, const Identifier& i, ArgumentsNode* a) KJS_FAST_CALL : base(b), ident(i), args(a) {}
+    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;
@@ -638 +647 @@
   private:
     ALWAYS_INLINE JSValue* inlineEvaluate(ExecState*);
-    RefPtr<ExpressionNode> base;
-    Identifier ident;
-    RefPtr<ArgumentsNode> args;
+    RefPtr<ExpressionNode> m_base;
+    Identifier m_ident;
+    RefPtr<ArgumentsNode> m_args;
   };
 
@@ -746 +755 @@
   class PostfixBracketNode : public ExpressionNode {
   public:
-    PostfixBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : m_base(b), m_subscript(s) {}
+    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; }
@@ -756 +766 @@
   class PostIncBracketNode : public PostfixBracketNode {
   public:
-    PostIncBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : PostfixBracketNode(b, s) {}
+    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;
@@ -763 +774 @@
   class PostDecBracketNode : public PostfixBracketNode {
   public:
-    PostDecBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : PostfixBracketNode(b, s) {}
+    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;
@@ -770 +782 @@
     class PostfixDotNode : public ExpressionNode {
   public:
-    PostfixDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : m_base(b), m_ident(i) {}
+    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; }
@@ -780 +793 @@
   class PostIncDotNode : public PostfixDotNode {
   public:
-    PostIncDotNode(ExpressionNode*  b, const Identifier& i) KJS_FAST_CALL : PostfixDotNode(b, i) {}
+    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;
@@ -787 +801 @@
   class PostDecDotNode : public PostfixDotNode {
   public:
-    PostDecDotNode(ExpressionNode*  b, const Identifier& i) KJS_FAST_CALL : PostfixDotNode(b, i) {}
+    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;
@@ -794 +809 @@
   class PostfixErrorNode : public ExpressionNode {
   public:
-    PostfixErrorNode(ExpressionNode* e, Operator o) KJS_FAST_CALL : m_expr(e), m_oper(o) {}
+    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;
@@ -805 +821 @@
   class DeleteResolveNode : public ExpressionNode {
   public:
-    DeleteResolveNode(const Identifier& i) KJS_FAST_CALL : m_ident(i) {}
+    DeleteResolveNode(const Identifier& ident) KJS_FAST_CALL
+        : m_ident(ident)
+    {
+    }
     DeleteResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
         : ExpressionNode(PlacementNewAdopt)
@@ -832 +851 @@
   class DeleteBracketNode : public ExpressionNode {
   public:
-    DeleteBracketNode(ExpressionNode* base, ExpressionNode* subscript) KJS_FAST_CALL : m_base(base), m_subscript(subscript) {}
+    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;
@@ -844 +864 @@
   class DeleteDotNode : public ExpressionNode {
   public:
-    DeleteDotNode(ExpressionNode* base, const Identifier& i) KJS_FAST_CALL : m_base(base), m_ident(i) {}
+    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;
@@ -856 +877 @@
   class DeleteValueNode : public ExpressionNode {
   public:
-    DeleteValueNode(ExpressionNode* e) KJS_FAST_CALL : m_expr(e) {}
+    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;
@@ -867 +889 @@
   class VoidNode : public ExpressionNode {
   public:
-    VoidNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) {}
+    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;
@@ -873 +896 @@
     virtual Precedence precedence() const { return PrecUnary; }
   private:
-    RefPtr<ExpressionNode> expr;
+    RefPtr<ExpressionNode> m_expr;
   };
 
   class TypeOfResolveNode : public ExpressionNode {
   public:
-    TypeOfResolveNode(const Identifier &s) KJS_FAST_CALL 
-        : ExpressionNode(StringType), m_ident(s) {}
+    TypeOfResolveNode(const Identifier& ident) KJS_FAST_CALL 
+        : ExpressionNode(StringType)
+        , m_ident(ident)
+    {
+    }
     
     TypeOfResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
@@ -927 +953 @@
   class PreIncResolveNode : public PrePostResolveNode {
   public:
-    PreIncResolveNode(const Identifier &s) KJS_FAST_CALL 
-        : PrePostResolveNode(s) 
+    PreIncResolveNode(const Identifier& ident) KJS_FAST_CALL 
+        : PrePostResolveNode(ident)
     { 
     }
@@ -969 +995 @@
   class PreDecResolveNode : public PrePostResolveNode {
   public:
-    PreDecResolveNode(const Identifier &s) KJS_FAST_CALL 
-        : PrePostResolveNode(s) 
+    PreDecResolveNode(const Identifier& ident) KJS_FAST_CALL 
+        : PrePostResolveNode(ident)
     { 
     }
@@ -1011 +1037 @@
   class PrefixBracketNode : public ExpressionNode {
   public:
-    PrefixBracketNode(ExpressionNode* b, ExpressionNode* s) KJS_FAST_CALL : m_base(b), m_subscript(s) {}
-    
+    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; }
@@ -1022 +1049 @@
   class PreIncBracketNode : public PrefixBracketNode {
   public:
-    PreIncBracketNode(ExpressionNode*  b, ExpressionNode*  s) KJS_FAST_CALL : PrefixBracketNode(b, s) {}
+    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;
@@ -1029 +1057 @@
   class PreDecBracketNode : public PrefixBracketNode {
   public:
-    PreDecBracketNode(ExpressionNode*  b, ExpressionNode*  s) KJS_FAST_CALL : PrefixBracketNode(b, s) {}
+    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;
@@ -1036 +1065 @@
   class PrefixDotNode : public ExpressionNode {
   public:
-    PrefixDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : m_base(b), m_ident(i) {}
+    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; }
@@ -1046 +1076 @@
   class PreIncDotNode : public PrefixDotNode {
   public:
-    PreIncDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : PrefixDotNode(b, i) {}
+    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;
@@ -1053 +1084 @@
   class PreDecDotNode : public PrefixDotNode {
   public:
-    PreDecDotNode(ExpressionNode* b, const Identifier& i) KJS_FAST_CALL : PrefixDotNode(b, i) {}
+    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;
@@ -1060 +1092 @@
   class PrefixErrorNode : public ExpressionNode {
   public:
-    PrefixErrorNode(ExpressionNode* e, Operator o) KJS_FAST_CALL : m_expr(e), m_oper(o) {}
+    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;
@@ -1071 +1104 @@
   class UnaryPlusNode : public ExpressionNode {
   public:
-    UnaryPlusNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(NumberType), m_expr(e) {}
+    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;
@@ -1086 +1120 @@
   class NegateNode : public ExpressionNode {
   public:
-    NegateNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(NumberType), expr(e) {}
+    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;
@@ -1093 +1128 @@
     virtual Precedence precedence() const { return PrecUnary; }
   private:
-    RefPtr<ExpressionNode> expr;
+    RefPtr<ExpressionNode> m_expr;
   };
 
   class BitwiseNotNode : public ExpressionNode {
   public:
-    BitwiseNotNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(NumberType), expr(e) {}
+    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;
@@ -1109 +1145 @@
   private:
     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> expr;
+    RefPtr<ExpressionNode> m_expr;
   };
 
   class LogicalNotNode : public ExpressionNode {
   public:
-    LogicalNotNode(ExpressionNode* e) KJS_FAST_CALL : ExpressionNode(BooleanType), expr(e) {}
+    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;
@@ -1121 +1158 @@
     virtual Precedence precedence() const { return PrecUnary; }
   private:
-    RefPtr<ExpressionNode> expr;
+    RefPtr<ExpressionNode> m_expr;
   };
   
   class MultNode : public ExpressionNode {
   public:
-      MultNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
+      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;
@@ -1137 +1175 @@
   private:
       ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
-      RefPtr<ExpressionNode> term1;
-      RefPtr<ExpressionNode> term2;
+      RefPtr<ExpressionNode> m_term1;
+      RefPtr<ExpressionNode> m_term2;
   };
   
   class DivNode : public ExpressionNode {
   public:
-      DivNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
+      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;
@@ -1153 +1192 @@
   private:
       ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
-      RefPtr<ExpressionNode> term1;
-      RefPtr<ExpressionNode> term2;
+      RefPtr<ExpressionNode> m_term1;
+      RefPtr<ExpressionNode> m_term2;
   };
   
   class ModNode : public ExpressionNode {
   public:
-      ModNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
+      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;
@@ -1170 +1210 @@
   private:
       ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
-      RefPtr<ExpressionNode> term1;
-      RefPtr<ExpressionNode> term2;
+      RefPtr<ExpressionNode> m_term1;
+      RefPtr<ExpressionNode> m_term2;
   };
 
   class AddNode : public ExpressionNode {
   public:
-    AddNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : term1(t1), term2(t2) {}
+    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;
@@ -1185 +1226 @@
     virtual Precedence precedence() const { return PrecAdditive; }
   protected:
-    AddNode(ExpressionNode* t1, ExpressionNode* t2, JSType expectedReturn) KJS_FAST_CALL : ExpressionNode(expectedReturn), term1(t1), term2(t2) {}
-    RefPtr<ExpressionNode> term1;
-    RefPtr<ExpressionNode> term2;
+    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*);
@@ -1194 +1236 @@
     class AddNumbersNode : public AddNode {
     public:
-        AddNumbersNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, NumberType) {}
+        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;
@@ -1205 +1248 @@
     class AddStringLeftNode : public AddNode {
     public:
-        AddStringLeftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, StringType) {}
+        AddStringLeftNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+          : AddNode(term1, term2, StringType) { }
         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     };
@@ -1211 +1255 @@
     class AddStringRightNode : public AddNode {
     public:
-        AddStringRightNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, StringType) {}
+        AddStringRightNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+          : AddNode(term1, term2, StringType) { }
         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     };
@@ -1217 +1262 @@
     class AddStringsNode : public AddNode {
     public:
-        AddStringsNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : AddNode(t1, t2, StringType) {}
+        AddStringsNode(ExpressionNode* term1, ExpressionNode* term2) KJS_FAST_CALL
+          : AddNode(term1, term2, StringType) { }
         virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     };
@@ -1223 +1269 @@
   class SubNode : public ExpressionNode {
   public:
-      SubNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL : ExpressionNode(NumberType), term1(t1), term2(t2) {}
+      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;
@@ -1233 +1280 @@
   private:
       ALWAYS_INLINE double inlineEvaluateToNumber(ExecState*);
-      RefPtr<ExpressionNode> term1;
-      RefPtr<ExpressionNode> term2;
+      RefPtr<ExpressionNode> m_term1;
+      RefPtr<ExpressionNode> m_term2;
   };
 
   class LeftShiftNode : public ExpressionNode {
   public:
-    LeftShiftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL
-      : ExpressionNode(NumberType), term1(t1), term2(t2) {}
+    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;
@@ -1250 +1297 @@
   private:
     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> term1;
-    RefPtr<ExpressionNode> term2;
+    RefPtr<ExpressionNode> m_term1;
+    RefPtr<ExpressionNode> m_term2;
   };
 
   class RightShiftNode : public ExpressionNode {
   public:
-    RightShiftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL
-      : ExpressionNode(NumberType), term1(t1), term2(t2) {}
+    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;
@@ -1267 +1314 @@
   private:
     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> term1;
-    RefPtr<ExpressionNode> term2;
+    RefPtr<ExpressionNode> m_term1;
+    RefPtr<ExpressionNode> m_term2;
   };
 
   class UnsignedRightShiftNode : public ExpressionNode {
   public:
-    UnsignedRightShiftNode(ExpressionNode* t1, ExpressionNode* t2) KJS_FAST_CALL
-      : ExpressionNode(NumberType), term1(t1), term2(t2) {}
+    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;
@@ -1284 +1331 @@
   private:
     ALWAYS_INLINE uint32_t inlineEvaluateToUInt32(ExecState*);
-    RefPtr<ExpressionNode> term1;
-    RefPtr<ExpressionNode> term2;
+    RefPtr<ExpressionNode> m_term1;
+    RefPtr<ExpressionNode> m_term2;
   };
 
   class LessNode : public ExpressionNode {
   public:
-    LessNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-      : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
+    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;
@@ -1300 +1347 @@
     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
   protected:
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
     class LessNumbersNode : public LessNode {
     public:
-        LessNumbersNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-            : LessNode(e1, e2) {}
+        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;
@@ -1316 +1363 @@
     class LessStringsNode : public LessNode {
     public:
-        LessStringsNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-            : LessNode(e1, e2) {}
+        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;
@@ -1327 +1374 @@
   public:
     GreaterNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
-      expr1(e1), expr2(e2) {}
+      m_expr1(e1), m_expr2(e2) {}
     virtual void optimizeVariableAccess(const SymbolTable&, const LocalStorage&, NodeStack&) KJS_FAST_CALL;
     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
@@ -1335 +1382 @@
   private:
     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
   class LessEqNode : public ExpressionNode {
   public:
-    LessEqNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
-      expr1(e1), expr2(e2) {}
+    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;
@@ -1350 +1397 @@
   private:
     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
   class GreaterEqNode : public ExpressionNode {
   public:
-    GreaterEqNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
-      expr1(e1), expr2(e2) {}
+    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;
@@ -1365 +1412 @@
   private:
     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
     class InstanceOfNode : public ExpressionNode {
   public:
-    InstanceOfNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
+    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;
@@ -1379 +1426 @@
     virtual Precedence precedence() const { return PrecRelational; }
   private:
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
     class InNode : public ExpressionNode {
   public:
-    InNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
-      expr1(e1), expr2(e2) {}
+    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;
@@ -1393 +1440 @@
     virtual Precedence precedence() const { return PrecRelational; }
   private:
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
     class EqualNode : public ExpressionNode {
   public:
-    EqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
+    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;
@@ -1408 +1455 @@
   private:
     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
     class NotEqualNode : public ExpressionNode {
   public:
-    NotEqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
+    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;
@@ -1423 +1470 @@
   private:
     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
     class StrictEqualNode : public ExpressionNode {
   public:
-    StrictEqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
+    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;
@@ -1438 +1485 @@
   private:
     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
     class NotStrictEqualNode : public ExpressionNode {
   public:
-    NotStrictEqualNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
+    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;
@@ -1453 +1500 @@
   private:
     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
     class BitAndNode : public ExpressionNode {
   public:
-    BitAndNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-        : ExpressionNode(NumberType), expr1(e1), expr2(e2) {}
+    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;
@@ -1471 +1518 @@
   private:
     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
     class BitOrNode : public ExpressionNode {
   public:
-    BitOrNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-        : ExpressionNode(NumberType), expr1(e1), expr2(e2) {}
+    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;
@@ -1489 +1536 @@
   private:
     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
-  };
-
-    class BitXOrNode : public ExpressionNode {
-  public:
-    BitXOrNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-        : ExpressionNode(NumberType), expr1(e1), expr2(e2) {}
+    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;
@@ -1507 +1554 @@
   private:
     ALWAYS_INLINE int32_t inlineEvaluateToInt32(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
   /**
-   * expr1 && expr2, expr1 || expr2
+   * m_expr1 && m_expr2, m_expr1 || m_expr2
    */
     class LogicalAndNode : public ExpressionNode {
   public:
-    LogicalAndNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
+    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;
@@ -1525 +1572 @@
   private:
     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
   
     class LogicalOrNode : public ExpressionNode {
   public:
-    LogicalOrNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL
-        : ExpressionNode(BooleanType), expr1(e1), expr2(e2) {}
+    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;
@@ -1540 +1587 @@
   private:
     ALWAYS_INLINE bool inlineEvaluateToBoolean(ExecState*);
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
   /**
-   * The ternary operator, "logical ? expr1 : expr2"
+   * The ternary operator, "m_logical ? m_expr1 : m_expr2"
    */
-    class ConditionalNode : public ExpressionNode {
-  public:
-    ConditionalNode(ExpressionNode*  l, ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL :
-      logical(l), expr1(e1), expr2(e2) {}
+  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;
@@ -1560 +1607 @@
     virtual Precedence precedence() const { return PrecConditional; }
   private:
-    RefPtr<ExpressionNode> logical;
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
-  };
-
-    class ReadModifyResolveNode : public ExpressionNode {
-  public:
-    ReadModifyResolveNode(const Identifier &ident, Operator oper, ExpressionNode*  right) KJS_FAST_CALL
+    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) 
-      {
-      }
+    {
+    }
 
     ReadModifyResolveNode(PlacementNewAdoptType) KJS_FAST_CALL 
@@ -1615 +1662 @@
   };
 
-    class AssignResolveNode : public ExpressionNode {
-  public:
-     AssignResolveNode(const Identifier &ident, ExpressionNode*  right) KJS_FAST_CALL
+  class AssignResolveNode : public ExpressionNode {
+  public:
+     AssignResolveNode(const Identifier& ident, ExpressionNode* right) KJS_FAST_CALL
       : m_ident(ident)
       , m_right(right) 
@@ -1661 +1708 @@
   };
 
-    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) {}
+  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;
@@ -1676 +1723 @@
   };
 
-    class AssignBracketNode : public ExpressionNode {
-  public:
-    AssignBracketNode(ExpressionNode*  base, ExpressionNode*  subscript, ExpressionNode*  right) KJS_FAST_CALL
-      : m_base(base), m_subscript(subscript), m_right(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;
@@ -1690 +1737 @@
   };
 
-    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) {}
+  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;
@@ -1704 +1751 @@
   };
 
-    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) {}
+  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;
@@ -1719 +1766 @@
   };
 
-    class AssignErrorNode : public ExpressionNode {
+  class AssignErrorNode : public ExpressionNode {
   public:
     AssignErrorNode(ExpressionNode* left, Operator oper, ExpressionNode* right) KJS_FAST_CALL
-      : m_left(left), m_oper(oper), m_right(right) {}
+      : m_left(left), m_oper(oper), m_right(right) { }
     virtual JSValue* evaluate(ExecState*) KJS_FAST_CALL;
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
@@ -1732 +1779 @@
   };
 
-    class CommaNode : public ExpressionNode {
-  public:
-    CommaNode(ExpressionNode* e1, ExpressionNode* e2) KJS_FAST_CALL : expr1(e1), expr2(e2)
-    {
-        e1->optimizeForUnnecessaryResult();
+  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;
@@ -1743 +1792 @@
     virtual Precedence precedence() const { return PrecExpression; }
   private:
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
+    RefPtr<ExpressionNode> m_expr1;
+    RefPtr<ExpressionNode> m_expr2;
   };
 
   class ConstDeclNode : public ExpressionNode {
   public:
-    ConstDeclNode(const Identifier& id, ExpressionNode* in) KJS_FAST_CALL;
+    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;
@@ -1755 +1804 @@
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
     virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
-    PassRefPtr<ConstDeclNode> releaseNext() KJS_FAST_CALL { return next.release(); }
-
-    Identifier ident;
-    ListRefPtr<ConstDeclNode> next;
-    RefPtr<ExpressionNode> init;
+    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;
@@ -1766 +1815 @@
   class ConstStatementNode : public StatementNode {
   public:
-    ConstStatementNode(ConstDeclNode* l) KJS_FAST_CALL : next(l) { }
+    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> next;
+    RefPtr<ConstDeclNode> m_next;
   };
 
@@ -1808 +1858 @@
   class ExprStatementNode : public StatementNode {
   public:
-    ExprStatementNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
+    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> expr;
+    RefPtr<ExpressionNode> m_expr;
   };
 
   class VarStatementNode : public StatementNode {
   public:
-    VarStatementNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
+    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> expr;
+    RefPtr<ExpressionNode> m_expr;
   };
 
   class IfNode : public StatementNode {
   public:
-    IfNode(ExpressionNode* e, StatementNode *s) KJS_FAST_CALL
-      : m_condition(e), m_ifBlock(s) { }
+    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;
@@ -1840 +1891 @@
     class IfElseNode : public IfNode {
     public:
-        IfElseNode(ExpressionNode* e, StatementNode* ifBlock, StatementNode* elseBlock) KJS_FAST_CALL
-            : IfNode(e, ifBlock), m_elseBlock(elseBlock) { }
+        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;
@@ -1851 +1902 @@
   class DoWhileNode : public StatementNode {
   public:
-    DoWhileNode(StatementNode *s, ExpressionNode* e) KJS_FAST_CALL : statement(s), expr(e) { }
+    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> statement;
-    RefPtr<ExpressionNode> expr;
+    RefPtr<StatementNode> m_statement;
+    RefPtr<ExpressionNode> m_expr;
   };
 
   class WhileNode : public StatementNode {
   public:
-    WhileNode(ExpressionNode* e, StatementNode *s) KJS_FAST_CALL : expr(e), statement(s) { }
+    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> expr;
-    RefPtr<StatementNode> statement;
+    RefPtr<ExpressionNode> m_expr;
+    RefPtr<StatementNode> m_statement;
   };
 
   class ForNode : public StatementNode {
   public:
-      ForNode(ExpressionNode* e1, ExpressionNode* e2, ExpressionNode* e3, StatementNode* s, bool e1WasVarDecl) KJS_FAST_CALL
-        : expr1(e1 ? e1 : new PlaceholderTrueNode)
-        , expr2(e2 ? e2 : new PlaceholderTrueNode)
-        , expr3(e3 ? e3 : new PlaceholderTrueNode)
-        , statement(s)
-        , expr1WasVarDecl(e1 && e1WasVarDecl)
-    {
-        ASSERT(expr1);
-        ASSERT(expr2);
-        ASSERT(expr3);
+      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);
 
-        expr1->optimizeForUnnecessaryResult();
-        expr3->optimizeForUnnecessaryResult();
+        m_expr1->optimizeForUnnecessaryResult();
+        m_expr3->optimizeForUnnecessaryResult();
     }
 
@@ -1893 +1946 @@
     virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
   private:
-    RefPtr<ExpressionNode> expr1;
-    RefPtr<ExpressionNode> expr2;
-    RefPtr<ExpressionNode> expr3;
-    RefPtr<StatementNode> statement;
-    bool expr1WasVarDecl;
+    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*  l, ExpressionNode* e, StatementNode *s) KJS_FAST_CALL;
-    ForInNode(const Identifier &i, ExpressionNode *in, ExpressionNode* e, StatementNode *s) KJS_FAST_CALL;
+    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 ident;
-    RefPtr<ExpressionNode> init;
-    RefPtr<ExpressionNode> lexpr;
-    RefPtr<ExpressionNode> expr;
-    RefPtr<StatementNode> statement;
-    bool identIsVarDecl;
+    Identifier m_ident;
+    RefPtr<ExpressionNode> m_init;
+    RefPtr<ExpressionNode> m_lexpr;
+    RefPtr<ExpressionNode> m_expr;
+    RefPtr<StatementNode> m_statement;
+    bool m_identIsVarDecl;
   };
 
@@ -1919 +1972 @@
   public:
     ContinueNode() KJS_FAST_CALL { }
-    ContinueNode(const Identifier &i) KJS_FAST_CALL : ident(i) { }
+    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 ident;
+    Identifier m_ident;
   };
 
@@ -1929 +1983 @@
   public:
     BreakNode() KJS_FAST_CALL { }
-    BreakNode(const Identifier &i) KJS_FAST_CALL : ident(i) { }
+    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 ident;
+    Identifier m_ident;
   };
 
   class ReturnNode : public StatementNode {
   public:
-    ReturnNode(ExpressionNode* v) KJS_FAST_CALL : value(v) {}
+    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> value;
+    RefPtr<ExpressionNode> m_value;
   };
 
   class WithNode : public StatementNode {
   public:
-    WithNode(ExpressionNode* e, StatementNode* s) KJS_FAST_CALL : expr(e), statement(s) { }
+    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> expr;
-    RefPtr<StatementNode> statement;
+    RefPtr<ExpressionNode> m_expr;
+    RefPtr<StatementNode> m_statement;
   };
 
   class LabelNode : public StatementNode {
   public:
-    LabelNode(const Identifier &l, StatementNode *s) KJS_FAST_CALL : label(l), statement(s) { }
+    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 label;
-    RefPtr<StatementNode> statement;
+    Identifier m_label;
+    RefPtr<StatementNode> m_statement;
   };
 
   class ThrowNode : public StatementNode {
   public:
-    ThrowNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) {}
+    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> expr;
+    RefPtr<ExpressionNode> m_expr;
   };
 
   class TryNode : public StatementNode {
   public:
-    TryNode(StatementNode *b, const Identifier &e, StatementNode *c, StatementNode *f) KJS_FAST_CALL
-      : tryBlock(b), exceptionIdent(e), catchBlock(c), finallyBlock(f) { }
+    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> tryBlock;
-    Identifier exceptionIdent;
-    RefPtr<StatementNode> catchBlock;
-    RefPtr<StatementNode> finallyBlock;
-  };
-
-    class ParameterNode : public Node {
-  public:
-    ParameterNode(const Identifier& i) KJS_FAST_CALL : id(i) { }
-    ParameterNode(ParameterNode* l, const Identifier& i) KJS_FAST_CALL
-      : id(i) { l->next = this; }
-    Identifier ident() KJS_FAST_CALL { return id; }
-    ParameterNode *nextParam() KJS_FAST_CALL { return next.get(); }
-    virtual void streamTo(SourceStream&) const KJS_FAST_CALL;
-    PassRefPtr<ParameterNode> releaseNext() KJS_FAST_CALL { return next.release(); }
+    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 id;
-    ListRefPtr<ParameterNode> next;
+    Identifier m_ident;
+    ListRefPtr<ParameterNode> m_next;
   };
 
@@ -2077 +2137 @@
   class FuncExprNode : public ExpressionNode {
   public:
-    FuncExprNode(const Identifier& i, FunctionBodyNode* b, ParameterNode* p = 0) KJS_FAST_CALL 
-      : ident(i), param(p), body(b) { addParams(); }
+    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;
@@ -2087 +2147 @@
     // Used for streamTo
     friend class PropertyNode;
-    Identifier ident;
-    RefPtr<ParameterNode> param;
-    RefPtr<FunctionBodyNode> body;
+    Identifier m_ident;
+    RefPtr<ParameterNode> m_parameter;
+    RefPtr<FunctionBodyNode> m_body;
   };
 
   class FuncDeclNode : public StatementNode {
   public:
-    FuncDeclNode(const Identifier& i, FunctionBodyNode* b) KJS_FAST_CALL
-      : ident(i), body(b) { addParams(); }
-    FuncDeclNode(const Identifier& i, ParameterNode* p, FunctionBodyNode* b) KJS_FAST_CALL
-      : ident(i), param(p), body(b) { addParams(); }
+    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 ident;
+    Identifier m_ident;
   private:
     void addParams() KJS_FAST_CALL;
-    RefPtr<ParameterNode> param;
-    RefPtr<FunctionBodyNode> body;
-  };
-
-    class CaseClauseNode : public Node {
-  public:
-      CaseClauseNode(ExpressionNode* e) KJS_FAST_CALL : expr(e) { }
+    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
-      : expr(e) { if (children) children->releaseContentsIntoVector(m_children); }
+        : 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;
@@ -2121 +2182 @@
 
   private:
-      RefPtr<ExpressionNode> expr;
+      RefPtr<ExpressionNode> m_expr;
       StatementVector m_children;
   };
   
-    class ClauseListNode : public Node {
-  public:
-      ClauseListNode(CaseClauseNode* c) KJS_FAST_CALL : clause(c) { }
-      ClauseListNode(ClauseListNode* n, CaseClauseNode* c) KJS_FAST_CALL
-      : clause(c) { n->next = this; }
+  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 clause.get(); }
-      ClauseListNode* getNext() const KJS_FAST_CALL { return next.get(); }
+      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 next.release(); }
+      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> clause;
-      ListRefPtr<ClauseListNode> next;
+      RefPtr<CaseClauseNode> m_clause;
+      ListRefPtr<ClauseListNode> m_next;
   };
   
-    class CaseBlockNode : public Node {
-  public:
-      CaseBlockNode(ClauseListNode* l1, CaseClauseNode* d, ClauseListNode* l2) KJS_FAST_CALL;
+  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;
@@ -2150 +2212 @@
       virtual Precedence precedence() const { ASSERT_NOT_REACHED(); return PrecExpression; }
   private:
-      RefPtr<ClauseListNode> list1;
-      RefPtr<CaseClauseNode> def;
-      RefPtr<ClauseListNode> list2;
+      RefPtr<ClauseListNode> m_list1;
+      RefPtr<CaseClauseNode> m_defaultClause;
+      RefPtr<ClauseListNode> m_list2;
   };
   
   class SwitchNode : public StatementNode {
   public:
-      SwitchNode(ExpressionNode* e, CaseBlockNode *b) KJS_FAST_CALL : expr(e), block(b) { }
+      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> expr;
-      RefPtr<CaseBlockNode> block;
+      RefPtr<ExpressionNode> m_expr;
+      RefPtr<CaseBlockNode> m_block;
   };
 
@@ -2206 +2269 @@
   };
 
-} // namespace
-
-#endif
+} // namespace KJS
+
+#endif // NODES_H_

trunk/JavaScriptCore/kjs/nodes2string.cpp

@@ -326 +326 @@
 void ResolveNode::streamTo(SourceStream& s) const
 {
-    s << ident;
+    s << m_ident;
 }
 
 void ElementNode::streamTo(SourceStream& s) const
 {
-    for (const ElementNode* n = this; n; n = n->next.get()) {
-        for (int i = 0; i < n->elision; i++)
+    for (const ElementNode* n = this; n; n = n->m_next.get()) {
+        for (int i = 0; i < n->m_elision; i++)
             s << ',';
-        s << PrecAssignment << n->node;
-        if (n->next)
+        s << PrecAssignment << n->m_node;
+        if (n->m_next)
             s << ',';
     }
@@ -342 +342 @@
 void ArrayNode::streamTo(SourceStream& s) const
 {
-    s << '[' << element;
-    for (int i = 0; i < elision; i++)
+    s << '[' << m_element;
+    for (int i = 0; i < m_elision; i++)
         s << ',';
     // Parser consumes one elision comma if there's array elements 
     // present in the expression.
-    if (opt && element)
+    if (m_opt && m_element)
         s << ',';
     s << ']';
@@ -354 +354 @@
 void ObjectLiteralNode::streamTo(SourceStream& s) const
 {
-    if (list)
-        s << "{ " << list << " }";
+    if (m_list)
+        s << "{ " << m_list << " }";
     else
         s << "{ }";
@@ -362 +362 @@
 void PropertyListNode::streamTo(SourceStream& s) const
 {
-    s << node;
-    for (const PropertyListNode* n = next.get(); n; n = n->next.get())
-        s << ", " << n->node;
+    s << m_node;
+    for (const PropertyListNode* n = m_next.get(); n; n = n->m_next.get())
+        s << ", " << n->m_node;
 }
 
 void PropertyNode::streamTo(SourceStream& s) const
 {
-    switch (type) {
+    switch (m_type) {
         case Constant: {
             UString propertyName = name().ustring();
@@ -376 +376 @@
             else
                 s << '"' << escapeStringForPrettyPrinting(propertyName) << '"';
-            s << ": " << PrecAssignment << assign;
+            s << ": " << PrecAssignment << m_assign;
             break;
         }
         case Getter:
         case Setter: {
-            const FuncExprNode* func = static_cast<const FuncExprNode*>(assign.get());
-            if (type == Getter)
+            const FuncExprNode* func = static_cast<const FuncExprNode*>(m_assign.get());
+            if (m_type == Getter)
                 s << "get "; 
             else
                 s << "set ";
             s << escapeStringForPrettyPrinting(name().ustring())
-                << "(" << func->param << ')' << func->body;
+                << "(" << func->m_parameter << ')' << func->m_body;
             break;
         }
@@ -395 +395 @@
 void BracketAccessorNode::streamTo(SourceStream& s) const
 {
-    bracketNodeStreamTo(s, expr1, expr2);
+    bracketNodeStreamTo(s, m_base, m_subscript);
 }
 
 void DotAccessorNode::streamTo(SourceStream& s) const
 {
-    dotNodeStreamTo(s, expr, ident);
+    dotNodeStreamTo(s, m_base, m_ident);
 }
 
 void ArgumentListNode::streamTo(SourceStream& s) const
 {
-    s << PrecAssignment << expr;
-    for (ArgumentListNode* n = next.get(); n; n = n->next.get())
-        s << ", " << PrecAssignment << n->expr;
+    s << PrecAssignment << m_expr;
+    for (ArgumentListNode* n = m_next.get(); n; n = n->m_next.get())
+        s << ", " << PrecAssignment << n->m_expr;
 }
 
 void ArgumentsNode::streamTo(SourceStream& s) const
 {
-    s << '(' << listNode << ')';
+    s << '(' << m_listNode << ')';
 }
 
 void NewExprNode::streamTo(SourceStream& s) const
 {
-    s << "new " << PrecMember << expr << args;
+    s << "new " << PrecMember << m_expr << m_args;
 }
 
 void FunctionCallValueNode::streamTo(SourceStream& s) const
 {
-    s << PrecCall << expr << args;
+    s << PrecCall << m_expr << m_args;
 }
 
 void FunctionCallResolveNode::streamTo(SourceStream& s) const
 {
-    s << ident << args;
+    s << m_ident << m_args;
 }
 
 void FunctionCallBracketNode::streamTo(SourceStream& s) const
 {
-    bracketNodeStreamTo(s, base, subscript);
-    s << args;
+    bracketNodeStreamTo(s, m_base, m_subscript);
+    s << m_args;
 }
 
 void FunctionCallDotNode::streamTo(SourceStream& s) const
 {
-    dotNodeStreamTo(s, base, ident);
-    s << args;
+    dotNodeStreamTo(s, m_base, m_ident);
+    s << m_args;
 }
 
@@ -509 +509 @@
 void VoidNode::streamTo(SourceStream& s) const
 {
-    s << "void " << PrecUnary << expr;
+    s << "void " << PrecUnary << m_expr;
 }
 
@@ -571 +571 @@
 void NegateNode::streamTo(SourceStream& s) const
 {
-    s << "- " << PrecUnary << expr;
+    s << "- " << PrecUnary << m_expr;
 }
 
 void BitwiseNotNode::streamTo(SourceStream& s) const
 {
-    s << "~" << PrecUnary << expr;
+    s << "~" << PrecUnary << m_expr;
 }
 
 void LogicalNotNode::streamTo(SourceStream& s) const
 {
-    s << "!" << PrecUnary << expr;
+    s << "!" << PrecUnary << m_expr;
 }
 
 void MultNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "*", term1, term2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "*", m_term1, m_term2);
 }
 
 void DivNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "/", term1, term2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "/", m_term1, m_term2);
 }
 
 void ModNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "%", term1, term2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "%", m_term1, m_term2);
 }
 
 void AddNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "+", term1, term2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "+", m_term1, m_term2);
 }
 
 void SubNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "-", term1, term2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "-", m_term1, m_term2);
 }
 
 void LeftShiftNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "<<", term1, term2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "<<", m_term1, m_term2);
 }
 
 void RightShiftNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), ">>", term1, term2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), ">>", m_term1, m_term2);
 }
 
 void UnsignedRightShiftNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), ">>>", term1, term2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), ">>>", m_term1, m_term2);
 }
 
 void LessNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "<", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "<", m_expr1, m_expr2);
 }
 
 void GreaterNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), ">", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), ">", m_expr1, m_expr2);
 }
 
 void LessEqNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "<=", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "<=", m_expr1, m_expr2);
 }
 
 void GreaterEqNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), ">=", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), ">=", m_expr1, m_expr2);
 }
 
 void InstanceOfNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "instanceof", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "instanceof", m_expr1, m_expr2);
 }
 
 void InNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "in", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "in", m_expr1, m_expr2);
 }
 
 void EqualNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "==", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "==", m_expr1, m_expr2);
 }
 
 void NotEqualNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "!=", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "!=", m_expr1, m_expr2);
 }
 
 void StrictEqualNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "===", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "===", m_expr1, m_expr2);
 }
 
 void NotStrictEqualNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "!==", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "!==", m_expr1, m_expr2);
 }
 
 void BitAndNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "&", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "&", m_expr1, m_expr2);
 }
 
 void BitXOrNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "^", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "^", m_expr1, m_expr2);
 }
 
 void BitOrNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "|", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "|", m_expr1, m_expr2);
 }
 
 void LogicalAndNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "&&", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "&&", m_expr1, m_expr2);
 }
 
 void LogicalOrNode::streamTo(SourceStream& s) const
 {
-    streamLeftAssociativeBinaryOperator(s, precedence(), "||", expr1, expr2);
+    streamLeftAssociativeBinaryOperator(s, precedence(), "||", m_expr1, m_expr2);
 }
 
 void ConditionalNode::streamTo(SourceStream& s) const
 {
-    s << PrecLogicalOr << logical
-        << " ? " << PrecAssignment << expr1
-        << " : " << PrecAssignment << expr2;
+    s << PrecLogicalOr << m_logical
+        << " ? " << PrecAssignment << m_expr1
+        << " : " << PrecAssignment << m_expr2;
 }
 
@@ -748 +748 @@
 void CommaNode::streamTo(SourceStream& s) const
 {
-    s << PrecAssignment << expr1 << ", " << PrecAssignment << expr2;
+    s << PrecAssignment << m_expr1 << ", " << PrecAssignment << m_expr2;
 }
 
 void ConstDeclNode::streamTo(SourceStream& s) const
 {
-    s << ident;
-    if (init)
-        s << " = " << init;
-    for (ConstDeclNode* n = next.get(); n; n = n->next.get()) {
-        s << ", " << ident;
-        if (init)
-            s << " = " << init;
+    s << m_ident;
+    if (m_init)
+        s << " = " << m_init;
+    for (ConstDeclNode* n = m_next.get(); n; n = n->m_next.get()) {
+        s << ", " << m_ident;
+        if (m_init)
+            s << " = " << m_init;
     }
 }
@@ -765 +765 @@
 void ConstStatementNode::streamTo(SourceStream& s) const
 {
-    s << Endl << "const " << next << ';';
+    s << Endl << "const " << m_next << ';';
 }
 
@@ -810 +810 @@
 void ExprStatementNode::streamTo(SourceStream& s) const
 {
-    s << Endl << expr << ';';
+    s << Endl << m_expr << ';';
 }
 
 void VarStatementNode::streamTo(SourceStream& s) const
 {
-    s << Endl << "var " << expr << ';';
+    s << Endl << "var " << m_expr << ';';
 }
 
@@ -831 +831 @@
 void DoWhileNode::streamTo(SourceStream& s) const
 {
-    s << Endl << "do " << Indent << statement << Unindent << Endl
-        << "while (" << expr << ");";
+    s << Endl << "do " << Indent << m_statement << Unindent << Endl
+        << "while (" << m_expr << ");";
 }
 
 void WhileNode::streamTo(SourceStream& s) const
 {
-    s << Endl << "while (" << expr << ')' << Indent << statement << Unindent;
+    s << Endl << "while (" << m_expr << ')' << Indent << m_statement << Unindent;
 }
 
@@ -843 +843 @@
 {
     s << Endl << "for ("
-        << (expr1WasVarDecl ? "var " : "")
-        << expr1
-        << "; " << expr2
-        << "; " << expr3
-        << ')' << Indent << statement << Unindent;
+        << (m_expr1WasVarDecl ? "var " : "")
+        << m_expr1
+        << "; " << m_expr2
+        << "; " << m_expr3
+        << ')' << Indent << m_statement << Unindent;
 }
 
@@ -853 +853 @@
 {
     s << Endl << "for (";
-    if (identIsVarDecl) {
+    if (m_identIsVarDecl) {
         s << "var ";
-        if (init)
-            s << init;
+        if (m_init)
+            s << m_init;
         else
-            s << PrecLeftHandSide << lexpr;
+            s << PrecLeftHandSide << m_lexpr;
     } else
-        s << PrecLeftHandSide << lexpr;
-
-    s << " in " << expr << ')' << Indent << statement << Unindent;
+        s << PrecLeftHandSide << m_lexpr;
+
+    s << " in " << m_expr << ')' << Indent << m_statement << Unindent;
 }
 
@@ -868 +868 @@
 {
     s << Endl << "continue";
-    if (!ident.isNull())
-        s << ' ' << ident;
+    if (!m_ident.isNull())
+        s << ' ' << m_ident;
     s << ';';
 }
@@ -876 +876 @@
 {
     s << Endl << "break";
-    if (!ident.isNull())
-        s << ' ' << ident;
+    if (!m_ident.isNull())
+        s << ' ' << m_ident;
     s << ';';
 }
@@ -884 +884 @@
 {
     s << Endl << "return";
-    if (value)
-        s << ' ' << value;
+    if (m_value)
+        s << ' ' << m_value;
     s << ';';
 }
@@ -891 +891 @@
 void WithNode::streamTo(SourceStream& s) const
 {
-    s << Endl << "with (" << expr << ") " << statement;
+    s << Endl << "with (" << m_expr << ") " << m_statement;
 }
 
@@ -897 +897 @@
 {
     s << Endl;
-    if (expr)
-        s << "case " << expr;
+    if (m_expr)
+        s << "case " << m_expr;
     else
         s << "default";
@@ -914 +914 @@
 void CaseBlockNode::streamTo(SourceStream& s) const
 {
-    for (const ClauseListNode* n = list1.get(); n; n = n->getNext())
+    for (const ClauseListNode* n = m_list1.get(); n; n = n->getNext())
         s << n->getClause();
-    s << def;
-    for (const ClauseListNode* n = list2.get(); n; n = n->getNext())
+    s << m_defaultClause;
+    for (const ClauseListNode* n = m_list2.get(); n; n = n->getNext())
         s << n->getClause();
 }
@@ -923 +923 @@
 void SwitchNode::streamTo(SourceStream& s) const
 {
-    s << Endl << "switch (" << expr << ") {"
-        << Indent << block << Unindent
+    s << Endl << "switch (" << m_expr << ") {"
+        << Indent << m_block << Unindent
         << Endl << "}";
 }
@@ -930 +930 @@
 void LabelNode::streamTo(SourceStream& s) const
 {
-    s << Endl << label << ":" << Indent << statement << Unindent;
+    s << Endl << m_label << ":" << Indent << m_statement << Unindent;
 }
 
 void ThrowNode::streamTo(SourceStream& s) const
 {
-    s << Endl << "throw " << expr << ';';
+    s << Endl << "throw " << m_expr << ';';
 }
 
 void TryNode::streamTo(SourceStream& s) const
 {
-    s << Endl << "try " << tryBlock;
-    if (catchBlock)
-        s << Endl << "catch (" << exceptionIdent << ')' << catchBlock;
-    if (finallyBlock)
-        s << Endl << "finally " << finallyBlock;
+    s << Endl << "try " << m_tryBlock;
+    if (m_catchBlock)
+        s << Endl << "catch (" << m_exceptionIdent << ')' << m_catchBlock;
+    if (m_finallyBlock)
+        s << Endl << "finally " << m_finallyBlock;
 }
 
 void ParameterNode::streamTo(SourceStream& s) const
 {
-    s << id;
-    for (ParameterNode* n = next.get(); n; n = n->next.get())
-        s << ", " << n->id;
+    s << m_ident;
+    for (ParameterNode* n = m_next.get(); n; n = n->m_next.get())
+        s << ", " << n->m_ident;
 }
 
 void FuncDeclNode::streamTo(SourceStream& s) const
 {
-    s << Endl << "function " << ident << '(' << param << ')' << body;
+    s << Endl << "function " << m_ident << '(' << m_parameter << ')' << m_body;
 }
 
 void FuncExprNode::streamTo(SourceStream& s) const
 {
-    s << "function " << ident << '(' << param << ')' << body;
+    s << "function " << m_ident << '(' << m_parameter << ')' << m_body;
 }