Fix style erros in XPath-related files.

Source/core/xml/XPathParser.cpp

 /*
  * Copyright 2005 Maksim Orlovich <maksim@kde.org>
  * Copyright (C) 2006 Apple Computer, Inc.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 11 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/xml/XPathParser.h"
 
 #include "bindings/v8/ExceptionState.h"
+#include "core/XPathGrammar.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/xml/XPathEvaluator.h"
 #include "core/xml/XPathNSResolver.h"
 #include "core/xml/XPathPath.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringHash.h"
 
 using namespace WebCore;
 using namespace WTF;
 using namespace Unicode;
 using namespace XPath;
 
-#include "core/XPathGrammar.h"
-
 Parser* Parser::currentParser = 0;
 
 enum XMLCat { NameStart, NameCont, NotPartOfName };
 
 typedef HashMap<String, Step::Axis> AxisNamesMap;
 
 static XMLCat charCat(UChar aChar)
 {
-    //### might need to add some special cases from the XML spec.
+    // might need to add some special cases from the XML spec.
 
     if (aChar == '_')
         return NameStart;
 
     if (aChar == '.' || aChar == '-')
         return NameCont;
     CharCategory category = Unicode::category(aChar);
     if (category & (Letter_Uppercase | Letter_Lowercase | Letter_Other | Letter_Titlecase | Number_Letter))
         return NameStart;
     if (category & (Mark_NonSpacing | Mark_SpacingCombining | Mark_Enclosing | Letter_Modifier | Number_DecimalDigit))
@@ skipping 135 matching lines @@
 }
 
 Token Parser::lexNumber()
 {
     int startPos = m_nextPos;
     bool seenDot = false;
 
     // Go until end or a non-digits character.
     for (; m_nextPos < m_data.length(); ++m_nextPos) {
         UChar aChar = m_data[m_nextPos];
-        if (aChar >= 0xff) break;
+        if (aChar >= 0xff)
+            break;
 
         if (aChar < '0' || aChar > '9') {
             if (aChar == '.' && !seenDot)
                 seenDot = true;
             else
                 break;
         }
     }
 
     return Token(NUMBER, m_data.substring(startPos, m_nextPos - startPos));
 }
 
 bool Parser::lexNCName(String& name)
 {
     int startPos = m_nextPos;
     if (m_nextPos >= m_data.length())
         return false;
 
     if (charCat(m_data[m_nextPos]) != NameStart)
         return false;
 
     // Keep going until we get a character that's not good for names.
-    for (; m_nextPos < m_data.length(); ++m_nextPos)
+    for (; m_nextPos < m_data.length(); ++m_nextPos) {
         if (charCat(m_data[m_nextPos]) == NotPartOfName)
             break;
+    }
 
     name = m_data.substring(startPos, m_nextPos - startPos);
     return true;
 }
 
 bool Parser::lexQName(String& name)
 {
     String n1;
     if (!lexNCName(n1))
         return false;
@@ skipping 43 matching lines @@
     }
     case '/':
         if (peekAheadHelper() == '/')
             return makeTokenAndAdvance(SLASHSLASH, 2);
         return makeTokenAndAdvance('/');
     case '+':
         return makeTokenAndAdvance(PLUS);
     case '-':
         return makeTokenAndAdvance(MINUS);
     case '=':
-        return makeTokenAndAdvance(EQOP, EqTestOp::OP_EQ);
+        return makeTokenAndAdvance(EQOP, EqTestOp::OpcodeEqual);
     case '!':
         if (peekAheadHelper() == '=')
-            return makeTokenAndAdvance(EQOP, EqTestOp::OP_NE, 2);
+            return makeTokenAndAdvance(EQOP, EqTestOp::OpcodeNotEqual, 2);
         return Token(XPATH_ERROR);
     case '<':
         if (peekAheadHelper() == '=')
-            return makeTokenAndAdvance(RELOP, EqTestOp::OP_LE, 2);
-        return makeTokenAndAdvance(RELOP, EqTestOp::OP_LT);
+            return makeTokenAndAdvance(RELOP, EqTestOp::OpcodeLessOrEqual, 2);
+        return makeTokenAndAdvance(RELOP, EqTestOp::OpcodeLessThan);
     case '>':
         if (peekAheadHelper() == '=')
-            return makeTokenAndAdvance(RELOP, EqTestOp::OP_GE, 2);
-        return makeTokenAndAdvance(RELOP, EqTestOp::OP_GT);
+            return makeTokenAndAdvance(RELOP, EqTestOp::OpcodeGreaterOrEqual, 2);
+        return makeTokenAndAdvance(RELOP, EqTestOp::OpcodeGreaterThan);
     case '*':
         if (isBinaryOperatorContext())
             return makeTokenAndAdvance(MULOP, NumericOp::OP_Mul);
         ++m_nextPos;
         return Token(NAMETEST, "*");
     case '$': { // $ QName
         m_nextPos++;
         String name;
         if (!lexQName(name))
             return Token(XPATH_ERROR);
         return Token(VARIABLEREFERENCE, name);
     }
     }
 
     String name;
     if (!lexNCName(name))
         return Token(XPATH_ERROR);
 
     skipWS();
     // If we're in an operator context, check for any operator names
     if (isBinaryOperatorContext()) {
-        if (name == "and") //### hash?
+        if (name == "and") // ### hash?
             return Token(AND);
         if (name == "or")
             return Token(OR);
         if (name == "mod")
             return Token(MULOP, NumericOp::OP_Mod);
         if (name == "div")
             return Token(MULOP, NumericOp::OP_Div);
     }
 
     // See whether we are at a :
     if (peekCurHelper() == ':') {
         m_nextPos++;
         // Any chance it's an axis name?
         if (peekCurHelper() == ':') {
             m_nextPos++;
 
-            //It might be an axis name.
+            // It might be an axis name.
             Step::Axis axis;
             if (isAxisName(name, axis))
                 return Token(AXISNAME, axis);
             // Ugh, :: is only valid in axis names -> error
             return Token(XPATH_ERROR);
         }
 
-        // Seems like this is a fully qualified qname, or perhaps the * modified one from NameTest
+        // Seems like this is a fully qualified qname, or perhaps the * modified
+        // one from NameTest
         skipWS();
         if (peekCurHelper() == '*') {
             m_nextPos++;
             return Token(NAMETEST, name + ":*");
         }
 
         // Make a full qname.
         String n2;
         if (!lexNCName(n2))
             return Token(XPATH_ERROR);
 
         name = name + ":" + n2;
     }
 
     skipWS();
     if (peekCurHelper() == '(') {
-        //note: we don't swallow the (here!
+        // Note: we don't swallow the ( here!
 
-        //either node type of function name
+        // Either node type of function name
         if (isNodeTypeName(name)) {
             if (name == "processing-instruction")
                 return Token(PI, name);
 
             return Token(NODETYPE, name);
         }
-        //must be a function name.
+        // Must be a function name.
         return Token(FUNCTIONNAME, name);
     }
 
     // At this point, it must be NAMETEST.
     return Token(NAMETEST, name);
 }
 
 Token Parser::nextToken()
 {
     Token toRet = nextTokenInternal();
@@ skipping 235 matching lines @@
 #if !ENABLE(OILPAN)
     if (t == 0)
         return;
 
     ASSERT(m_nodeTests.contains(t));
 
     m_nodeTests.remove(t);
 #endif
 }