Changeset 38327 in webkit

Timestamp:

Nov 11, 2008 5:53:37 PM (15 years ago)

Author:

eric@webkit.org

Message:

Reviewed by Antti Koivisto and Sam Weinig.

Clean up HTMLTokenizer a litle
​https://bugs.webkit.org/show_bug.cgi?id=22188

Rename pendingScripts to m_pendingScripts
Rename scriptNode to m_scriptNode make the type specific
Rename pendingSrc to m_pendingSrc
Rename currentPrependingSrc to m_currentPrependingSrc
Rename noMoreData to m_noMoreData and cBuffer to m_cBuffer
Remove long-since-dead kdDebug and qDebug calls
Rename brokenComments to m_brokenComments
Remove HTMLTokenizer includes and document the rest
Rename src to m_src
Rename parser to m_parser and make it an OwnPtr
Rename inWrite to m_inWrite and jsProxy to scriptController
Rename brokenServer to m_brokenServer
Rename buffer to m_buffer and dest to m_dest
Rename size to m_bufferSize
Rename attrName to m_attrName
Rename searchStopper to m_searchStopper and searchStopperLen to m_searchStopperLen
Rename scriptCode* to m_scriptCode* and change scriptCodeMax to m_scriptCodeCapacity
Rename scriptStartLineno to m_currentScriptTagStartLineNumber and tagStartLineno to m_currentTagStartLineNumber
Rename scriptSrc to m_scriptTagSrcAttrValue and scriptSrcCharset to m_scriptTagCharsetAttrValue -- a bit unwieldy, but more precise
Rename flat to selfClosingTag
Rename currToken to m_currentToken

• css/CSSParser.cpp:
• dom/XMLTokenizer.cpp:
• dom/XMLTokenizerLibxml2.cpp:
• html/HTMLDocument.cpp:
• html/HTMLElement.cpp:
• html/HTMLFormControlElement.cpp:
• html/HTMLParser.h:
• html/HTMLTokenizer.cpp: (WebCore::Token::addAttribute): (WebCore::HTMLTokenizer::HTMLTokenizer): (WebCore::HTMLTokenizer::reset): (WebCore::HTMLTokenizer::begin): (WebCore::HTMLTokenizer::processListing): (WebCore::HTMLTokenizer::parseSpecial): (WebCore::HTMLTokenizer::scriptHandler): (WebCore::HTMLTokenizer::scriptExecution): (WebCore::HTMLTokenizer::parseComment): (WebCore::HTMLTokenizer::parseServer): (WebCore::HTMLTokenizer::parseProcessingInstruction): (WebCore::HTMLTokenizer::parseText): (WebCore::HTMLTokenizer::parseEntity): (WebCore::HTMLTokenizer::parseTag): (WebCore::HTMLTokenizer::write): (WebCore::HTMLTokenizer::processingData): (WebCore::HTMLTokenizer::end): (WebCore::HTMLTokenizer::finish): (WebCore::HTMLTokenizer::processToken): (WebCore::HTMLTokenizer::processDoctypeToken): (WebCore::HTMLTokenizer::~HTMLTokenizer): (WebCore::HTMLTokenizer::enlargeBuffer): (WebCore::HTMLTokenizer::enlargeScriptBuffer): (WebCore::HTMLTokenizer::notifyFinished): (WebCore::HTMLTokenizer::setSrc):
• html/HTMLTokenizer.h: (WebCore::Token::Token): (WebCore::Token::reset): (WebCore::HTMLTokenizer::processingContentWrittenByScript): (WebCore::HTMLTokenizer::htmlParser): (WebCore::HTMLTokenizer::checkBuffer): (WebCore::HTMLTokenizer::checkScriptBuffer):
• html/HTMLViewSourceDocument.h:
• rendering/RenderBlock.cpp: (WebCore::RenderBlock::leftRelOffset): (WebCore::RenderBlock::rightRelOffset): (WebCore::RenderBlock::lineWidth):
• xml/XSLTProcessor.cpp:

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• css/CSSParser.cpp (modified) (1 diff)
• dom/XMLTokenizer.cpp (modified) (1 diff)
• dom/XMLTokenizerLibxml2.cpp (modified) (1 diff)
• html/HTMLDocument.cpp (modified) (1 diff)
• html/HTMLElement.cpp (modified) (1 diff)
• html/HTMLFormControlElement.cpp (modified) (1 diff)
• html/HTMLParser.cpp (modified) (3 diffs)
• html/HTMLParser.h (modified) (1 diff)
• html/HTMLTokenizer.cpp (modified) (106 diffs)
• html/HTMLTokenizer.h (modified) (13 diffs)
• html/HTMLViewSourceDocument.h (modified) (1 diff)
• rendering/RenderBlock.cpp (modified) (5 diffs)
• xml/XSLTProcessor.cpp (modified) (1 diff)

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-11-11  Eric Seidel  <eric@webkit.org>
+
+        Reviewed by Antti Koivisto and Sam Weinig.
+
+        Clean up HTMLTokenizer a litle
+        https://bugs.webkit.org/show_bug.cgi?id=22188
+
+        Rename pendingScripts to m_pendingScripts
+        Rename scriptNode to m_scriptNode make the type specific
+        Rename pendingSrc to m_pendingSrc
+        Rename currentPrependingSrc to m_currentPrependingSrc
+        Rename noMoreData to m_noMoreData and cBuffer to m_cBuffer
+        Remove long-since-dead kdDebug and qDebug calls
+        Rename brokenComments to m_brokenComments
+        Remove HTMLTokenizer includes and document the rest
+        Rename src to m_src
+        Rename parser to m_parser and make it an OwnPtr
+        Rename inWrite to m_inWrite and jsProxy to scriptController
+        Rename brokenServer to m_brokenServer
+        Rename buffer to m_buffer and dest to m_dest
+        Rename size to m_bufferSize
+        Rename attrName to m_attrName
+        Rename searchStopper to m_searchStopper and searchStopperLen to m_searchStopperLen
+        Rename scriptCode* to m_scriptCode* and change scriptCodeMax to m_scriptCodeCapacity
+        Rename scriptStartLineno to m_currentScriptTagStartLineNumber and tagStartLineno to m_currentTagStartLineNumber
+        Rename scriptSrc to m_scriptTagSrcAttrValue and scriptSrcCharset to m_scriptTagCharsetAttrValue -- a bit unwieldy, but more precise
+        Rename flat to selfClosingTag
+        Rename currToken to m_currentToken
+
+        * css/CSSParser.cpp:
+        * dom/XMLTokenizer.cpp:
+        * dom/XMLTokenizerLibxml2.cpp:
+        * html/HTMLDocument.cpp:
+        * html/HTMLElement.cpp:
+        * html/HTMLFormControlElement.cpp:
+        * html/HTMLParser.h:
+        * html/HTMLTokenizer.cpp:
+        (WebCore::Token::addAttribute):
+        (WebCore::HTMLTokenizer::HTMLTokenizer):
+        (WebCore::HTMLTokenizer::reset):
+        (WebCore::HTMLTokenizer::begin):
+        (WebCore::HTMLTokenizer::processListing):
+        (WebCore::HTMLTokenizer::parseSpecial):
+        (WebCore::HTMLTokenizer::scriptHandler):
+        (WebCore::HTMLTokenizer::scriptExecution):
+        (WebCore::HTMLTokenizer::parseComment):
+        (WebCore::HTMLTokenizer::parseServer):
+        (WebCore::HTMLTokenizer::parseProcessingInstruction):
+        (WebCore::HTMLTokenizer::parseText):
+        (WebCore::HTMLTokenizer::parseEntity):
+        (WebCore::HTMLTokenizer::parseTag):
+        (WebCore::HTMLTokenizer::write):
+        (WebCore::HTMLTokenizer::processingData):
+        (WebCore::HTMLTokenizer::end):
+        (WebCore::HTMLTokenizer::finish):
+        (WebCore::HTMLTokenizer::processToken):
+        (WebCore::HTMLTokenizer::processDoctypeToken):
+        (WebCore::HTMLTokenizer::~HTMLTokenizer):
+        (WebCore::HTMLTokenizer::enlargeBuffer):
+        (WebCore::HTMLTokenizer::enlargeScriptBuffer):
+        (WebCore::HTMLTokenizer::notifyFinished):
+        (WebCore::HTMLTokenizer::setSrc):
+        * html/HTMLTokenizer.h:
+        (WebCore::Token::Token):
+        (WebCore::Token::reset):
+        (WebCore::HTMLTokenizer::processingContentWrittenByScript):
+        (WebCore::HTMLTokenizer::htmlParser):
+        (WebCore::HTMLTokenizer::checkBuffer):
+        (WebCore::HTMLTokenizer::checkScriptBuffer):
+        * html/HTMLViewSourceDocument.h:
+        * rendering/RenderBlock.cpp:
+        (WebCore::RenderBlock::leftRelOffset):
+        (WebCore::RenderBlock::rightRelOffset):
+        (WebCore::RenderBlock::lineWidth):
+        * xml/XSLTProcessor.cpp:
+
 2008-11-11  Sam Weinig  <sam@webkit.org>
 

trunk/WebCore/css/CSSParser.cpp

@@ -4139 +4139 @@
 }
 
-#ifdef CSS_DEBUG
-
-static inline int yyerror(const char *str)
-{
-    kdDebug(6080) << "CSS parse error " << str << endl;
-    return 1;
-}
-
-#else
-
 static inline int yyerror(const char*) { return 1; }
-
-#endif
 
 #define END_TOKEN 0

trunk/WebCore/dom/XMLTokenizer.cpp

@@ -41 +41 @@
 #include "HTMLScriptElement.h"
 #include "HTMLStyleElement.h"
-#include "HTMLTokenizer.h"
 #include "ScriptController.h"
 #include "ProcessingInstruction.h"

trunk/WebCore/dom/XMLTokenizerLibxml2.cpp

@@ -39 +39 @@
 #include "HTMLLinkElement.h"
 #include "HTMLStyleElement.h"
-#include "HTMLTokenizer.h"
+#include "HTMLTokenizer.h" // for decodeNamedEntity
 #include "ScriptController.h"
 #include "ProcessingInstruction.h"

trunk/WebCore/html/HTMLDocument.cpp

@@ -67 +67 @@
 #include "FrameView.h"
 #include "HTMLBodyElement.h"
-#include "HTMLElement.h"
 #include "HTMLElementFactory.h"
 #include "HTMLNames.h"

trunk/WebCore/html/HTMLElement.cpp

@@ -37 +37 @@
 #include "HTMLFormElement.h"
 #include "HTMLNames.h"
-#include "HTMLTokenizer.h"
+#include "HTMLTokenizer.h" // parseHTMLDocumentFragment
 #include "RenderWordBreak.h"
 #include "Settings.h"

trunk/WebCore/html/HTMLFormControlElement.cpp

@@ -36 +36 @@
 #include "HTMLTokenizer.h"
 #include "RenderTheme.h"
-#include "Tokenizer.h"
 
 namespace WebCore {

trunk/WebCore/html/HTMLParser.cpp

@@ -225 +225 @@
             // split large blocks of text to nodes of manageable size
             n = Text::createWithLengthLimit(document, text, charsLeft);
-            if (!insertNode(n.get(), t->flat))
+            if (!insertNode(n.get(), t->selfClosingTag))
                 return 0;
         }
@@ -255 +255 @@
     }
 
-    if (!insertNode(n.get(), t->flat)) {
+    if (!insertNode(n.get(), t->selfClosingTag)) {
         // we couldn't insert the node
 
@@ -722 +722 @@
 {
     RefPtr<Node> n = handleIsindex(t);
-    if (!inBody) {
+    if (!inBody)
         m_isindexElement = n.release();
-    } else {
-        t->flat = true;
+    else {
+        t->selfClosingTag = true;
         result = n.release();
     }

trunk/WebCore/html/HTMLParser.h

@@ -40 +40 @@
 class HTMLMapElement;
 class Node;
-class Token;
 
 struct HTMLStackElem;
+struct Token;
 
 /**

trunk/WebCore/html/HTMLTokenizer.cpp

@@ -132 +132 @@
 }
 
-inline void Token::addAttribute(Document* doc, AtomicString& attrName, const AtomicString& v, bool viewSourceMode)
+inline void Token::addAttribute(Document* doc, AtomicString& attrName, const AtomicString& attributeValue, bool viewSourceMode)
 {
     if (!attrName.isEmpty()) {
         ASSERT(!attrName.contains('/'));
-        RefPtr<MappedAttribute> a = MappedAttribute::create(attrName, v);
+        RefPtr<MappedAttribute> a = MappedAttribute::create(attrName, attributeValue);
         if (!attrs) {
             attrs = NamedMappedAttrMap::create();
@@ -151 +151 @@
 HTMLTokenizer::HTMLTokenizer(HTMLDocument* doc, bool reportErrors)
     : Tokenizer()
-    , buffer(0)
-    , scriptCode(0)
-    , scriptCodeSize(0)
-    , scriptCodeMaxSize(0)
-    , scriptCodeResync(0)
+    , m_buffer(0)
+    , m_scriptCode(0)
+    , m_scriptCodeSize(0)
+    , m_scriptCodeCapacity(0)
+    , m_scriptCodeResync(0)
     , m_executingScript(0)
     , m_requestingScript(false)
@@ -161 +161 @@
     , m_timer(this, &HTMLTokenizer::timerFired)
     , m_doc(doc)
-    , parser(new HTMLParser(doc, reportErrors))
-    , inWrite(false)
+    , m_parser(new HTMLParser(doc, reportErrors))
+    , m_inWrite(false)
     , m_fragment(false)
 {
@@ -170 +170 @@
 HTMLTokenizer::HTMLTokenizer(HTMLViewSourceDocument* doc)
     : Tokenizer(true)
-    , buffer(0)
-    , scriptCode(0)
-    , scriptCodeSize(0)
-    , scriptCodeMaxSize(0)
-    , scriptCodeResync(0)
+    , m_buffer(0)
+    , m_scriptCode(0)
+    , m_scriptCodeSize(0)
+    , m_scriptCodeCapacity(0)
+    , m_scriptCodeResync(0)
     , m_executingScript(0)
     , m_requestingScript(false)
@@ -180 +180 @@
     , m_timer(this, &HTMLTokenizer::timerFired)
     , m_doc(doc)
-    , parser(0)
-    , inWrite(false)
+    , m_parser(0)
+    , m_inWrite(false)
     , m_fragment(false)
 {
@@ -188 +188 @@
 
 HTMLTokenizer::HTMLTokenizer(DocumentFragment* frag)
-    : buffer(0)
-    , scriptCode(0)
-    , scriptCodeSize(0)
-    , scriptCodeMaxSize(0)
-    , scriptCodeResync(0)
+    : m_buffer(0)
+    , m_scriptCode(0)
+    , m_scriptCodeSize(0)
+    , m_scriptCodeCapacity(0)
+    , m_scriptCodeResync(0)
     , m_executingScript(0)
     , m_requestingScript(false)
@@ -198 +198 @@
     , m_timer(this, &HTMLTokenizer::timerFired)
     , m_doc(frag->document())
-    , inWrite(false)
+    , m_parser(new HTMLParser(frag))
+    , m_inWrite(false)
     , m_fragment(true)
 {
-    parser = new HTMLParser(frag);
     begin();
 }
@@ -209 +209 @@
     ASSERT(m_executingScript == 0);
 
-    while (!pendingScripts.isEmpty()) {
-        CachedScript *cs = pendingScripts.first().get();
-        pendingScripts.removeFirst();
+    while (!m_pendingScripts.isEmpty()) {
+        CachedScript* cs = m_pendingScripts.first().get();
+        m_pendingScripts.removeFirst();
         ASSERT(cache()->disabled() || cs->accessCount() > 0);
         cs->removeClient(this);
     }
-    
-    fastFree(buffer);
-    buffer = dest = 0;
-    size = 0;
-
-    fastFree(scriptCode);
-    scriptCode = 0;
-    scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
+
+    fastFree(m_buffer);
+    m_buffer = m_dest = 0;
+    m_bufferSize = 0;
+
+    fastFree(m_scriptCode);
+    m_scriptCode = 0;
+    m_scriptCodeSize = m_scriptCodeCapacity = m_scriptCodeResync = 0;
 
     m_timer.stop();
@@ -228 +228 @@
     m_state.setForceSynchronous(false);
 
-    currToken.reset();
+    m_currentToken.reset();
     m_doctypeToken.reset();
     m_doctypeSearchCount = 0;
@@ -241 +241 @@
     m_state.setLoadingExtScript(false);
     reset();
-    size = 254;
-    buffer = static_cast<UChar*>(fastMalloc(sizeof(UChar) * 254));
-    dest = buffer;
+    m_bufferSize = 254;
+    m_buffer = static_cast<UChar*>(fastMalloc(sizeof(UChar) * 254));
+    m_dest = m_buffer;
     tquote = NoQuote;
     searchCount = 0;
     m_state.setEntityState(NoEntity);
-    scriptSrc = String();
-    pendingSrc.clear();
-    currentPrependingSrc = 0;
-    noMoreData = false;
-    brokenComments = false;
-    brokenServer = false;
+    m_scriptTagSrcAttrValue = String();
+    m_pendingSrc.clear();
+    m_currentPrependingSrc = 0;
+    m_noMoreData = false;
+    m_brokenComments = false;
+    m_brokenServer = false;
     m_lineNumber = 0;
-    scriptStartLineno = 0;
-    tagStartLineno = 0;
+    m_currentScriptTagStartLineNumber = 0;
+    m_currentTagStartLineNumber = 0;
     m_state.setForceSynchronous(false);
 
@@ -295 +295 @@
                 state.setDiscardLF(false); // We have discarded 1 LF
             else
-                *dest++ = '\n';
+                *m_dest++ = '\n';
 
             /* Check for MS-DOS CRLF sequence */
@@ -304 +304 @@
         } else {
             state.setDiscardLF(false);
-            *dest++ = *list;
+            *m_dest++ = *list;
             list.advance();
         }
@@ -312 +312 @@
 }
 
-HTMLTokenizer::State HTMLTokenizer::parseSpecial(SegmentedString &src, State state)
+HTMLTokenizer::State HTMLTokenizer::parseSpecial(SegmentedString& src, State state)
 {
     ASSERT(state.inTextArea() || state.inTitle() || state.inIFrame() || !state.hasEntityState());
     ASSERT(!state.hasTagState());
     ASSERT(state.inXmp() + state.inTextArea() + state.inTitle() + state.inStyle() + state.inScript() + state.inIFrame() == 1 );
-    if (state.inScript() && !scriptStartLineno)
-        scriptStartLineno = m_lineNumber + 1; // Script line numbers are 1 based.
+    if (state.inScript() && !m_currentScriptTagStartLineNumber)
+        m_currentScriptTagStartLineNumber = m_lineNumber;
 
     if (state.inComment()) 
@@ -324 +324 @@
 
     int lastDecodedEntityPosition = -1;
-    while ( !src.isEmpty() ) {
+    while (!src.isEmpty()) {
         checkScriptBuffer();
         UChar ch = *src;
 
-        if (!scriptCodeResync && !brokenComments &&
-            !state.inXmp() && ch == '-' && scriptCodeSize >= 3 && !src.escaped() &&
-            scriptCode[scriptCodeSize-3] == '<' && scriptCode[scriptCodeSize-2] == '!' && scriptCode[scriptCodeSize-1] == '-' &&
-            (lastDecodedEntityPosition < scriptCodeSize - 3)) {
+        if (!m_scriptCodeResync && !m_brokenComments &&
+            !state.inXmp() && ch == '-' && m_scriptCodeSize >= 3 && !src.escaped() &&
+            m_scriptCode[m_scriptCodeSize - 3] == '<' && m_scriptCode[m_scriptCodeSize - 2] == '!' && m_scriptCode[m_scriptCodeSize - 1] == '-' &&
+            (lastDecodedEntityPosition < m_scriptCodeSize - 3)) {
             state.setInComment(true);
             state = parseComment(src, state);
             continue;
         }
-        if (scriptCodeResync && !tquote && ch == '>') {
+        if (m_scriptCodeResync && !tquote && ch == '>') {
             src.advancePastNonNewline();
-            scriptCodeSize = scriptCodeResync-1;
-            scriptCodeResync = 0;
-            scriptCode[ scriptCodeSize ] = scriptCode[ scriptCodeSize + 1 ] = 0;
+            m_scriptCodeSize = m_scriptCodeResync - 1;
+            m_scriptCodeResync = 0;
+            m_scriptCode[m_scriptCodeSize] = m_scriptCode[m_scriptCodeSize + 1] = 0;
             if (state.inScript())
                 state = scriptHandler(state);
             else {
-                state = processListing(SegmentedString(scriptCode, scriptCodeSize), state);
+                state = processListing(SegmentedString(m_scriptCode, m_scriptCodeSize), state);
                 processToken();
                 if (state.inStyle()) { 
-                    currToken.tagName = styleTag.localName(); 
-                    currToken.beginTag = false; 
+                    m_currentToken.tagName = styleTag.localName();
+                    m_currentToken.beginTag = false;
                 } else if (state.inTextArea()) { 
-                    currToken.tagName = textareaTag.localName(); 
-                    currToken.beginTag = false; 
+                    m_currentToken.tagName = textareaTag.localName();
+                    m_currentToken.beginTag = false;
                 } else if (state.inTitle()) { 
-                    currToken.tagName = titleTag.localName(); 
-                    currToken.beginTag = false; 
+                    m_currentToken.tagName = titleTag.localName();
+                    m_currentToken.beginTag = false;
                 } else if (state.inXmp()) {
-                    currToken.tagName = xmpTag.localName(); 
-                    currToken.beginTag = false; 
+                    m_currentToken.tagName = xmpTag.localName();
+                    m_currentToken.beginTag = false;
                 } else if (state.inIFrame()) {
-                    currToken.tagName = iframeTag.localName();
-                    currToken.beginTag = false;
+                    m_currentToken.tagName = iframeTag.localName();
+                    m_currentToken.beginTag = false;
                 }
                 processToken();
@@ -370 +370 @@
                 state.setInIFrame(false);
                 tquote = NoQuote;
-                scriptCodeSize = scriptCodeResync = 0;
+                m_scriptCodeSize = m_scriptCodeResync = 0;
             }
             return state;
         }
         // possible end of tagname, lets check.
-        if (!scriptCodeResync && !state.escaped() && !src.escaped() && (ch == '>' || ch == '/' || isASCIISpace(ch)) &&
-             scriptCodeSize >= searchStopperLen &&
-             tagMatch(searchStopper, scriptCode + scriptCodeSize - searchStopperLen, searchStopperLen) &&
-             (lastDecodedEntityPosition < scriptCodeSize - searchStopperLen)) {
-            scriptCodeResync = scriptCodeSize-searchStopperLen+1;
+        if (!m_scriptCodeResync && !state.escaped() && !src.escaped() && (ch == '>' || ch == '/' || isASCIISpace(ch)) &&
+             m_scriptCodeSize >= m_searchStopperLength &&
+             tagMatch(m_searchStopper, m_scriptCode + m_scriptCodeSize - m_searchStopperLength, m_searchStopperLength) &&
+             (lastDecodedEntityPosition < m_scriptCodeSize - m_searchStopperLength)) {
+            m_scriptCodeResync = m_scriptCodeSize-m_searchStopperLength+1;
             tquote = NoQuote;
             continue;
         }
-        if (scriptCodeResync && !state.escaped()) {
+        if (m_scriptCodeResync && !state.escaped()) {
             if (ch == '\"')
                 tquote = (tquote == NoQuote) ? DoubleQuote : ((tquote == SingleQuote) ? SingleQuote : NoQuote);
@@ -392 +392 @@
         }
         state.setEscaped(!state.escaped() && ch == '\\');
-        if (!scriptCodeResync && (state.inTextArea() || state.inTitle() || state.inIFrame()) && !src.escaped() && ch == '&') {
-            UChar* scriptCodeDest = scriptCode+scriptCodeSize;
+        if (!m_scriptCodeResync && (state.inTextArea() || state.inTitle() || state.inIFrame()) && !src.escaped() && ch == '&') {
+            UChar* scriptCodeDest = m_scriptCode + m_scriptCodeSize;
             src.advancePastNonNewline();
             state = parseEntity(src, scriptCodeDest, state, m_cBufferPos, true, false);
-            if (scriptCodeDest == scriptCode + scriptCodeSize)
-                lastDecodedEntityPosition = scriptCodeSize;
+            if (scriptCodeDest == m_scriptCode + m_scriptCodeSize)
+                lastDecodedEntityPosition = m_scriptCodeSize;
             else
-                scriptCodeSize = scriptCodeDest - scriptCode;
+                m_scriptCodeSize = scriptCodeDest - m_scriptCode;
         } else {
-            scriptCode[scriptCodeSize++] = ch;
+            m_scriptCode[m_scriptCodeSize++] = ch;
             src.advance(m_lineNumber);
         }
@@ -413 +413 @@
     // We are inside a <script>
     bool doScriptExec = false;
-    int startLine = scriptStartLineno;
-
-    // Reset scriptStartLineno to indicate that we've finished parsing the current script element
-    scriptStartLineno = 0;
+    int startLine = m_currentScriptTagStartLineNumber + 1; // Script line numbers are 1 based, HTMLTokenzier line numbers are 0 based
+
+    // Reset m_currentScriptTagStartLineNumber to indicate that we've finished parsing the current script element
+    m_currentScriptTagStartLineNumber = 0;
 
     // (Bugzilla 3837) Scripts following a frameset element should not execute or, 
@@ -425 +425 @@
     // don't load external scripts for standalone documents (for now)
     if (!inViewSourceMode()) {
-        if (!scriptSrc.isEmpty() && m_doc->frame()) {
+        if (!m_scriptTagSrcAttrValue.isEmpty() && m_doc->frame()) {
             // forget what we just got; load from src url instead
-            if (!parser->skipMode() && !followingFrameset) {
+            if (!m_parser->skipMode() && !followingFrameset) {
 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
                 if (!m_doc->ownerElement())
@@ -434 +434 @@
                 // The parser might have been stopped by for example a window.close call in an earlier script.
                 // If so, we don't want to load scripts.
-                if (!m_parserStopped && (cs = m_doc->docLoader()->requestScript(scriptSrc, scriptSrcCharset)))
-                    pendingScripts.append(cs);
+                if (!m_parserStopped && (cs = m_doc->docLoader()->requestScript(m_scriptTagSrcAttrValue, m_scriptTagCharsetAttrValue)))
+                    m_pendingScripts.append(cs);
                 else
-                    scriptNode = 0;
+                    m_scriptNode = 0;
             } else
-                scriptNode = 0;
-            scriptSrc = String();
+                m_scriptNode = 0;
+            m_scriptTagSrcAttrValue = String();
         } else {
-            // Parse scriptCode containing <script> info
+            // Parse m_scriptCode containing <script> info
 #if USE(LOW_BANDWIDTH_DISPLAY)
             if (m_doc->inLowBandwidthDisplay()) {
@@ -452 +452 @@
             } else
 #endif
-            doScriptExec = static_cast<HTMLScriptElement*>(scriptNode.get())->shouldExecuteAsJavaScript();
-            scriptNode = 0;
-        }
-    }
-
-    state = processListing(SegmentedString(scriptCode, scriptCodeSize), state);
+            doScriptExec = m_scriptNode->shouldExecuteAsJavaScript();
+            m_scriptNode = 0;
+        }
+    }
+
+    state = processListing(SegmentedString(m_scriptCode, m_scriptCodeSize), state);
     RefPtr<Node> node = processToken();
     String scriptString = node ? node->textContent() : "";
-    currToken.tagName = scriptTag.localName();
-    currToken.beginTag = false;
+    m_currentToken.tagName = scriptTag.localName();
+    m_currentToken.beginTag = false;
     processToken();
 
     state.setInScript(false);
-    scriptCodeSize = scriptCodeResync = 0;
+    m_scriptCodeSize = m_scriptCodeResync = 0;
     
     // FIXME: The script should be syntax highlighted.
@@ -471 +471 @@
         return state;
 
-    SegmentedString *savedPrependingSrc = currentPrependingSrc;
+    SegmentedString* savedPrependingSrc = m_currentPrependingSrc;
     SegmentedString prependingSrc;
-    currentPrependingSrc = &prependingSrc;
-
-    if (!parser->skipMode() && !followingFrameset) {
+    m_currentPrependingSrc = &prependingSrc;
+
+    if (!m_parser->skipMode() && !followingFrameset) {
         if (cs) {
             if (savedPrependingSrc)
-                savedPrependingSrc->append(src);
+                savedPrependingSrc->append(m_src);
             else
-                pendingSrc.prepend(src);
+                m_pendingSrc.prepend(m_src);
             setSrc(SegmentedString());
 
@@ -492 +492 @@
             state = m_state;
             // will be 0 if script was already loaded and ref() executed it
-            if (!pendingScripts.isEmpty())
+            if (!m_pendingScripts.isEmpty())
                 state.setLoadingExtScript(true);
         } else if (!m_fragment && doScriptExec) {
             if (!m_executingScript)
-                pendingSrc.prepend(src);
+                m_pendingSrc.prepend(m_src);
             else
-                prependingSrc = src;
+                prependingSrc = m_src;
             setSrc(SegmentedString());
             state = scriptExecution(scriptString, state, String(), startLine);
@@ -505 +505 @@
 
     if (!m_executingScript && !state.loadingExtScript()) {
-        src.append(pendingSrc);
-        pendingSrc.clear();
+        m_src.append(m_pendingSrc);
+        m_pendingSrc.clear();
     } else if (!prependingSrc.isEmpty()) {
         // restore first so that the write appends in the right place
         // (does not hurt to do it again below)
-        currentPrependingSrc = savedPrependingSrc;
+        m_currentPrependingSrc = savedPrependingSrc;
 
         // we need to do this slightly modified bit of one of the write() cases
-        // because we want to prepend to pendingSrc rather than appending
+        // because we want to prepend to m_pendingSrc rather than appending
         // if there's no previous prependingSrc
-        if (!pendingScripts.isEmpty()) {
-            if (currentPrependingSrc) {
-                currentPrependingSrc->append(prependingSrc);
-            } else {
-                pendingSrc.prepend(prependingSrc);
-            }
+        if (!m_pendingScripts.isEmpty()) {
+            if (m_currentPrependingSrc)
+                m_currentPrependingSrc->append(prependingSrc);
+            else
+                m_pendingSrc.prepend(prependingSrc);
         } else {
             m_state = state;
@@ -529 +528 @@
     
 #if PRELOAD_SCANNER_ENABLED
-    if (!pendingScripts.isEmpty() && !m_executingScript) {
+    if (!m_pendingScripts.isEmpty() && !m_executingScript) {
         if (!m_preloadScanner)
             m_preloadScanner.set(new PreloadScanner(m_doc));
         if (!m_preloadScanner->inProgress()) {
             m_preloadScanner->begin();
-            m_preloadScanner->write(pendingSrc);
+            m_preloadScanner->write(m_pendingSrc);
         }
     }
 #endif
-    currentPrependingSrc = savedPrependingSrc;
+    m_currentPrependingSrc = savedPrependingSrc;
 
     return state;
@@ -550 +549 @@
     String url = scriptURL.isNull() ? m_doc->frame()->document()->url().string() : scriptURL;
 
-    SegmentedString *savedPrependingSrc = currentPrependingSrc;
+    SegmentedString* savedPrependingSrc = m_currentPrependingSrc;
     SegmentedString prependingSrc;
-    currentPrependingSrc = &prependingSrc;
+    m_currentPrependingSrc = &prependingSrc;
 
 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
@@ -573 +572 @@
 
     if (!m_executingScript && !state.loadingExtScript()) {
-        pendingSrc.prepend(prependingSrc);        
-        src.append(pendingSrc);
-        pendingSrc.clear();
+        m_pendingSrc.prepend(prependingSrc);        
+        m_src.append(m_pendingSrc);
+        m_pendingSrc.clear();
     } else if (!prependingSrc.isEmpty()) {
         // restore first so that the write appends in the right place
         // (does not hurt to do it again below)
-        currentPrependingSrc = savedPrependingSrc;
+        m_currentPrependingSrc = savedPrependingSrc;
 
         // we need to do this slightly modified bit of one of the write() cases
-        // because we want to prepend to pendingSrc rather than appending
+        // because we want to prepend to m_pendingSrc rather than appending
         // if there's no previous prependingSrc
-        if (!pendingScripts.isEmpty()) {
-            if (currentPrependingSrc)
-                currentPrependingSrc->append(prependingSrc);
+        if (!m_pendingScripts.isEmpty()) {
+            if (m_currentPrependingSrc)
+                m_currentPrependingSrc->append(prependingSrc);
             else
-                pendingSrc.prepend(prependingSrc);
+                m_pendingSrc.prepend(prependingSrc);
             
 #if PRELOAD_SCANNER_ENABLED
@@ -605 +604 @@
     }
 
-    currentPrependingSrc = savedPrependingSrc;
+    m_currentPrependingSrc = savedPrependingSrc;
 
     return state;
 }
 
-HTMLTokenizer::State HTMLTokenizer::parseComment(SegmentedString &src, State state)
+HTMLTokenizer::State HTMLTokenizer::parseComment(SegmentedString& src, State state)
 {
     // FIXME: Why does this code even run for comments inside <script> and <style>? This seems bogus.
@@ -616 +615 @@
     while (!src.isEmpty()) {
         UChar ch = *src;
-        scriptCode[scriptCodeSize++] = ch;
+        m_scriptCode[m_scriptCodeSize++] = ch;
         if (ch == '>') {
-            bool handleBrokenComments = brokenComments && !(state.inScript() || state.inStyle());
+            bool handleBrokenComments = m_brokenComments && !(state.inScript() || state.inStyle());
             int endCharsCount = 1; // start off with one for the '>' character
-            if (scriptCodeSize > 2 && scriptCode[scriptCodeSize-3] == '-' && scriptCode[scriptCodeSize-2] == '-') {
+            if (m_scriptCodeSize > 2 && m_scriptCode[m_scriptCodeSize-3] == '-' && m_scriptCode[m_scriptCodeSize-2] == '-') {
                 endCharsCount = 3;
-            } else if (scriptCodeSize > 3 && scriptCode[scriptCodeSize-4] == '-' && scriptCode[scriptCodeSize-3] == '-' && 
-                scriptCode[scriptCodeSize-2] == '!') {
+            } else if (m_scriptCodeSize > 3 && m_scriptCode[m_scriptCodeSize-4] == '-' && m_scriptCode[m_scriptCodeSize-3] == '-' && 
+                m_scriptCode[m_scriptCodeSize-2] == '!') {
                 // Other browsers will accept --!> as a close comment, even though it's
                 // not technically valid.
@@ -632 +631 @@
                 if (!(state.inTitle() || state.inScript() || state.inXmp() || state.inTextArea() || state.inStyle() || state.inIFrame())) {
                     checkScriptBuffer();
-                    scriptCode[scriptCodeSize] = 0;
-                    scriptCode[scriptCodeSize + 1] = 0;
-                    currToken.tagName = commentAtom;
-                    currToken.beginTag = true;
-                    state = processListing(SegmentedString(scriptCode, scriptCodeSize - endCharsCount), state);
+                    m_scriptCode[m_scriptCodeSize] = 0;
+                    m_scriptCode[m_scriptCodeSize + 1] = 0;
+                    m_currentToken.tagName = commentAtom;
+                    m_currentToken.beginTag = true;
+                    state = processListing(SegmentedString(m_scriptCode, m_scriptCodeSize - endCharsCount), state);
                     processToken();
-                    currToken.tagName = commentAtom;
-                    currToken.beginTag = false;
+                    m_currentToken.tagName = commentAtom;
+                    m_currentToken.beginTag = false;
                     processToken();
-                    scriptCodeSize = 0;
+                    m_scriptCodeSize = 0;
                 }
                 state.setInComment(false);
@@ -658 +657 @@
     while (!src.isEmpty()) {
         UChar ch = *src;
-        scriptCode[scriptCodeSize++] = ch;
-        if (ch == '>' && scriptCodeSize > 1 && scriptCode[scriptCodeSize-2] == '%') {
+        m_scriptCode[m_scriptCodeSize++] = ch;
+        if (ch == '>' && m_scriptCodeSize > 1 && m_scriptCode[m_scriptCodeSize - 2] == '%') {
             src.advancePastNonNewline();
             state.setInServer(false);
-            scriptCodeSize = 0;
+            m_scriptCodeSize = 0;
             return state; // Finished parsing server include
         }
@@ -670 +669 @@
 }
 
-HTMLTokenizer::State HTMLTokenizer::parseProcessingInstruction(SegmentedString &src, State state)
+HTMLTokenizer::State HTMLTokenizer::parseProcessingInstruction(SegmentedString& src, State state)
 {
     UChar oldchar = 0;
@@ -696 +695 @@
 }
 
-HTMLTokenizer::State HTMLTokenizer::parseText(SegmentedString &src, State state)
+HTMLTokenizer::State HTMLTokenizer::parseText(SegmentedString& src, State state)
 {
     while (!src.isEmpty()) {
@@ -714 +713 @@
         if (cc == '\r') {
             state.setSkipLF(true);
-            *dest++ = '\n';
+            *m_dest++ = '\n';
         } else
-            *dest++ = cc;
+            *m_dest++ = cc;
         src.advance(m_lineNumber);
     }
@@ -724 +723 @@
 
 
-HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, UChar*& dest, State state, unsigned &cBufferPos, bool start, bool parsingTag)
-{
-    if (start)
-    {
+HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString& src, UChar*& dest, State state, unsigned& cBufferPos, bool start, bool parsingTag)
+{
+    if (start) {
         cBufferPos = 0;
         state.setEntityState(SearchEntity);
@@ -733 +731 @@
     }
 
-    while(!src.isEmpty())
-    {
+    while(!src.isEmpty()) {
         UChar cc = *src;
         switch(state.entityState()) {
@@ -743 +740 @@
         case SearchEntity:
             if (cc == '#') {
-                cBuffer[cBufferPos++] = cc;
+                m_cBuffer[cBufferPos++] = cc;
                 src.advancePastNonNewline();
                 state.setEntityState(NumericSearch);
@@ -752 +749 @@
         case NumericSearch:
             if (cc == 'x' || cc == 'X') {
-                cBuffer[cBufferPos++] = cc;
+                m_cBuffer[cBufferPos++] = cc;
                 src.advancePastNonNewline();
                 state.setEntityState(Hexadecimal);
@@ -775 +772 @@
                     digit = (cc - 'A' + 10) & 0xF; // handle both upper and lower case without a branch
                 EntityUnicodeValue = EntityUnicodeValue * 16 + digit;
-                cBuffer[cBufferPos++] = cc;
+                m_cBuffer[cBufferPos++] = cc;
                 src.advancePastNonNewline();
             }
@@ -794 +791 @@
 
                 EntityUnicodeValue = EntityUnicodeValue * 10 + (cc - '0');
-                cBuffer[cBufferPos++] = cc;
+                m_cBuffer[cBufferPos++] = cc;
                 src.advancePastNonNewline();
             }
@@ -812 +809 @@
                 }
 
-                cBuffer[cBufferPos++] = cc;
+                m_cBuffer[cBufferPos++] = cc;
                 src.advancePastNonNewline();
             }
@@ -829 +826 @@
                     ASSERT(cBufferPos < 10);
                     for (; testedEntityNameLen < cBufferPos; ++testedEntityNameLen) {
-                        if (cBuffer[testedEntityNameLen] > 0x7e)
+                        if (m_cBuffer[testedEntityNameLen] > 0x7e)
                             break;
-                        tmpEntityNameBuffer[testedEntityNameLen] = cBuffer[testedEntityNameLen];
+                        tmpEntityNameBuffer[testedEntityNameLen] = m_cBuffer[testedEntityNameLen];
                     }
 
@@ -872 +869 @@
                     *dest++ = '&';
                     for (unsigned i = 0; i < cBufferPos; i++)
-                        dest[i] = cBuffer[i];
+                        dest[i] = m_cBuffer[i];
                     dest += cBufferPos;
                     if (*src == ';') {
@@ -884 +881 @@
                 *dest++ = '&';
                 for (unsigned i = 0; i < cBufferPos; i++)
-                    dest[i] = cBuffer[i];
+                    dest[i] = m_cBuffer[i];
                 dest += cBufferPos;
             }
@@ -1112 +1109 @@
 }
 
-HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
+HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString& src, State state)
 {
     ASSERT(!state.hasEntityState());
@@ -1140 +1137 @@
                         // Found '<!--' sequence
                         src.advancePastNonNewline();
-                        dest = buffer; // ignore the previous part of this tag
+                        m_dest = m_buffer; // ignore the previous part of this tag
                         state.setInComment(true);
                         state.setTagState(NoTag);
@@ -1151 +1148 @@
                             src.advancePastNonNewline();
                             if (!src.isEmpty())
-                                cBuffer[cBufferPos++] = *src;
+                                m_cBuffer[cBufferPos++] = *src;
                         } else
                           state = parseComment(src, state);
@@ -1158 +1155 @@
                         return state; // Finished parsing tag!
                     }
-                    cBuffer[cBufferPos++] = *src;
+                    m_cBuffer[cBufferPos++] = *src;
                     src.advancePastNonNewline();
                     break;
@@ -1168 +1165 @@
                 if (toASCIILower(*src) == doctypeStart[m_doctypeSearchCount]) {
                     m_doctypeSearchCount++;
-                    cBuffer[cBufferPos++] = *src;
+                    m_cBuffer[cBufferPos++] = *src;
                     src.advancePastNonNewline();
                     if (m_doctypeSearchCount == 9) {
@@ -1176 +1173 @@
                         m_doctypeToken.reset();
                         if (inViewSourceMode())
-                            m_doctypeToken.m_source.append(cBuffer, cBufferPos);
+                            m_doctypeToken.m_source.append(m_cBuffer, cBufferPos);
                         state = parseDoctype(src, state);
                         m_cBufferPos = cBufferPos;
@@ -1197 +1194 @@
                 // tolower() shows up on profiles. This is faster!
                 if (curchar >= 'A' && curchar <= 'Z' && !inViewSourceMode())
-                    cBuffer[cBufferPos++] = curchar + ('a' - 'A');
+                    m_cBuffer[cBufferPos++] = curchar + ('a' - 'A');
                 else
-                    cBuffer[cBufferPos++] = curchar;
+                    m_cBuffer[cBufferPos++] = curchar;
                 src.advancePastNonNewline();
             }
@@ -1205 +1202 @@
             // Disadvantage: we add the possible rest of the tag
             // as attribute names. ### judge if this causes problems
-            if(finish || CBUFLEN == cBufferPos) {
+            if (finish || CBUFLEN == cBufferPos) {
                 bool beginTag;
-                UChar* ptr = cBuffer;
+                UChar* ptr = m_cBuffer;
                 unsigned int len = cBufferPos;
-                cBuffer[cBufferPos] = '\0';
+                m_cBuffer[cBufferPos] = '\0';
                 if ((cBufferPos > 0) && (*ptr == '/')) {
                     // End Tag
@@ -1227 +1224 @@
                 // FIXME: FireFox and WinIE turn !foo nodes into comments, we ignore comments. (fast/parser/tag-with-exclamation-point.html)
                 if (ptr[0] != '!' || inViewSourceMode()) {
-                    currToken.tagName = AtomicString(ptr);
-                    currToken.beginTag = beginTag;
-                }
-                dest = buffer;
+                    m_currentToken.tagName = AtomicString(ptr);
+                    m_currentToken.beginTag = beginTag;
+                }
+                m_dest = m_buffer;
                 state.setTagState(SearchAttribute);
                 cBufferPos = 0;
@@ -1237 +1234 @@
         }
         case SearchAttribute:
-#if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
-            qDebug("SearchAttribute");
-#endif
             while(!src.isEmpty()) {
                 UChar curchar = *src;
@@ -1253 +1247 @@
                 }
                 if (inViewSourceMode())
-                    currToken.addViewSourceChar(curchar);
+                    m_currentToken.addViewSourceChar(curchar);
                 src.advance(m_lineNumber);
             }
@@ -1259 +1253 @@
         case AttributeName:
         {
-#if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
-            qDebug("AttributeName");
-#endif
-            int ll = min(src.length(), CBUFLEN-cBufferPos);
-            while(ll--) {
+            int ll = min(src.length(), CBUFLEN - cBufferPos);
+            while (ll--) {
                 UChar curchar = *src;
                 // If we encounter a "/" when scanning an attribute name, treat it as a delimiter.  This allows the 
                 // cases like <input type=checkbox checked/> to work (and accommodates XML-style syntax as per HTML5).
                 if (curchar <= '>' && (curchar >= '<' || isASCIISpace(curchar) || curchar == '/')) {
-                    cBuffer[cBufferPos] = '\0';
-                    attrName = AtomicString(cBuffer);
-                    dest = buffer;
-                    *dest++ = 0;
+                    m_cBuffer[cBufferPos] = '\0';
+                    m_attrName = AtomicString(m_cBuffer);
+                    m_dest = m_buffer;
+                    *m_dest++ = 0;
                     state.setTagState(SearchEqual);
                     if (inViewSourceMode())
-                        currToken.addViewSourceChar('a');
+                        m_currentToken.addViewSourceChar('a');
                     break;
                 }
@@ -1280 +1271 @@
                 // tolower() shows up on profiles. This is faster!
                 if (curchar >= 'A' && curchar <= 'Z' && !inViewSourceMode())
-                    cBuffer[cBufferPos++] = curchar + ('a' - 'A');
+                    m_cBuffer[cBufferPos++] = curchar + ('a' - 'A');
                 else
-                    cBuffer[cBufferPos++] = curchar;
+                    m_cBuffer[cBufferPos++] = curchar;
                     
                 src.advance(m_lineNumber);
             }
-            if ( cBufferPos == CBUFLEN ) {
-                cBuffer[cBufferPos] = '\0';
-                attrName = AtomicString(cBuffer);
-                dest = buffer;
-                *dest++ = 0;
+            if (cBufferPos == CBUFLEN) {
+                m_cBuffer[cBufferPos] = '\0';
+                m_attrName = AtomicString(m_cBuffer);
+                m_dest = m_buffer;
+                *m_dest++ = 0;
                 state.setTagState(SearchEqual);
                 if (inViewSourceMode())
-                    currToken.addViewSourceChar('a');
+                    m_currentToken.addViewSourceChar('a');
             }
             break;
         }
         case SearchEqual:
-#if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
-            qDebug("SearchEqual");
-#endif
-            while(!src.isEmpty()) {
+            while (!src.isEmpty()) {
                 UChar curchar = *src;
 
@@ -1307 +1295 @@
                     // This is a quirk (with a long sad history).  We have to do this
                     // since widgets do <script src="foo.js"/> and expect the tag to close.
-                    if (currToken.tagName == scriptTag)
-                        currToken.flat = true;
-                    currToken.brokenXMLStyle = true;
+                    if (m_currentToken.tagName == scriptTag)
+                        m_currentToken.selfClosingTag = true;
+                    m_currentToken.brokenXMLStyle = true;
                 }
 
@@ -1315 +1303 @@
                 if (!isASCIISpace(curchar) && curchar != '\'' && curchar != '"' && curchar != '/') {
                     if (curchar == '=') {
-#ifdef TOKEN_DEBUG
-                        kdDebug(6036) << "found equal" << endl;
-#endif
                         state.setTagState(SearchValue);
                         if (inViewSourceMode())
-                            currToken.addViewSourceChar(curchar);
+                            m_currentToken.addViewSourceChar(curchar);
                         src.advancePastNonNewline();
                     } else {
-                        currToken.addAttribute(m_doc, attrName, emptyAtom, inViewSourceMode());
-                        dest = buffer;
+                        m_currentToken.addAttribute(m_doc, m_attrName, emptyAtom, inViewSourceMode());
+                        m_dest = m_buffer;
                         state.setTagState(SearchAttribute);
                         lastIsSlash = false;
@@ -1331 +1316 @@
                 }
                 if (inViewSourceMode())
-                    currToken.addViewSourceChar(curchar);
+                    m_currentToken.addViewSourceChar(curchar);
                     
                 lastIsSlash = curchar == '/';
@@ -1346 +1331 @@
                         state.setTagState(QuotedValue);
                         if (inViewSourceMode())
-                            currToken.addViewSourceChar(curchar);
+                            m_currentToken.addViewSourceChar(curchar);
                         src.advancePastNonNewline();
                     } else
@@ -1354 +1339 @@
                 }
                 if (inViewSourceMode())
-                    currToken.addViewSourceChar(curchar);
+                    m_currentToken.addViewSourceChar(curchar);
                 src.advance(m_lineNumber);
             }
             break;
         case QuotedValue:
-#if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
-            qDebug("QuotedValue");
-#endif
             while (!src.isEmpty()) {
                 checkBuffer();
@@ -1367 +1349 @@
                 UChar curchar = *src;
                 if (curchar <= '>' && !src.escaped()) {
-                    if (curchar == '>' && attrName.isEmpty()) {
+                    if (curchar == '>' && m_attrName.isEmpty()) {
                         // Handle a case like <img '>.  Just go ahead and be willing
                         // to close the whole tag.  Don't consume the character and
@@ -1375 +1357 @@
                         // It doesn't handle the general case of
                         // unmatched quotes among attributes that have names. -dwh
-                        while (dest > buffer + 1 && (dest[-1] == '\n' || dest[-1] == '\r'))
-                            dest--; // remove trailing newlines
-                        AtomicString v(buffer + 1, dest - buffer - 1);
-                        if (!v.contains('/'))
-                            attrName = v; // Just make the name/value match. (FIXME: Is this some WinIE quirk?)
-                        currToken.addAttribute(m_doc, attrName, v, inViewSourceMode());
+                        while (m_dest > m_buffer + 1 && (m_dest[-1] == '\n' || m_dest[-1] == '\r'))
+                            m_dest--; // remove trailing newlines
+                        AtomicString attributeValue(m_buffer + 1, m_dest - m_buffer - 1);
+                        if (!attributeValue.contains('/'))
+                            m_attrName = attributeValue; // Just make the name/value match. (FIXME: Is this some WinIE quirk?)
+                        m_currentToken.addAttribute(m_doc, m_attrName, attributeValue, inViewSourceMode());
                         if (inViewSourceMode())
-                            currToken.addViewSourceChar('x');
+                            m_currentToken.addViewSourceChar('x');
                         state.setTagState(SearchAttribute);
-                        dest = buffer;
+                        m_dest = m_buffer;
                         tquote = NoQuote;
                         break;
@@ -1391 +1373 @@
                     if (curchar == '&') {
                         src.advancePastNonNewline();
-                        state = parseEntity(src, dest, state, cBufferPos, true, true);
+                        state = parseEntity(src, m_dest, state, cBufferPos, true, true);
                         break;
                     }
@@ -1397 +1379 @@
                     if ((tquote == SingleQuote && curchar == '\'') || (tquote == DoubleQuote && curchar == '\"')) {
                         // some <input type=hidden> rely on trailing spaces. argh
-                        while (dest > buffer + 1 && (dest[-1] == '\n' || dest[-1] == '\r'))
-                            dest--; // remove trailing newlines
-                        AtomicString v(buffer + 1, dest - buffer - 1);
-                        if (attrName.isEmpty() && !v.contains('/')) {
-                            attrName = v; // Make the name match the value. (FIXME: Is this a WinIE quirk?)
+                        while (m_dest > m_buffer + 1 && (m_dest[-1] == '\n' || m_dest[-1] == '\r'))
+                            m_dest--; // remove trailing newlines
+                        AtomicString attributeValue(m_buffer + 1, m_dest - m_buffer - 1);
+                        if (m_attrName.isEmpty() && !attributeValue.contains('/')) {
+                            m_attrName = attributeValue; // Make the name match the value. (FIXME: Is this a WinIE quirk?)
                             if (inViewSourceMode())
-                                currToken.addViewSourceChar('x');
+                                m_currentToken.addViewSourceChar('x');
                         } else if (inViewSourceMode())
-                            currToken.addViewSourceChar('v');
-                        currToken.addAttribute(m_doc, attrName, v, inViewSourceMode());
-                        dest = buffer;
+                            m_currentToken.addViewSourceChar('v');
+                        m_currentToken.addAttribute(m_doc, m_attrName, attributeValue, inViewSourceMode());
+                        m_dest = m_buffer;
                         state.setTagState(SearchAttribute);
                         tquote = NoQuote;
                         if (inViewSourceMode())
-                            currToken.addViewSourceChar(curchar);
+                            m_currentToken.addViewSourceChar(curchar);
                         src.advancePastNonNewline();
                         break;
@@ -1417 +1399 @@
                 }
 
-                *dest++ = curchar;
+                *m_dest++ = curchar;
                 src.advance(m_lineNumber);
             }
             break;
         case Value:
-#if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
-            qDebug("Value");
-#endif
             while(!src.isEmpty()) {
                 checkBuffer();
@@ -1432 +1411 @@
                     if (curchar == '&') {
                         src.advancePastNonNewline();
-                        state = parseEntity(src, dest, state, cBufferPos, true, true);
+                        state = parseEntity(src, m_dest, state, cBufferPos, true, true);
                         break;
                     }
@@ -1438 +1417 @@
                     // '/' does not delimit in IE!
                     if (isASCIISpace(curchar) || curchar == '>') {
-                        AtomicString v(buffer+1, dest-buffer-1);
-                        currToken.addAttribute(m_doc, attrName, v, inViewSourceMode());
+                        AtomicString attributeValue(m_buffer + 1, m_dest - m_buffer - 1);
+                        m_currentToken.addAttribute(m_doc, m_attrName, attributeValue, inViewSourceMode());
                         if (inViewSourceMode())
-                            currToken.addViewSourceChar('v');
-                        dest = buffer;
+                            m_currentToken.addViewSourceChar('v');
+                        m_dest = m_buffer;
                         state.setTagState(SearchAttribute);
                         break;
@@ -1448 +1427 @@
                 }
 
-                *dest++ = curchar;
+                *m_dest++ = curchar;
                 src.advance(m_lineNumber);
             }
@@ -1454 +1433 @@
         case SearchEnd:
         {
-#if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
-                qDebug("SearchEnd");
-#endif
             while (!src.isEmpty()) {
                 UChar ch = *src;
@@ -1462 +1438 @@
                     break;
                 if (ch == '/')
-                    currToken.flat = true;
+                    m_currentToken.selfClosingTag = true;
                 if (inViewSourceMode())
-                    currToken.addViewSourceChar(ch);
+                    m_currentToken.addViewSourceChar(ch);
                 src.advance(m_lineNumber);
             }
-            if (src.isEmpty()) break;
+            if (src.isEmpty())
+                break;
 
             searchCount = 0; // Stop looking for '<!--' sequence
@@ -1476 +1453 @@
                 src.advance(m_lineNumber);
 
-            if (currToken.tagName == nullAtom) { //stop if tag is unknown
+            if (m_currentToken.tagName == nullAtom) { //stop if tag is unknown
                 m_cBufferPos = cBufferPos;
                 return state;
             }
 
-            AtomicString tagName = currToken.tagName;
+            AtomicString tagName = m_currentToken.tagName;
 
             // Handle <script src="foo"/> like Mozilla/Opera. We have to do this now for Dashboard
             // compatibility.
-            bool isSelfClosingScript = currToken.flat && currToken.beginTag && currToken.tagName == scriptTag;
-            bool beginTag = !currToken.flat && currToken.beginTag;
-            if (currToken.beginTag && currToken.tagName == scriptTag && !inViewSourceMode() && !parser->skipMode()) {
+            bool isSelfClosingScript = m_currentToken.selfClosingTag && m_currentToken.beginTag && m_currentToken.tagName == scriptTag;
+            bool beginTag = !m_currentToken.selfClosingTag && m_currentToken.beginTag;
+            if (m_currentToken.beginTag && m_currentToken.tagName == scriptTag && !inViewSourceMode() && !m_parser->skipMode()) {
                 Attribute* a = 0;
-                scriptSrc = String();
-                scriptSrcCharset = String();
-                if (currToken.attrs && !m_fragment) {
+                m_scriptTagSrcAttrValue = String();
+                m_scriptTagCharsetAttrValue = String();
+                if (m_currentToken.attrs && !m_fragment) {
                     if (m_doc->frame() && m_doc->frame()->script()->isEnabled()) {
-                        if ((a = currToken.attrs->getAttributeItem(srcAttr)))
-                            scriptSrc = m_doc->completeURL(parseURL(a->value())).string();
+                        if ((a = m_currentToken.attrs->getAttributeItem(srcAttr)))
+                            m_scriptTagSrcAttrValue = m_doc->completeURL(parseURL(a->value())).string();
                     }
                 }
@@ -1506 +1483 @@
                         state.setDiscardLF(true); // Discard the first LF after we open a pre.
                 } else if (tagName == scriptTag) {
-                    ASSERT(!scriptNode);
-                    scriptNode = n;
-                    if (n)
-                        scriptSrcCharset = static_cast<HTMLScriptElement*>(n.get())->scriptCharset();
+                    ASSERT(!m_scriptNode);
+                    m_scriptNode = static_pointer_cast<HTMLScriptElement>(n);
+                    if (m_scriptNode)
+                        m_scriptTagCharsetAttrValue = m_scriptNode->scriptCharset();
                     if (beginTag) {
-                        searchStopper = scriptEnd;
-                        searchStopperLen = 8;
+                        m_searchStopper = scriptEnd;
+                        m_searchStopperLength = 8;
                         state.setInScript(true);
                         state = parseSpecial(src, state);
@@ -1521 +1498 @@
                 } else if (tagName == styleTag) {
                     if (beginTag) {
-                        searchStopper = styleEnd;
-                        searchStopperLen = 7;
+                        m_searchStopper = styleEnd;
+                        m_searchStopperLength = 7;
                         state.setInStyle(true);
                         state = parseSpecial(src, state);
@@ -1528 +1505 @@
                 } else if (tagName == textareaTag) {
                     if (beginTag) {
-                        searchStopper = textareaEnd;
-                        searchStopperLen = 10;
+                        m_searchStopper = textareaEnd;
+                        m_searchStopperLength = 10;
                         state.setInTextArea(true);
                         state = parseSpecial(src, state);
@@ -1535 +1512 @@
                 } else if (tagName == titleTag) {
                     if (beginTag) {
-                        searchStopper = titleEnd;
-                        searchStopperLen = 7;
+                        m_searchStopper = titleEnd;
+                        m_searchStopperLength = 7;
                         State savedState = state;
                         SegmentedString savedSrc = src;
@@ -1547 +1524 @@
                             // Let the parser clean up the missing </title> tag.
                             // FIXME: This is incorrect, because src.isEmpty() doesn't mean we're
-                            // at the end of the document unless noMoreData is also true. We need
+                            // at the end of the document unless m_noMoreData is also true. We need
                             // to detect this case elsewhere, and save the state somewhere other
                             // than a local variable.
@@ -1553 +1530 @@
                             src = savedSrc;
                             m_lineNumber = savedLineno;
-                            scriptCodeSize = 0;
+                            m_scriptCodeSize = 0;
                         }
                     }
                 } else if (tagName == xmpTag) {
                     if (beginTag) {
-                        searchStopper = xmpEnd;
-                        searchStopperLen = 5;
+                        m_searchStopper = xmpEnd;
+                        m_searchStopperLength = 5;
                         state.setInXmp(true);
                         state = parseSpecial(src, state);
@@ -1565 +1542 @@
                 } else if (tagName == iframeTag) {
                     if (beginTag) {
-                        searchStopper = iframeEnd;
-                        searchStopperLen = 8;
+                        m_searchStopper = iframeEnd;
+                        m_searchStopperLength = 8;
                         state.setInIFrame(true);
                         state = parseSpecial(src, state);
@@ -1612 +1589 @@
 bool HTMLTokenizer::write(const SegmentedString& str, bool appendData)
 {
-#ifdef TOKEN_DEBUG
-    kdDebug( 6036 ) << this << " Tokenizer::write(\"" << str.toString() << "\"," << appendData << ")" << endl;
-#endif
-
-    if (!buffer)
+    if (!m_buffer)
         return false;
     
@@ -1626 +1599 @@
         source.setExcludeLineNumbers();
 
-    if ((m_executingScript && appendData) || !pendingScripts.isEmpty()) {
+    if ((m_executingScript && appendData) || !m_pendingScripts.isEmpty()) {
         // don't parse; we will do this later
-        if (currentPrependingSrc)
-            currentPrependingSrc->append(source);
+        if (m_currentPrependingSrc)
+            m_currentPrependingSrc->append(source);
         else {
-            pendingSrc.append(source);
+            m_pendingSrc.append(source);
 #if PRELOAD_SCANNER_ENABLED
             if (m_preloadScanner && m_preloadScanner->inProgress() && appendData)
@@ -1645 +1618 @@
 #endif
 
-    if (!src.isEmpty())
-        src.append(source);
+    if (!m_src.isEmpty())
+        m_src.append(source);
     else
         setSrc(source);
@@ -1654 +1627 @@
         return false;
 
-    bool wasInWrite = inWrite;
-    inWrite = true;
+    bool wasInWrite = m_inWrite;
+    m_inWrite = true;
     
 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
@@ -1665 +1638 @@
     double startTime = currentTime();
 
-    Frame *frame = m_doc->frame();
+    Frame* frame = m_doc->frame();
 
     State state = m_state;
 
-    while (!src.isEmpty() && (!frame || !frame->loader()->isScheduledLocationChangePending())) {
+    while (!m_src.isEmpty() && (!frame || !frame->loader()->isScheduledLocationChangePending())) {
         if (!continueProcessing(processedCount, startTime, state))
             break;
@@ -1676 +1649 @@
         checkBuffer();
 
-        UChar cc = *src;
+        UChar cc = *m_src;
 
         bool wasSkipLF = state.skipLF();
@@ -1683 +1656 @@
 
         if (wasSkipLF && (cc == '\n'))
-            src.advance();
+            m_src.advance();
         else if (state.needsSpecialWriteHandling()) {
             // it's important to keep needsSpecialWriteHandling with the flags this block tests
             if (state.hasEntityState())
-                state = parseEntity(src, dest, state, m_cBufferPos, false, state.hasTagState());
+                state = parseEntity(m_src, m_dest, state, m_cBufferPos, false, state.hasTagState());
             else if (state.inPlainText())
-                state = parseText(src, state);
+                state = parseText(m_src, state);
             else if (state.inAnySpecial())
-                state = parseSpecial(src, state);
+                state = parseSpecial(m_src, state);
             else if (state.inComment())
-                state = parseComment(src, state);
+                state = parseComment(m_src, state);
             else if (state.inDoctype())
-                state = parseDoctype(src, state);
+                state = parseDoctype(m_src, state);
             else if (state.inServer())
-                state = parseServer(src, state);
+                state = parseServer(m_src, state);
             else if (state.inProcessingInstruction())
-                state = parseProcessingInstruction(src, state);
+                state = parseProcessingInstruction(m_src, state);
             else if (state.hasTagState())
-                state = parseTag(src, state);
+                state = parseTag(m_src, state);
             else if (state.startTag()) {
                 state.setStartTag(false);
@@ -1718 +1691 @@
                     state.setInProcessingInstruction(true);
                     tquote = NoQuote;
-                    state = parseProcessingInstruction(src, state);
+                    state = parseProcessingInstruction(m_src, state);
                     continue;
 
@@ -1724 +1697 @@
                 }
                 case '%':
-                    if (!brokenServer) {
+                    if (!m_brokenServer) {
                         // <% server stuff, handle as comment %>
                         state.setInServer(true);
                         tquote = NoQuote;
-                        state = parseServer(src, state);
+                        state = parseServer(m_src, state);
                         continue;
                     }
@@ -1738 +1711 @@
                         // Invalid tag
                         // Add as is
-                        *dest = '<';
-                        dest++;
+                        *m_dest = '<';
+                        m_dest++;
                         continue;
                     }
@@ -1749 +1722 @@
                 m_cBufferPos = 0;
                 state.setTagState(TagName);
-                state = parseTag(src, state);
-            }
-        } else if (cc == '&' && !src.escaped()) {
-            src.advancePastNonNewline();
-            state = parseEntity(src, dest, state, m_cBufferPos, true, state.hasTagState());
-        } else if (cc == '<' && !src.escaped()) {
-            tagStartLineno = m_lineNumber;
-            src.advancePastNonNewline();
+                state = parseTag(m_src, state);
+            }
+        } else if (cc == '&' && !m_src.escaped()) {
+            m_src.advancePastNonNewline();
+            state = parseEntity(m_src, m_dest, state, m_cBufferPos, true, state.hasTagState());
+        } else if (cc == '<' && !m_src.escaped()) {
+            m_currentTagStartLineNumber = m_lineNumber;
+            m_src.advancePastNonNewline();
             state.setStartTag(true);
             state.setDiscardLF(false);
@@ -1765 +1738 @@
             else {
                 // Process this LF
-                *dest++ = '\n';
-                if (cc == '\r' && !src.excludeLineNumbers())
+                *m_dest++ = '\n';
+                if (cc == '\r' && !m_src.excludeLineNumbers())
                     m_lineNumber++;
             }
@@ -1773 +1746 @@
             if (cc == '\r')
                 state.setSkipLF(true);
-            src.advance(m_lineNumber);
+            m_src.advance(m_lineNumber);
         } else {
             state.setDiscardLF(false);
-            *dest++ = cc;
-            src.advancePastNonNewline();
+            *m_dest++ = cc;
+            m_src.advancePastNonNewline();
         }
     }
@@ -1786 +1759 @@
 #endif
     
-    inWrite = wasInWrite;
+    m_inWrite = wasInWrite;
 
     m_state = state;
 
-    if (noMoreData && !inWrite && !state.loadingExtScript() && !m_executingScript && !m_timer.isActive()) {
+    if (m_noMoreData && !m_inWrite && !state.loadingExtScript() && !m_executingScript && !m_timer.isActive()) {
         end(); // this actually causes us to be deleted
         return true;
@@ -1810 +1783 @@
 bool HTMLTokenizer::processingData() const
 {
-    return m_timer.isActive() || inWrite;
+    return m_timer.isActive() || m_inWrite;
 }
 
@@ -1836 +1809 @@
     m_timer.stop(); // Only helps if assertion above fires, but do it anyway.
 
-    if (buffer) {
+    if (m_buffer) {
         // parseTag is using the buffer for different matters
         if (!m_state.hasTagState())
             processToken();
 
-        fastFree(scriptCode);
-        scriptCode = 0;
-        scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
-
-        fastFree(buffer);
-        buffer = 0;
+        fastFree(m_scriptCode);
+        m_scriptCode = 0;
+        m_scriptCodeSize = m_scriptCodeCapacity = m_scriptCodeResync = 0;
+
+        fastFree(m_buffer);
+        m_buffer = 0;
     }
 
     if (!inViewSourceMode())
-        parser->finished();
+        m_parser->finished();
     else
         m_doc->finishedParsing();
@@ -1858 +1831 @@
 {
     // do this as long as we don't find matching comment ends
-    while ((m_state.inComment() || m_state.inServer()) && scriptCode && scriptCodeSize) {
+    while ((m_state.inComment() || m_state.inServer()) && m_scriptCode && m_scriptCodeSize) {
         // we've found an unmatched comment start
         if (m_state.inComment())
-            brokenComments = true;
+            m_brokenComments = true;
         else
-            brokenServer = true;
+            m_brokenServer = true;
         checkScriptBuffer();
-        scriptCode[scriptCodeSize] = 0;
-        scriptCode[scriptCodeSize + 1] = 0;
+        m_scriptCode[m_scriptCodeSize] = 0;
+        m_scriptCode[m_scriptCodeSize + 1] = 0;
         int pos;
         String food;
         if (m_state.inScript() || m_state.inStyle() || m_state.inTextArea())
-            food = String(scriptCode, scriptCodeSize);
+            food = String(m_scriptCode, m_scriptCodeSize);
         else if (m_state.inServer()) {
             food = "<";
-            food.append(scriptCode, scriptCodeSize);
+            food.append(m_scriptCode, m_scriptCodeSize);
         } else {
-            pos = find(scriptCode, scriptCodeSize, '>');
-            food = String(scriptCode + pos + 1, scriptCodeSize - pos - 1);
-        }
-        fastFree(scriptCode);
-        scriptCode = 0;
-        scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
+            pos = find(m_scriptCode, m_scriptCodeSize, '>');
+            food = String(m_scriptCode + pos + 1, m_scriptCodeSize - pos - 1);
+        }
+        fastFree(m_scriptCode);
+        m_scriptCode = 0;
+        m_scriptCodeSize = m_scriptCodeCapacity = m_scriptCodeResync = 0;
         m_state.setInComment(false);
         m_state.setInServer(false);
@@ -1888 +1861 @@
     // this indicates we will not receive any more data... but if we are waiting on
     // an external script to load, we can't finish parsing until that is done
-    noMoreData = true;
-    if (!inWrite && !m_state.loadingExtScript() && !m_executingScript && !m_timer.isActive())
+    m_noMoreData = true;
+    if (!m_inWrite && !m_state.loadingExtScript() && !m_executingScript && !m_timer.isActive())
         end(); // this actually causes us to be deleted
 }
@@ -1895 +1868 @@
 PassRefPtr<Node> HTMLTokenizer::processToken()
 {
-    ScriptController* jsProxy = (!m_fragment && m_doc->frame()) ? m_doc->frame()->script() : 0;
-    if (jsProxy && m_doc->frame()->script()->isEnabled())
-        jsProxy->setEventHandlerLineno(tagStartLineno + 1); // Script line numbers are 1 based.
-    if (dest > buffer) {
-        currToken.text = StringImpl::createStrippingNullCharacters(buffer, dest - buffer);
-        if (currToken.tagName != commentAtom)
-            currToken.tagName = textAtom;
-    } else if (currToken.tagName == nullAtom) {
-        currToken.reset();
-        if (jsProxy)
-            jsProxy->setEventHandlerLineno(m_lineNumber + 1); // Script line numbers are 1 based.
+    ScriptController* scriptController = (!m_fragment && m_doc->frame()) ? m_doc->frame()->script() : 0;
+    if (scriptController && scriptController->isEnabled())
+        // FIXME: Why isn't this m_currentScriptTagStartLineNumber?  I suspect this is wrong.
+        scriptController->setEventHandlerLineno(m_currentTagStartLineNumber + 1); // Script line numbers are 1 based.
+    if (m_dest > m_buffer) {
+        m_currentToken.text = StringImpl::createStrippingNullCharacters(m_buffer, m_dest - m_buffer);
+        if (m_currentToken.tagName != commentAtom)
+            m_currentToken.tagName = textAtom;
+    } else if (m_currentToken.tagName == nullAtom) {
+        m_currentToken.reset();
+        if (scriptController)
+            scriptController->setEventHandlerLineno(m_lineNumber + 1); // Script line numbers are 1 based.
         return 0;
     }
 
-    dest = buffer;
+    m_dest = m_buffer;
 
     RefPtr<Node> n;
     
     if (!m_parserStopped) {
-        if (NamedMappedAttrMap* map = currToken.attrs.get())
+        if (NamedMappedAttrMap* map = m_currentToken.attrs.get())
             map->shrinkToLength();
         if (inViewSourceMode())
-            static_cast<HTMLViewSourceDocument*>(m_doc)->addViewSourceToken(&currToken);
+            static_cast<HTMLViewSourceDocument*>(m_doc)->addViewSourceToken(&m_currentToken);
         else
             // pass the token over to the parser, the parser DOES NOT delete the token
-            n = parser->parseToken(&currToken);
-    }
-    currToken.reset();
-    if (jsProxy)
-        jsProxy->setEventHandlerLineno(0);
+            n = m_parser->parseToken(&m_currentToken);
+    }
+    m_currentToken.reset();
+    if (scriptController)
+        scriptController->setEventHandlerLineno(0);
 
     return n.release();
@@ -1934 +1908 @@
         static_cast<HTMLViewSourceDocument*>(m_doc)->addViewSourceDoctypeToken(&m_doctypeToken);
     else
-        parser->parseDoctypeToken(&m_doctypeToken);
+        m_parser->parseDoctypeToken(&m_doctypeToken);
 }
 
 HTMLTokenizer::~HTMLTokenizer()
 {
-    ASSERT(!inWrite);
+    ASSERT(!m_inWrite);
     reset();
-    delete parser;
 }
 
@@ -1947 +1920 @@
 void HTMLTokenizer::enlargeBuffer(int len)
 {
-    int newSize = max(size * 2, size + len);
-    int oldOffset = dest - buffer;
-    buffer = static_cast<UChar*>(fastRealloc(buffer, newSize * sizeof(UChar)));
-    dest = buffer + oldOffset;
-    size = newSize;
+    int newSize = max(m_bufferSize * 2, m_bufferSize + len);
+    int oldOffset = m_dest - m_buffer;
+    m_buffer = static_cast<UChar*>(fastRealloc(m_buffer, newSize * sizeof(UChar)));
+    m_dest = m_buffer + oldOffset;
+    m_bufferSize = newSize;
 }
 
 void HTMLTokenizer::enlargeScriptBuffer(int len)
 {
-    int newSize = max(scriptCodeMaxSize * 2, scriptCodeMaxSize + len);
-    scriptCode = static_cast<UChar*>(fastRealloc(scriptCode, newSize * sizeof(UChar)));
-    scriptCodeMaxSize = newSize;
+    int newSize = max(m_scriptCodeCapacity * 2, m_scriptCodeCapacity + len);
+    m_scriptCode = static_cast<UChar*>(fastRealloc(m_scriptCode, newSize * sizeof(UChar)));
+    m_scriptCodeCapacity = newSize;
 }
     
@@ -1976 +1949 @@
 #endif
 
-    ASSERT(!pendingScripts.isEmpty());
+    ASSERT(!m_pendingScripts.isEmpty());
 
     // Make external scripts wait for external stylesheets.
@@ -1985 +1958 @@
 
     bool finished = false;
-    while (!finished && pendingScripts.first()->isLoaded()) {
-        CachedScript *cs = pendingScripts.first().get();
-        pendingScripts.removeFirst();
+    while (!finished && m_pendingScripts.first()->isLoaded()) {
+        CachedScript* cs = m_pendingScripts.first().get();
+        m_pendingScripts.removeFirst();
         ASSERT(cache()->disabled() || cs->accessCount() > 0);
 
@@ -1998 +1971 @@
         bool errorOccurred = cs->errorOccurred();
         cs->removeClient(this);
-        RefPtr<Node> n = scriptNode.release();
+        RefPtr<Node> n = m_scriptNode.release();
 
 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
@@ -2013 +1986 @@
         }
 
-        // The state of pendingScripts.isEmpty() can change inside the scriptExecution()
+        // The state of m_pendingScripts.isEmpty() can change inside the scriptExecution()
         // call above, so test afterwards.
-        finished = pendingScripts.isEmpty();
+        finished = m_pendingScripts.isEmpty();
         if (finished) {
             m_state.setLoadingExtScript(false);
@@ -2026 +1999 @@
         // 'm_requestingScript' is true when we are called synchronously from
         // scriptHandler(). In that case scriptHandler() will take care
-        // of pendingSrc.
+        // of m_pendingSrc.
         if (!m_requestingScript) {
-            SegmentedString rest = pendingSrc;
-            pendingSrc.clear();
+            SegmentedString rest = m_pendingSrc;
+            m_pendingSrc.clear();
             write(rest, false);
             // we might be deleted at this point, do not access any members.
@@ -2041 +2014 @@
 }
 
-void HTMLTokenizer::setSrc(const SegmentedString &source)
-{
-    src = source;
+void HTMLTokenizer::setSrc(const SegmentedString& source)
+{
+    m_src = source;
 }
 

trunk/WebCore/html/HTMLTokenizer.h

@@ -41 +41 @@
 class Document;
 class HTMLDocument;
+class HTMLScriptElement;
 class HTMLViewSourceDocument;
 class FrameView;
@@ -53 +54 @@
  * text contains the text.
  */
-class Token {
-public:
-    Token() : beginTag(true), flat(false), brokenXMLStyle(false), m_sourceInfo(0) { }
+struct Token {
+    Token()
+        : beginTag(true)
+        , selfClosingTag(false)
+        , brokenXMLStyle(false)
+        , m_sourceInfo(0)
+    { }
     ~Token() { }
 
@@ -69 +74 @@
         tagName = nullAtom;
         beginTag = true;
-        flat = false;
+        selfClosingTag = false;
         brokenXMLStyle = false;
         if (m_sourceInfo)
@@ -81 +86 @@
     AtomicString tagName;
     bool beginTag;
-    bool flat;
+    bool selfClosingTag;
     bool brokenXMLStyle;
     OwnPtr<Vector<UChar> > m_sourceInfo;
@@ -144 +149 @@
     virtual int columnNumber() const { return 1; }
 
-    bool processingContentWrittenByScript() const { return src.excludeLineNumbers(); }
+    bool processingContentWrittenByScript() const { return m_src.excludeLineNumbers(); }
     
     virtual void executeScriptsWaitingForStylesheets();
     
     virtual bool isHTMLTokenizer() const { return true; }
-    HTMLParser* htmlParser() const { return parser; }
+    HTMLParser* htmlParser() const { return m_parser.get(); }
 
 private:
@@ -170 +175 @@
     State parseSpecial(SegmentedString&, State);
     State parseTag(SegmentedString&, State);
-    State parseEntity(SegmentedString&, UChar*& dest, State, unsigned& _cBufferPos, bool start, bool parsingTag);
+    State parseEntity(SegmentedString&, UChar*& dest, State, unsigned& cBufferPos, bool start, bool parsingTag);
     State parseProcessingInstruction(SegmentedString&, State);
     State scriptHandler(State);
@@ -180 +185 @@
     inline void checkBuffer(int len = 10)
     {
-        if ((dest - buffer) > size - len)
+        if ((m_dest - m_buffer) > m_bufferSize - len)
             enlargeBuffer(len);
     }
@@ -186 +191 @@
     inline void checkScriptBuffer(int len = 10)
     {
-        if (scriptCodeSize + len >= scriptCodeMaxSize)
+        if (m_scriptCodeSize + len >= m_scriptCodeCapacity)
             enlargeScriptBuffer(len);
     }
@@ -198 +203 @@
 
     // from CachedResourceClient
-    void notifyFinished(CachedResource *finishedObj);
+    void notifyFinished(CachedResource*);
 
     // Internal buffers
     ///////////////////
-    UChar* buffer;
-    UChar* dest;
-
-    Token currToken;
-
-    // the size of buffer
-    int size;
+    UChar* m_buffer;
+    int m_bufferSize;
+    UChar* m_dest;
+
+    Token m_currentToken;
 
     // Tokenizer flags
@@ -335 +338 @@
     int m_doctypeSecondarySearchCount;
 
-    bool brokenServer;
+    bool m_brokenServer;
 
     // Name of an attribute that we just scanned.
-    AtomicString attrName;
+    AtomicString m_attrName;
 
     // Used to store the code of a scripting sequence
-    UChar* scriptCode;
+    UChar* m_scriptCode;
     // Size of the script sequenze stored in @ref #scriptCode
-    int scriptCodeSize;
+    int m_scriptCodeSize;
     // Maximal size that can be stored in @ref #scriptCode
-    int scriptCodeMaxSize;
+    int m_scriptCodeCapacity;
     // resync point of script code size
-    int scriptCodeResync;
+    int m_scriptCodeResync;
 
     // Stores characters if we are scanning for a string like "</script>"
@@ -355 +358 @@
     int searchCount;
     // the stopper string
-    const char* searchStopper;
-    // the stopper len
-    int searchStopperLen;
+    const char* m_searchStopper;
+    int m_searchStopperLength;
     
     // if no more data is coming, just parse what we have (including ext scripts that
     // may be still downloading) and finish
-    bool noMoreData;
+    bool m_noMoreData;
     // URL to get source code of script from
-    String scriptSrc;
-    String scriptSrcCharset;
+    String m_scriptTagSrcAttrValue;
+    String m_scriptTagCharsetAttrValue;
     // the HTML code we will parse after the external script we are waiting for has loaded
-    SegmentedString pendingSrc;
+    SegmentedString m_pendingSrc;
 
     // the HTML code we will parse after this particular script has
     // loaded, but before all pending HTML
-    SegmentedString *currentPrependingSrc;
+    SegmentedString* m_currentPrependingSrc;
 
     // true if we are executing a script while parsing a document. This causes the parsing of
     // the output of the script to be postponed until after the script has finished executing
     int m_executingScript;
-    Deque<CachedResourceHandle<CachedScript> > pendingScripts;
-    RefPtr<Node> scriptNode;
+    Deque<CachedResourceHandle<CachedScript> > m_pendingScripts;
+    RefPtr<HTMLScriptElement> m_scriptNode;
 
     bool m_requestingScript;
@@ -383 +385 @@
     // if we found one broken comment, there are most likely others as well
     // store a flag to get rid of the O(n^2) behaviour in such a case.
-    bool brokenComments;
+    bool m_brokenComments;
     // current line number
     int m_lineNumber;
-    // line number at which the current <script> started
-    int scriptStartLineno;
-    int tagStartLineno;
+    int m_currentScriptTagStartLineNumber;
+    int m_currentTagStartLineNumber;
 
     double m_tokenizerTimeDelay;
@@ -400 +401 @@
 // we'll just make it large enough to handle all imaginable cases.
 #define CBUFLEN 1024
-    UChar cBuffer[CBUFLEN + 2];
+    UChar m_cBuffer[CBUFLEN + 2];
     unsigned int m_cBufferPos;
 
-    SegmentedString src;
+    SegmentedString m_src;
     Document* m_doc;
-    HTMLParser* parser;
-    bool inWrite;
+    OwnPtr<HTMLParser> m_parser;
+    bool m_inWrite;
     bool m_fragment;
 

trunk/WebCore/html/HTMLViewSourceDocument.h

@@ -31 +31 @@
 
 class DoctypeToken;
-class Token;
+struct Token;
 
 class HTMLViewSourceDocument : public HTMLDocument {

trunk/WebCore/rendering/RenderBlock.cpp

@@ -2485 +2485 @@
 
     if (applyTextIndent && m_firstLine && style()->direction() == LTR) {
-        int cw=0;
+        int cw = 0;
         if (style()->textIndent().isPercent())
             cw = containingBlock()->availableWidth();
@@ -2491 +2491 @@
     }
 
-    //kdDebug( 6040 ) << "leftOffset(" << y << ") = " << left << endl;
     return left;
 }
@@ -2523 +2522 @@
     
     if (applyTextIndent && m_firstLine && style()->direction() == RTL) {
-        int cw=0;
+        int cw = 0;
         if (style()->textIndent().isPercent())
             cw = containingBlock()->availableWidth();
@@ -2529 +2528 @@
     }
     
-    //kdDebug( 6040 ) << "rightOffset(" << y << ") = " << right << endl;
     return right;
 }
@@ -2536 +2534 @@
 RenderBlock::lineWidth(int y) const
 {
-    //kdDebug( 6040 ) << "lineWidth(" << y << ")=" << rightOffset(y) - leftOffset(y) << endl;
     int result = rightOffset(y) - leftOffset(y);
     return (result < 0) ? 0 : result;

trunk/WebCore/xml/XSLTProcessor.cpp

@@ -37 +37 @@
 #include "FrameView.h"
 #include "HTMLDocument.h"
-#include "HTMLTokenizer.h"
+#include "HTMLTokenizer.h" // for parseHTMLDocumentFragment
 #include "Page.h"
 #include "ResourceError.h"