Changeset 29825 in webkit for trunk/JavaScriptCore/kjs/nodes2string.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/nodes2string.cpp (modified) (22 diffs)

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