Update tokenizer to match spec

sky/engine/core/html/parser/HTMLTokenizer.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Torch Mobile, Inc. http://www.torchmobile.com/
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 44 matching lines @@
 bool AtomicHTMLToken::usesName() const
 {
     return m_type == HTMLToken::StartTag || m_type == HTMLToken::EndTag;
 }
 
 bool AtomicHTMLToken::usesAttributes() const
 {
     return m_type == HTMLToken::StartTag || m_type == HTMLToken::EndTag;
 }
 
-static inline UChar toLowerCase(UChar cc)
-{
-    ASSERT(isASCIIUpper(cc));
-    const int lowerCaseOffset = 0x20;
-    return cc + lowerCaseOffset;
-}
-
-static inline bool vectorEqualsString(const Vector<LChar, 32>& vector, const String& string)
-{
-    if (vector.size() != string.length())
-        return false;
-
-    if (!string.length())
-        return true;
-
-    return equal(string.impl(), vector.data(), vector.size());
-}
-
 static inline bool isEndTagBufferingState(HTMLTokenizer::State state)
 {
-    switch (state) {
-    case HTMLTokenizer::RAWTEXTEndTagOpenState:
-    case HTMLTokenizer::RAWTEXTEndTagNameState:
-        return true;
-    default:
-        return false;
-    }
+    return state == HTMLTokenizer::RawDataEndTagOpenState || state == HTMLTokenizer::RawDataEndTagNameState;
 }
 
 #define HTML_BEGIN_STATE(stateName) BEGIN_STATE(HTMLTokenizer, stateName)
 #define HTML_RECONSUME_IN(stateName) RECONSUME_IN(HTMLTokenizer, stateName)
 #define HTML_ADVANCE_TO(stateName) ADVANCE_TO(HTMLTokenizer, stateName)
 #define HTML_SWITCH_TO(stateName) SWITCH_TO(HTMLTokenizer, stateName)
 
 HTMLTokenizer::HTMLTokenizer()
     : m_inputStreamPreprocessor(this)
 {
     reset();
 }
 
 HTMLTokenizer::~HTMLTokenizer()
 {
 }
 
 void HTMLTokenizer::reset()
 {
     m_state = HTMLTokenizer::DataState;
     m_token = 0;
 }
 
 bool HTMLTokenizer::flushBufferedEndTag(SegmentedString& source)
 {
     ASSERT(m_token->type() == HTMLToken::Character || m_token->type() == HTMLToken::Uninitialized);
     source.advanceAndUpdateLineNumber();
     if (m_token->type() == HTMLToken::Character)
         return true;
-    m_token->beginEndTag(m_bufferedEndTagName);
-    m_bufferedEndTagName.clear();
+    m_token->beginEndTag(m_temporaryBuffer);
     m_appropriateEndTagName.clear();
     m_temporaryBuffer.clear();
     return false;
 }
 
 #define FLUSH_AND_ADVANCE_TO(stateName)                                    \
     do {                                                                   \
         m_state = HTMLTokenizer::stateName;                                \
         if (flushBufferedEndTag(source))                                   \
             return true;                                                   \
@@ skipping 11 matching lines @@
     return true;
 }
 
 bool HTMLTokenizer::nextToken(SegmentedString& source, HTMLToken& token)
 {
     // If we have a token in progress, then we're supposed to be called back
     // with the same token so we can finish it.
     ASSERT(!m_token || m_token == &token || token.type() == HTMLToken::Uninitialized);
     m_token = &token;
 
-    if (!m_bufferedEndTagName.isEmpty() && !isEndTagBufferingState(m_state)) {
+    if (!m_temporaryBuffer.isEmpty() && !isEndTagBufferingState(m_state)) {
         // FIXME: This should call flushBufferedEndTag().
         // We started an end tag during our last iteration.
-        m_token->beginEndTag(m_bufferedEndTagName);
-        m_bufferedEndTagName.clear();
+        m_token->beginEndTag(m_temporaryBuffer);
         m_appropriateEndTagName.clear();
         m_temporaryBuffer.clear();
         if (m_state == HTMLTokenizer::DataState) {
             // We're back in the data state, so we must be done with the tag.
             return true;
         }
     }
 
     if (source.isEmpty() || !m_inputStreamPreprocessor.peek(source))
         return haveBufferedCharacterToken();
     UChar cc = m_inputStreamPreprocessor.nextInputCharacter();
 
     // Source: http://www.whatwg.org/specs/web-apps/current-work/#tokenisation0
     switch (m_state) {
     HTML_BEGIN_STATE(DataState) {
         if (cc == '&') {
             m_returnState = DataState;
             m_entityParser.reset();
             HTML_ADVANCE_TO(CharacterReferenceInDataState);
         } else if (cc == '<') {
             if (m_token->type() == HTMLToken::Character) {
                 // We have a bunch of character tokens queued up that we
                 // are emitting lazily here.
                 return true;
             }
             HTML_ADVANCE_TO(TagOpenState);
-        } else if (cc == kEndOfFileMarker)
+        } else if (cc == kEndOfFileMarker) {
             return emitEndOfFile(source);
-        else {
+        } else {
             bufferCharacter(cc);
             HTML_ADVANCE_TO(DataState);
         }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(CharacterReferenceInDataState) {
         if (!m_entityParser.parse(source))
             return haveBufferedCharacterToken();
         for (const UChar& entityCharacter : m_entityParser.result())
@@ skipping 15 matching lines @@
             HTML_SWITCH_TO(AttributeValueDoubleQuotedState);
         else if (m_returnState == AttributeValueSingleQuotedState)
             HTML_SWITCH_TO(AttributeValueSingleQuotedState);
         else if (m_returnState == AttributeValueUnquotedState)
             HTML_SWITCH_TO(AttributeValueUnquotedState);
         else
             ASSERT_NOT_REACHED();
     }
     END_STATE()
 
-    HTML_BEGIN_STATE(RAWTEXTState) {
-        if (cc == '<')
-            HTML_ADVANCE_TO(RAWTEXTLessThanSignState);
-        else if (cc == kEndOfFileMarker)
-            return emitEndOfFile(source);
-        else {
+    HTML_BEGIN_STATE(RawDataState) {
+        if (cc == '<') {
+            HTML_ADVANCE_TO(RawDataLessThanSignState);
+        } else {
             bufferCharacter(cc);
-            HTML_ADVANCE_TO(RAWTEXTState);
+            HTML_ADVANCE_TO(RawDataState);
+        }
+    }
+    END_STATE()
+
+    HTML_BEGIN_STATE(RawDataLessThanSignState) {
+        if (cc == '/') {
+            m_temporaryBuffer.clear();
+            HTML_ADVANCE_TO(RawDataEndTagOpenState);
+        } else {
+            bufferCharacter('<');
+            HTML_RECONSUME_IN(RawDataState);
+        }
+    }
+    END_STATE()
+
+    HTML_BEGIN_STATE(RawDataEndTagOpenState) {
+        if (isASCIILower(cc)) {
+            m_temporaryBuffer.append(static_cast<LChar>(cc));
+            HTML_ADVANCE_TO(RawDataEndTagNameState);
+        } else {
+            bufferCharacter('<');
+            bufferCharacter('/');
+            HTML_RECONSUME_IN(RawDataState);
+        }
+    }
+    END_STATE()
+
+    HTML_BEGIN_STATE(RawDataEndTagNameState) {
+        if (isASCIILower(cc)) {
+            m_temporaryBuffer.append(static_cast<LChar>(cc));
+            HTML_ADVANCE_TO(RawDataEndTagNameState);
+        } else {
+            if (isTokenizerWhitespace(cc)) {
+                if (isAppropriateEndTag())
+                    FLUSH_AND_ADVANCE_TO(BeforeAttributeNameState);
+            } else if (cc == '/') {
+                if (isAppropriateEndTag())
+                    FLUSH_AND_ADVANCE_TO(VoidTagState);
+            } else if (cc == '>') {
+                if (isAppropriateEndTag())
+                    return flushEmitAndResumeIn(source, HTMLTokenizer::DataState);
+            }
+            bufferCharacter('<');
+            bufferCharacter('/');
+            m_token->appendToCharacter(m_temporaryBuffer);
+            m_temporaryBuffer.clear();
+            HTML_RECONSUME_IN(RawDataState);
         }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(TagOpenState) {
-        if (cc == '!')
+        if (cc == '!') {
             HTML_ADVANCE_TO(CommentStart1State);
-        else if (cc == '/')
+        } else if (cc == '/') {
             HTML_ADVANCE_TO(CloseTagState);
-        else if (isASCIIUpper(cc)) {
-            m_token->beginStartTag(toLowerCase(cc));
-            HTML_ADVANCE_TO(TagNameState);
-        } else if (isASCIILower(cc)) {
-            m_token->beginStartTag(cc);
+        } else if (isTokenizerTagName(cc)) {
+            m_token->beginStartTag(static_cast<LChar>(cc));
             HTML_ADVANCE_TO(TagNameState);
         } else {
-            parseError();
             bufferCharacter('<');
             HTML_RECONSUME_IN(DataState);
         }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(CloseTagState) {
-        if (isASCIIUpper(cc)) {
-            m_token->beginEndTag(static_cast<LChar>(toLowerCase(cc)));
-            m_appropriateEndTagName.clear();
-            HTML_ADVANCE_TO(TagNameState);
-        } else if (isASCIILower(cc)) {
+        if (isTokenizerTagName(cc)) {
             m_token->beginEndTag(static_cast<LChar>(cc));
-            m_appropriateEndTagName.clear();
             HTML_ADVANCE_TO(TagNameState);
         } else if (cc == '>') {
             bufferCharacter('<');
             bufferCharacter('/');
             bufferCharacter('>');
             HTML_ADVANCE_TO(DataState);
         } else {
             bufferCharacter('<');
             bufferCharacter('/');
             HTML_RECONSUME_IN(DataState);
         }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(TagNameState) {
-        if (isTokenizerWhitespace(cc))
+        if (isTokenizerWhitespace(cc)) {
             HTML_ADVANCE_TO(BeforeAttributeNameState);
-        else if (cc == '/')
-            HTML_ADVANCE_TO(SelfClosingStartTagState);
-        else if (cc == '>')
+        } else if (cc == '/') {
+            HTML_ADVANCE_TO(VoidTagState);
+        } else if (cc == '>') {
             return emitAndResumeIn(source, HTMLTokenizer::DataState);
-        else if (isASCIIUpper(cc)) {
-            m_token->appendToName(toLowerCase(cc));
-            HTML_ADVANCE_TO(TagNameState);
-        } else if (cc == kEndOfFileMarker) {
-            parseError();
-            HTML_RECONSUME_IN(DataState);
         } else {
             m_token->appendToName(cc);
             HTML_ADVANCE_TO(TagNameState);
         }
     }
     END_STATE()
 
-    HTML_BEGIN_STATE(RAWTEXTLessThanSignState) {
-        if (cc == '/') {
-            m_temporaryBuffer.clear();
-            ASSERT(m_bufferedEndTagName.isEmpty());
-            HTML_ADVANCE_TO(RAWTEXTEndTagOpenState);
-        } else {
-            bufferCharacter('<');
-            HTML_RECONSUME_IN(RAWTEXTState);
-        }
-    }
-    END_STATE()
-
-    HTML_BEGIN_STATE(RAWTEXTEndTagOpenState) {
-        if (isASCIIUpper(cc)) {
-            m_temporaryBuffer.append(static_cast<LChar>(cc));
-            addToPossibleEndTag(static_cast<LChar>(toLowerCase(cc)));
-            HTML_ADVANCE_TO(RAWTEXTEndTagNameState);
-        } else if (isASCIILower(cc)) {
-            m_temporaryBuffer.append(static_cast<LChar>(cc));
-            addToPossibleEndTag(static_cast<LChar>(cc));
-            HTML_ADVANCE_TO(RAWTEXTEndTagNameState);
-        } else {
-            bufferCharacter('<');
-            bufferCharacter('/');
-            HTML_RECONSUME_IN(RAWTEXTState);
-        }
-    }
-    END_STATE()
-
-    HTML_BEGIN_STATE(RAWTEXTEndTagNameState) {
-        if (isASCIIUpper(cc)) {
-            m_temporaryBuffer.append(static_cast<LChar>(cc));
-            addToPossibleEndTag(static_cast<LChar>(toLowerCase(cc)));
-            HTML_ADVANCE_TO(RAWTEXTEndTagNameState);
-        } else if (isASCIILower(cc)) {
-            m_temporaryBuffer.append(static_cast<LChar>(cc));
-            addToPossibleEndTag(static_cast<LChar>(cc));
-            HTML_ADVANCE_TO(RAWTEXTEndTagNameState);
-        } else {
-            if (isTokenizerWhitespace(cc)) {
-                if (isAppropriateEndTag()) {
-                    m_temporaryBuffer.append(static_cast<LChar>(cc));
-                    FLUSH_AND_ADVANCE_TO(BeforeAttributeNameState);
-                }
-            } else if (cc == '/') {
-                if (isAppropriateEndTag()) {
-                    m_temporaryBuffer.append(static_cast<LChar>(cc));
-                    FLUSH_AND_ADVANCE_TO(SelfClosingStartTagState);
-                }
-            } else if (cc == '>') {
-                if (isAppropriateEndTag()) {
-                    m_temporaryBuffer.append(static_cast<LChar>(cc));
-                    return flushEmitAndResumeIn(source, HTMLTokenizer::DataState);
-                }
-            }
-            bufferCharacter('<');
-            bufferCharacter('/');
-            m_token->appendToCharacter(m_temporaryBuffer);
-            m_bufferedEndTagName.clear();
-            m_temporaryBuffer.clear();
-            HTML_RECONSUME_IN(RAWTEXTState);
-        }
-    }
-    END_STATE()
-
     HTML_BEGIN_STATE(BeforeAttributeNameState) {
-        if (isTokenizerWhitespace(cc))
+        if (isTokenizerWhitespace(cc)) {
             HTML_ADVANCE_TO(BeforeAttributeNameState);
-        else if (cc == '/')
-            HTML_ADVANCE_TO(SelfClosingStartTagState);
-        else if (cc == '>')
+        } else if (cc == '/') {
+            HTML_ADVANCE_TO(VoidTagState);
+        } else if (cc == '>') {
             return emitAndResumeIn(source, HTMLTokenizer::DataState);
-        else if (isASCIIUpper(cc)) {
-            m_token->addNewAttribute();
-            m_token->beginAttributeName(source.numberOfCharactersConsumed());
-            m_token->appendToAttributeName(toLowerCase(cc));
-            HTML_ADVANCE_TO(AttributeNameState);
-        } else if (cc == kEndOfFileMarker) {
-            parseError();
-            HTML_RECONSUME_IN(DataState);
         } else {
-            if (cc == '"' || cc == '\'' || cc == '<' || cc == '=')
-                parseError();
             m_token->addNewAttribute();
             m_token->beginAttributeName(source.numberOfCharactersConsumed());
             m_token->appendToAttributeName(cc);
             HTML_ADVANCE_TO(AttributeNameState);
         }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(AttributeNameState) {
         if (isTokenizerWhitespace(cc)) {
             m_token->endAttributeName(source.numberOfCharactersConsumed());
             HTML_ADVANCE_TO(AfterAttributeNameState);
         } else if (cc == '/') {
             m_token->endAttributeName(source.numberOfCharactersConsumed());
-            HTML_ADVANCE_TO(SelfClosingStartTagState);
+            HTML_ADVANCE_TO(VoidTagState);
         } else if (cc == '=') {
             m_token->endAttributeName(source.numberOfCharactersConsumed());
             HTML_ADVANCE_TO(BeforeAttributeValueState);
         } else if (cc == '>') {
             m_token->endAttributeName(source.numberOfCharactersConsumed());
             return emitAndResumeIn(source, HTMLTokenizer::DataState);
-        } else if (isASCIIUpper(cc)) {
-            m_token->appendToAttributeName(toLowerCase(cc));
-            HTML_ADVANCE_TO(AttributeNameState);
-        } else if (cc == kEndOfFileMarker) {
-            parseError();
-            m_token->endAttributeName(source.numberOfCharactersConsumed());
-            HTML_RECONSUME_IN(DataState);
         } else {
-            if (cc == '"' || cc == '\'' || cc == '<' || cc == '=')
-                parseError();
             m_token->appendToAttributeName(cc);
             HTML_ADVANCE_TO(AttributeNameState);
         }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(AfterAttributeNameState) {
-        if (isTokenizerWhitespace(cc))
+        if (isTokenizerWhitespace(cc)) {
             HTML_ADVANCE_TO(AfterAttributeNameState);
-        else if (cc == '/')
-            HTML_ADVANCE_TO(SelfClosingStartTagState);
-        else if (cc == '=')
+        } else if (cc == '/') {
+            HTML_ADVANCE_TO(VoidTagState);
+        } else if (cc == '=') {
             HTML_ADVANCE_TO(BeforeAttributeValueState);
-        else if (cc == '>')
+        } else if (cc == '>') {
             return emitAndResumeIn(source, HTMLTokenizer::DataState);
-        else if (isASCIIUpper(cc)) {
-            m_token->addNewAttribute();
-            m_token->beginAttributeName(source.numberOfCharactersConsumed());
-            m_token->appendToAttributeName(toLowerCase(cc));
-            HTML_ADVANCE_TO(AttributeNameState);
-        } else if (cc == kEndOfFileMarker) {
-            parseError();
-            HTML_RECONSUME_IN(DataState);
         } else {
-            if (cc == '"' || cc == '\'' || cc == '<')
-                parseError();
             m_token->addNewAttribute();
             m_token->beginAttributeName(source.numberOfCharactersConsumed());
             m_token->appendToAttributeName(cc);
             HTML_ADVANCE_TO(AttributeNameState);
         }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(BeforeAttributeValueState) {
         if (isTokenizerWhitespace(cc))
             HTML_ADVANCE_TO(BeforeAttributeValueState);
         else if (cc == '"') {
             m_token->beginAttributeValue(source.numberOfCharactersConsumed() + 1);
             HTML_ADVANCE_TO(AttributeValueDoubleQuotedState);
         } else if (cc == '&') {
             m_token->beginAttributeValue(source.numberOfCharactersConsumed());
             HTML_RECONSUME_IN(AttributeValueUnquotedState);
         } else if (cc == '\'') {
             m_token->beginAttributeValue(source.numberOfCharactersConsumed() + 1);
             HTML_ADVANCE_TO(AttributeValueSingleQuotedState);
         } else if (cc == '>') {
-            parseError();
             return emitAndResumeIn(source, HTMLTokenizer::DataState);
-        } else if (cc == kEndOfFileMarker) {
-            parseError();
-            HTML_RECONSUME_IN(DataState);
         } else {
-            if (cc == '<' || cc == '=' || cc == '`')
-                parseError();
             m_token->beginAttributeValue(source.numberOfCharactersConsumed());
             m_token->appendToAttributeValue(cc);
             HTML_ADVANCE_TO(AttributeValueUnquotedState);
         }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(AttributeValueDoubleQuotedState) {
         if (cc == '"') {
             m_token->endAttributeValue(source.numberOfCharactersConsumed());
-            HTML_ADVANCE_TO(AfterAttributeValueQuotedState);
+            HTML_ADVANCE_TO(BeforeAttributeNameState);
         } else if (cc == '&') {
             m_returnState = AttributeValueDoubleQuotedState;
             m_entityParser.reset();
             HTML_ADVANCE_TO(CharacterReferenceInAttributeValueState);
-        } else if (cc == kEndOfFileMarker) {
-            parseError();
-            m_token->endAttributeValue(source.numberOfCharactersConsumed());
-            HTML_RECONSUME_IN(DataState);
         } else {
             m_token->appendToAttributeValue(cc);
             HTML_ADVANCE_TO(AttributeValueDoubleQuotedState);
         }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(AttributeValueSingleQuotedState) {
         if (cc == '\'') {
             m_token->endAttributeValue(source.numberOfCharactersConsumed());
-            HTML_ADVANCE_TO(AfterAttributeValueQuotedState);
+            HTML_ADVANCE_TO(BeforeAttributeNameState);
         } else if (cc == '&') {
             m_returnState = AttributeValueSingleQuotedState;
             m_entityParser.reset();
             HTML_ADVANCE_TO(CharacterReferenceInAttributeValueState);
-        } else if (cc == kEndOfFileMarker) {
-            parseError();
-            m_token->endAttributeValue(source.numberOfCharactersConsumed());
-            HTML_RECONSUME_IN(DataState);
         } else {
             m_token->appendToAttributeValue(cc);
             HTML_ADVANCE_TO(AttributeValueSingleQuotedState);
         }
     }
     END_STATE()
 
     HTML_BEGIN_STATE(AttributeValueUnquotedState) {
         if (isTokenizerWhitespace(cc)) {
             m_token->endAttributeValue(source.numberOfCharactersConsumed());
             HTML_ADVANCE_TO(BeforeAttributeNameState);
         } else if (cc == '&') {
             m_returnState = AttributeValueUnquotedState;
             m_entityParser.reset();
             HTML_ADVANCE_TO(CharacterReferenceInAttributeValueState);
         } else if (cc == '>') {
             m_token->endAttributeValue(source.numberOfCharactersConsumed());
             return emitAndResumeIn(source, HTMLTokenizer::DataState);
-        } else if (cc == kEndOfFileMarker) {
-            parseError();
-            m_token->endAttributeValue(source.numberOfCharactersConsumed());
-            HTML_RECONSUME_IN(DataState);
         } else {
-            if (cc == '"' || cc == '\'' || cc == '<' || cc == '=' || cc == '`')
-                parseError();
             m_token->appendToAttributeValue(cc);
             HTML_ADVANCE_TO(AttributeValueUnquotedState);
         }
     }
     END_STATE()
 
-    HTML_BEGIN_STATE(AfterAttributeValueQuotedState) {
-        if (isTokenizerWhitespace(cc))
-            HTML_ADVANCE_TO(BeforeAttributeNameState);
-        else if (cc == '/')
-            HTML_ADVANCE_TO(SelfClosingStartTagState);
-        else if (cc == '>')
+    HTML_BEGIN_STATE(VoidTagState) {
+        if (cc == '>') {
+            m_token->setSelfClosing();
             return emitAndResumeIn(source, HTMLTokenizer::DataState);
-        else if (cc == kEndOfFileMarker) {
-            parseError();
-            HTML_RECONSUME_IN(DataState);
         } else {
-            parseError();
             HTML_RECONSUME_IN(BeforeAttributeNameState);
         }
     }
-    END_STATE()
-
-    HTML_BEGIN_STATE(SelfClosingStartTagState) {
-        if (cc == '>') {
-            m_token->setSelfClosing();
-            return emitAndResumeIn(source, HTMLTokenizer::DataState);
-        } else if (cc == kEndOfFileMarker) {
-            parseError();
-            HTML_RECONSUME_IN(DataState);
-        } else {
-            parseError();
-            HTML_RECONSUME_IN(BeforeAttributeNameState);
-        }
-    }
     END_STATE()
 
     HTML_BEGIN_STATE(CommentStart1State) {
         if (cc == '-') {
             HTML_ADVANCE_TO(CommentStart2State);
         } else {
             bufferCharacter('<');
             bufferCharacter('!');
             HTML_RECONSUME_IN(DataState);
         }
@@ skipping 36 matching lines @@
         else
             HTML_ADVANCE_TO(CommentState);
     }
     END_STATE()
     }
 
     ASSERT_NOT_REACHED();
     return false;
 }
 
-inline bool HTMLTokenizer::temporaryBufferIs(const String& expectedString)
-{
-    return vectorEqualsString(m_temporaryBuffer, expectedString);
-}
-
-inline void HTMLTokenizer::addToPossibleEndTag(LChar cc)
-{
-    ASSERT(isEndTagBufferingState(m_state));
-    m_bufferedEndTagName.append(cc);
-}
-
 inline bool HTMLTokenizer::isAppropriateEndTag()
 {
-    if (m_bufferedEndTagName.size() != m_appropriateEndTagName.size())
+    if (m_temporaryBuffer.size() != m_appropriateEndTagName.size())
         return false;
 
-    size_t numCharacters = m_bufferedEndTagName.size();
+    size_t numCharacters = m_temporaryBuffer.size();
 
     for (size_t i = 0; i < numCharacters; i++) {
-        if (m_bufferedEndTagName[i] != m_appropriateEndTagName[i])
+        if (m_temporaryBuffer[i] != m_appropriateEndTagName[i])
             return false;
     }
 
     return true;
 }
 
 inline void HTMLTokenizer::parseError()
 {
     notImplemented();
 }
 
 }