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

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:

File:

• trunk/JavaScriptCore/kjs/nodes.cpp (modified) (165 diffs)

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();
   }