Changeset 21704 in webkit


Ignore:
Timestamp:
May 24, 2007 1:56:35 AM (17 years ago)
Author:
hyatt
Message:

Rework how HTML handles line numbering so that it is not fooled by
\r without a following \n and so that document.write doesn't lead
to line numbering confusion.

Reviewed by aroben

  • html/HTMLParser.cpp: (WebCore::HTMLParser::reportErrorToConsole):
  • html/HTMLTokenizer.cpp: (WebCore::HTMLTokenizer::processListing): (WebCore::HTMLTokenizer::parseSpecial): (WebCore::HTMLTokenizer::parseComment): (WebCore::HTMLTokenizer::parseServer): (WebCore::HTMLTokenizer::parseProcessingInstruction): (WebCore::HTMLTokenizer::parseText): (WebCore::HTMLTokenizer::parseEntity): (WebCore::HTMLTokenizer::parseTag): (WebCore::HTMLTokenizer::write): (WebCore::HTMLTokenizer::processToken): (WebCore::HTMLTokenizer::setSrc):
  • html/HTMLTokenizer.h: (WebCore::HTMLTokenizer::lineNumberPtr):
  • html/HTMLViewSourceDocument.cpp: (WebCore::HTMLViewSourceDocument::addLine):
  • loader/TextDocument.cpp: (WebCore::TextTokenizer::write):
  • platform/SegmentedString.cpp: (WebCore::SegmentedString::SegmentedString): (WebCore::SegmentedString::operator=): (WebCore::SegmentedString::clear):
  • platform/SegmentedString.h: (WebCore::SegmentedString::SegmentedString): (WebCore::SegmentedString::advance): (WebCore::SegmentedString::escaped):
Location:
trunk/WebCore
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r21698 r21704  
     12007-05-24  David Hyatt  <hyatt@apple.com>
     2
     3        Rework how HTML handles line numbering so that it is not fooled by
     4        \r without a following \n and so that document.write doesn't lead
     5        to line numbering confusion.
     6
     7        Reviewed by aroben
     8
     9        * html/HTMLParser.cpp:
     10        (WebCore::HTMLParser::reportErrorToConsole):
     11        * html/HTMLTokenizer.cpp:
     12        (WebCore::HTMLTokenizer::processListing):
     13        (WebCore::HTMLTokenizer::parseSpecial):
     14        (WebCore::HTMLTokenizer::parseComment):
     15        (WebCore::HTMLTokenizer::parseServer):
     16        (WebCore::HTMLTokenizer::parseProcessingInstruction):
     17        (WebCore::HTMLTokenizer::parseText):
     18        (WebCore::HTMLTokenizer::parseEntity):
     19        (WebCore::HTMLTokenizer::parseTag):
     20        (WebCore::HTMLTokenizer::write):
     21        (WebCore::HTMLTokenizer::processToken):
     22        (WebCore::HTMLTokenizer::setSrc):
     23        * html/HTMLTokenizer.h:
     24        (WebCore::HTMLTokenizer::lineNumberPtr):
     25        * html/HTMLViewSourceDocument.cpp:
     26        (WebCore::HTMLViewSourceDocument::addLine):
     27        * loader/TextDocument.cpp:
     28        (WebCore::TextTokenizer::write):
     29        * platform/SegmentedString.cpp:
     30        (WebCore::SegmentedString::SegmentedString):
     31        (WebCore::SegmentedString::operator=):
     32        (WebCore::SegmentedString::clear):
     33        * platform/SegmentedString.h:
     34        (WebCore::SegmentedString::SegmentedString):
     35        (WebCore::SegmentedString::advance):
     36        (WebCore::SegmentedString::escaped):
     37
    1382007-05-23  David Hyatt  <hyatt@apple.com>
    239

  • trunk/WebCore/html/HTMLParser.cpp

    r21522 r21704  
    14181418
    14191419    HTMLTokenizer* htmlTokenizer = static_cast<HTMLTokenizer*>(document->tokenizer());
    1420     int lineNumber = htmlTokenizer->tagStartLineNumber() + 1;
     1420    int lineNumber = htmlTokenizer->lineNumber() + 1;
    14211421
    14221422    AtomicString tag1;

  • trunk/WebCore/html/HTMLTokenizer.cpp

    r21680 r21704  
    257257            state.setSkipLF(false);
    258258            if (*list == '\n') {
    259                 ++list;
     259                list.advance(0);
    260260                continue;
    261261            }
    … …  
    275275                state.setSkipLF(true);
    276276
    277             ++list;
     277            list.advance(0);
    278278        } else {
    279279            state.setDiscardLF(false);
    280280            *dest++ = *list;
    281             ++list;
     281            list.advance(0);
    282282        }
    283283    }
    … …  
    292292    ASSERT(state.inXmp() + state.inTextArea() + state.inTitle() + state.inStyle() + state.inScript() == 1 );
    293293    if (state.inScript())
    294         scriptStartLineno = lineno + src.lineCount();
     294        scriptStartLineno = lineno;
    295295
    296296    if (state.inComment())
    … …  
    307307        }
    308308        if (scriptCodeResync && !tquote && ch == '>') {
    309             ++src;
     309            src.advance(lineNumberPtr());
    310310            scriptCodeSize = scriptCodeResync-1;
    311311            scriptCodeResync = 0;
    … …  
    359359        if (!scriptCodeResync && (state.inTextArea() || state.inTitle()) && !src.escaped() && ch == '&') {
    360360            UChar* scriptCodeDest = scriptCode+scriptCodeSize;
    361             ++src;
     361            src.advance(lineNumberPtr());
    362362            state = parseEntity(src, scriptCodeDest, state, m_cBufferPos, true, false);
    363363            scriptCodeSize = scriptCodeDest-scriptCode;
    364364        } else {
    365365            scriptCode[scriptCodeSize++] = *src;
    366             ++src;
     366            src.advance(lineNumberPtr());
    367367        }
    368368    }
    … …  
    573573            }
    574574            if (handleBrokenComments || endCharsCount > 1) {
    575                 ++src;
     575                src.advance(lineNumberPtr());
    576576                if (!(state.inTitle() || state.inScript() || state.inXmp() || state.inTextArea() || state.inStyle())) {
    577577                    checkScriptBuffer();
    … …  
    591591            }
    592592        }
    593         ++src;
     593        src.advance(lineNumberPtr());
    594594    }
    595595
    … …  
    604604        if (*src == '>' &&
    605605            scriptCodeSize > 1 && scriptCode[scriptCodeSize-2] == '%') {
    606             ++src;
     606            src.advance(lineNumberPtr());
    607607            state.setInServer(false);
    608608            scriptCodeSize = 0;
    609609            return state; // Finished parsing server include
    610610        }
    611         ++src;
     611        src.advance(lineNumberPtr());
    612612    }
    613613    return state;
    … …  
    629629            // We got a '?>' sequence
    630630            state.setInProcessingInstruction(false);
    631             ++src;
     631            src.advance(lineNumberPtr());
    632632            state.setDiscardLF(true);
    633633            return state; // Finished parsing comment!
    634634        }
    635         ++src;
     635        src.advance(lineNumberPtr());
    636636        oldchar = chbegin;
    637637    }
    … …  
    648648            state.setSkipLF(false);
    649649            if (cc == '\n') {
    650                 ++src;
     650                src.advance(lineNumberPtr());
    651651                continue;
    652652            }
    … …  
    661661        } else
    662662            *dest++ = cc;
    663         ++src;
     663        src.advance(lineNumberPtr());
    664664    }
    665665
    … …  
    688688            if(cc == '#') {
    689689                cBuffer[cBufferPos++] = cc;
    690                 ++src;
     690                src.advance(lineNumberPtr());
    691691                state.setEntityState(NumericSearch);
    692692            }
    … …  
    699699            if (cc == 'x' || cc == 'X') {
    700700                cBuffer[cBufferPos++] = cc;
    701                 ++src;
     701                src.advance(lineNumberPtr());
    702702                state.setEntityState(Hexadecimal);
    703703            } else if (cc >= '0' && cc <= '9')
    … …  
    722722                EntityUnicodeValue = EntityUnicodeValue * 16 + digit;
    723723                cBuffer[cBufferPos++] = cc;
    724                 ++src;
     724                src.advance(lineNumberPtr());
    725725            }
    726726            if (cBufferPos == 10) 
    … …  
    741741                EntityUnicodeValue = EntityUnicodeValue * 10 + (cc - '0');
    742742                cBuffer[cBufferPos++] = cc;
    743                 ++src;
     743                src.advance(lineNumberPtr());
    744744            }
    745745            if (cBufferPos == 9) 
    … …  
    759759
    760760                cBuffer[cBufferPos++] = cc;
    761                 ++src;
     761                src.advance(lineNumberPtr());
    762762            }
    763763            if (cBufferPos == 9)
    … …  
    782782                if (!inViewSourceMode()) {
    783783                    if (*src == ';')
    784                         ++src;
     784                        src.advance(lineNumberPtr());
    785785                    if (EntityUnicodeValue <= 0xFFFF) {
    786786                        checkBuffer();
    … …  
    801801                    if (*src == ';') {
    802802                        *dest++ = ';';
    803                         ++src;
     803                        src.advance(lineNumberPtr());
    804804                    }
    805805                }
    … …  
    827827    unsigned cBufferPos = m_cBufferPos;
    828828
    829     while (!src.isEmpty())
    830     {
     829    int* lineNoPtr = lineNumberPtr();
     830
     831    while (!src.isEmpty()) {
    831832        checkBuffer();
    832833        switch(state.tagState()) {
    … …  
    852853#endif
    853854                        // Found '<!--' sequence
    854                         ++src;
     855                        src.advance(lineNoPtr);
    855856                        dest = buffer; // ignore the previous part of this tag
    856857                        state.setInComment(true);
    … …  
    862863                        if (!src.isEmpty() && *src == '>' && m_doc->inCompatMode()) {
    863864                          state.setInComment(false);
    864                           ++src;
     865                          src.advance(lineNoPtr);
    865866                          if (!src.isEmpty())
    866867                              // cuts off high bits, which is okay
    … …  
    875876                    // cuts off high bits, which is okay
    876877                    cBuffer[cBufferPos++] = *src;
    877                     ++src;
     878                    src.advance(lineNoPtr);
    878879                    break;
    879880                }
    … …  
    896897                else
    897898                    cBuffer[cBufferPos++] = curchar;
    898                 ++src;
     899                src.advance(lineNoPtr);
    899900            }
    900901
    … …  
    950951                if (inViewSourceMode())
    951952                    currToken.addViewSourceChar(curchar);
    952                 ++src;
     953                src.advance(lineNoPtr);
    953954            }
    954955            break;
    … …  
    980981                    cBuffer[cBufferPos++] = curchar;
    981982                   
    982                 ++src;
     983                src.advance(lineNoPtr);
    983984            }
    984985            if ( cBufferPos == CBUFLEN ) {
    … …  
    10081009                        if (inViewSourceMode())
    10091010                            currToken.addViewSourceChar(curchar);
    1010                         ++src;
     1011                        src.advance(lineNoPtr);
    10111012                    }
    10121013                    else {
    … …  
    10251026                    currToken.flat = true;
    10261027                   
    1027                 ++src;
     1028                src.advance(lineNoPtr);
    10281029            }
    10291030            break;
    … …  
    10371038                        if (inViewSourceMode())
    10381039                            currToken.addViewSourceChar(curchar);
    1039                         ++src;
     1040                        src.advance(lineNoPtr);
    10401041                    } else
    10411042                        state.setTagState(Value);
    … …  
    10451046                if (inViewSourceMode())
    10461047                    currToken.addViewSourceChar(curchar);
    1047                 ++src;
     1048                src.advance(lineNoPtr);
    10481049            }
    10491050            break;
    … …  
    10811082                    if ( curchar == '&' )
    10821083                    {
    1083                         ++src;
     1084                        src.advance(lineNoPtr);
    10841085                        state = parseEntity(src, dest, state, cBufferPos, true, true);
    10851086                        break;
    … …  
    11041105                        if (inViewSourceMode())
    11051106                            currToken.addViewSourceChar(curchar);
    1106                         ++src;
     1107                        src.advance(lineNoPtr);
    11071108                        break;
    11081109                    }
    11091110                }
    11101111                *dest++ = *src;
    1111                 ++src;
     1112                src.advance(lineNoPtr);
    11121113            }
    11131114            break;
    … …  
    11231124                    if ( curchar == '&' )
    11241125                    {
    1125                         ++src;
     1126                        src.advance(lineNoPtr);
    11261127                        state = parseEntity(src, dest, state, cBufferPos, true, true);
    11271128                        break;
    … …  
    11421143
    11431144                *dest++ = *src;
    1144                 ++src;
     1145                src.advance(lineNoPtr);
    11451146            }
    11461147            break;
    … …  
    11591160                if (inViewSourceMode())
    11601161                    currToken.addViewSourceChar(*src);
    1161                 ++src;
     1162                src.advance(lineNoPtr);
    11621163            }
    11631164            if (src.isEmpty()) break;
    … …  
    11681169
    11691170            if (*src != '<')
    1170                 ++src;
     1171                src.advance(lineNoPtr);
    11711172
    11721173            if (currToken.tagName == nullAtom) { //stop if tag is unknown
    … …  
    13461347    State state = m_state;
    13471348
     1349    int* lineNoPtr = lineNumberPtr();
     1350
    13481351    while (!src.isEmpty() && (!frame || !frame->loader()->isScheduledLocationChangePending())) {
    13491352        if (!continueProcessing(processedCount, startTime, state))
    … …  
    13601363
    13611364        if (wasSkipLF && (cc == '\n'))
    1362             ++src;
     1365            src.advance(0);
    13631366        else if (state.needsSpecialWriteHandling()) {
    13641367            // it's important to keep needsSpecialWriteHandling with the flags this block tests
    … …  
    14271430            }
    14281431        } else if (cc == '&' && !src.escaped()) {
    1429             ++src;
     1432            src.advance(lineNoPtr);
    14301433            state = parseEntity(src, dest, state, m_cBufferPos, true, state.hasTagState());
    14311434        } else if (cc == '<' && !src.escaped()) {
    1432             tagStartLineno = lineno+src.lineCount();
    1433             ++src;
     1435            tagStartLineno = lineno;
     1436            src.advance(lineNoPtr);
    14341437            state.setStartTag(true);
    14351438        } else if (cc == '\n' || cc == '\r') {
    … …  
    14371440                // Ignore this LF
    14381441                state.setDiscardLF(false); // We have discarded 1 LF
    1439             else
     1442            else {
    14401443                // Process this LF
    14411444                *dest++ = '\n';
    1442            
     1445                if (cc == '\r')
     1446                    lineno++;
     1447            }
     1448
    14431449            /* Check for MS-DOS CRLF sequence */
    14441450            if (cc == '\r')
    14451451                state.setSkipLF(true);
    1446             ++src;
     1452            src.advance(lineNoPtr);
    14471453        } else {
    14481454            state.setDiscardLF(false);
    14491455            *dest++ = cc;
    1450             ++src;
     1456            src.advance(lineNoPtr);
    14511457        }
    14521458    }
    … …  
    15891595        currToken.reset();
    15901596        if (jsProxy)
    1591             jsProxy->setEventHandlerLineno(lineno+src.lineCount());
     1597            jsProxy->setEventHandlerLineno(lineno);
    15921598        return 0;
    15931599    }
    … …  
    17311737void HTMLTokenizer::setSrc(const SegmentedString &source)
    17321738{
    1733     lineno += src.lineCount();
    17341739    src = source;
    1735     src.resetLineCount();
    17361740}
    17371741

  • trunk/WebCore/html/HTMLTokenizer.h

    r21526 r21704  
    102102    virtual int columnNumber() const { return 1; }
    103103
    104     int tagStartLineNumber() const { return tagStartLineno; }
     104    int* lineNumberPtr() { return m_executingScript ? 0 : &lineno; }
    105105
    106106private:

  • trunk/WebCore/html/HTMLViewSourceDocument.cpp

    r21630 r21704  
    227227    m_current = m_td = td;
    228228
     229#ifdef DEBUG_LINE_NUMBERS
     230    Text* lineNumberText = new Text(this, String::number(tokenizer()->lineNumber() + 1) + " ");
     231    td->addChild(lineNumberText);
     232    lineNumberText->attach();
     233#endif
     234
    229235    // Open up the needed spans.
    230236    if (!className.isEmpty()) {

  • trunk/WebCore/loader/TextDocument.cpp

    r21599 r21704  
    8888        }
    8989       
    90         ++str;
     90        str.advance(0);
    9191       
    9292        // Maybe enlarge the buffer

  • trunk/WebCore/platform/SegmentedString.cpp

    r20495 r21704  
    2727SegmentedString::SegmentedString(const SegmentedString &other) :
    2828    m_pushedChar1(other.m_pushedChar1), m_pushedChar2(other.m_pushedChar2), m_currentString(other.m_currentString),
    29     m_substrings(other.m_substrings), m_lines(other.m_lines), m_composite(other.m_composite)
     29    m_substrings(other.m_substrings), m_composite(other.m_composite)
    3030{
    3131    if (other.m_currentChar == &other.m_pushedChar1)
    … …  
    4343    m_currentString = other.m_currentString;
    4444    m_substrings = other.m_substrings;
    45     m_lines = other.m_lines;
    4645    m_composite = other.m_composite;
    4746    if (other.m_currentChar == &other.m_pushedChar1)
    … …  
    7877    m_currentString.clear();
    7978    m_substrings.clear();
    80     m_lines = 0;
    8179    m_composite = false;
    8280}

  • trunk/WebCore/platform/SegmentedString.h

    r20496 r21704  
    6262public:
    6363    SegmentedString()
    64         : m_pushedChar1(0), m_pushedChar2(0), m_currentChar(0)
    65         , m_lines(0), m_composite(false) {}
     64        : m_pushedChar1(0), m_pushedChar2(0), m_currentChar(0), m_composite(false) {}
    6665    SegmentedString(const UChar* str, int length) : m_pushedChar1(0), m_pushedChar2(0)
    67         , m_currentString(str, length), m_currentChar(m_currentString.m_current)
    68         , m_lines(0), m_composite(false) {}
     66        , m_currentString(str, length), m_currentChar(m_currentString.m_current), m_composite(false) {}
    6967    SegmentedString(const String& str)
    7068        : m_pushedChar1(0), m_pushedChar2(0), m_currentString(str)
    71         , m_currentChar(m_currentString.m_current)
    72         , m_lines(0), m_composite(false) {}
     69        , m_currentChar(m_currentString.m_current), m_composite(false) {}
    7370    SegmentedString(const SegmentedString&);
    7471
    … …  
    9390    unsigned length() const;
    9491
    95     void advance() {
     92    void advance(int* lineNumber = 0) {
    9693        if (m_pushedChar1) {
    9794            m_pushedChar1 = m_pushedChar2;
    9895            m_pushedChar2 = 0;
    9996        } else if (m_currentString.m_current) {
    100             m_lines += *m_currentString.m_current++ == '\n';
     97            if (*m_currentString.m_current++ == '\n' && lineNumber)
     98                *lineNumber = *lineNumber + 1;
    10199            if (--m_currentString.m_length == 0)
    102100                advanceSubstring();
    … …  
    106104   
    107105    bool escaped() const { return m_pushedChar1; }
    108 
    109     int lineCount() const { return m_lines; }
    110     void resetLineCount() { m_lines = 0; }
    111106   
    112107    String toString() const;
    113108
    114     void operator++() { advance(); }
    115109    const UChar& operator*() const { return *current(); }
    116110    const UChar* operator->() const { return current(); }
    … …  
    128122    const UChar* m_currentChar;
    129123    DeprecatedValueList<SegmentedSubstring> m_substrings;
    130     int m_lines;
    131124    bool m_composite;
    132125};
Note: See TracChangeset for help on using the changeset viewer.