4ee5220611021aa06b273578dc1566c2093d9d35
[WebKit-https.git] / WebCore / html / HTMLTokenizer.cpp
1 /*
2     This file is part of the KDE libraries
3
4     Copyright (C) 1997 Martin Jones (mjones@kde.org)
5               (C) 1997 Torben Weis (weis@kde.org)
6               (C) 1998 Waldo Bastian (bastian@kde.org)
7               (C) 1999 Lars Knoll (knoll@kde.org)
8               (C) 1999 Antti Koivisto (koivisto@kde.org)
9               (C) 2001 Dirk Mueller (mueller@kde.org)
10     Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
11     Copyright (C) 2005, 2006 Alexey Proskuryakov (ap@nypop.com)
12
13     This library is free software; you can redistribute it and/or
14     modify it under the terms of the GNU Library General Public
15     License as published by the Free Software Foundation; either
16     version 2 of the License, or (at your option) any later version.
17
18     This library is distributed in the hope that it will be useful,
19     but WITHOUT ANY WARRANTY; without even the implied warranty of
20     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21     Library General Public License for more details.
22
23     You should have received a copy of the GNU Library General Public License
24     along with this library; see the file COPYING.LIB.  If not, write to
25     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
26     Boston, MA 02111-1307, USA.
27 */
28
29 #include "config.h"
30 #include "HTMLTokenizer.h"
31
32 #include "CachedScript.h"
33 #include "DocLoader.h"
34 #include "DocumentFragment.h"
35 #include "EventNames.h"
36 #include "Frame.h"
37 #include "HTMLViewSourceDocument.h"
38 #include "HTMLElement.h"
39 #include "SystemTime.h"
40 #include "csshelper.h"
41 #include "HTMLNames.h"
42 #include "HTMLParser.h"
43 #include "kjs_proxy.h"
44
45 #include "HTMLEntityNames.c"
46
47 // #define INSTRUMENT_LAYOUT_SCHEDULING 1
48
49 #define TOKENIZER_CHUNK_SIZE  4096
50
51 using namespace std;
52
53 namespace WebCore {
54
55 using namespace HTMLNames;
56 using namespace EventNames;
57
58 // FIXME: We would like this constant to be 200ms.
59 // Yielding more aggressively results in increased responsiveness and better incremental rendering.
60 // It slows down overall page-load on slower machines, though, so for now we set a value of 500.
61 const double tokenizerTimeDelay = 0.500;
62
63 static const char commentStart [] = "<!--";
64 static const char scriptEnd [] = "</script";
65 static const char xmpEnd [] = "</xmp";
66 static const char styleEnd [] =  "</style";
67 static const char textareaEnd [] = "</textarea";
68 static const char titleEnd [] = "</title";
69
70 // Full support for MS Windows extensions to Latin-1.
71 // Technically these extensions should only be activated for pages
72 // marked "windows-1252" or "cp1252", but
73 // in the standard Microsoft way, these extensions infect hundreds of thousands
74 // of web pages.  Note that people with non-latin-1 Microsoft extensions
75 // are SOL.
76 //
77 // See: http://www.microsoft.com/globaldev/reference/WinCP.asp
78 //      http://www.bbsinc.com/iso8859.html
79 //      http://www.obviously.com/
80 //
81 // There may be better equivalents
82
83 // We only need this for entities. For non-entity text, we handle this in the text encoding.
84
85 static const UChar windowsLatin1ExtensionArray[32] = {
86     0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021, // 80-87
87     0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F, // 88-8F
88     0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, // 90-97
89     0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178  // 98-9F
90 };
91
92 static inline UChar fixUpChar(UChar c)
93 {
94     if ((c & ~0x1F) != 0x0080)
95         return c;
96     return windowsLatin1ExtensionArray[c - 0x80];
97 }
98
99 static inline bool tagMatch(const char* s1, const UChar* s2, unsigned length)
100 {
101     for (unsigned i = 0; i != length; ++i) {
102         unsigned char c1 = s1[i];
103         unsigned char uc1 = toupper(c1);
104         UChar c2 = s2[i];
105         if (c1 != c2 && uc1 != c2)
106             return false;
107     }
108     return true;
109 }
110
111 inline void Token::addAttribute(Document* doc, const AtomicString& attrName, const AtomicString& v)
112 {
113     if (!attrName.isEmpty() && attrName != "/") {
114         Attribute* a = new MappedAttribute(attrName, v);
115         if (!attrs)
116             attrs = new NamedMappedAttrMap(0);
117         attrs->insertAttribute(a);
118     }
119 }
120
121 // ----------------------------------------------------------------------------
122
123 HTMLTokenizer::HTMLTokenizer(HTMLDocument* doc)
124     : Tokenizer()
125     , buffer(0)
126     , scriptCode(0)
127     , scriptCodeSize(0)
128     , scriptCodeMaxSize(0)
129     , scriptCodeResync(0)
130     , m_executingScript(0)
131     , m_requestingScript(false)
132     , m_timer(this, &HTMLTokenizer::timerFired)
133     , m_doc(doc)
134     , parser(new HTMLParser(doc))
135     , inWrite(false)
136     , m_fragment(false)
137 {
138     begin();
139 }
140
141 HTMLTokenizer::HTMLTokenizer(HTMLViewSourceDocument* doc)
142     : Tokenizer(true)
143     , buffer(0)
144     , scriptCode(0)
145     , scriptCodeSize(0)
146     , scriptCodeMaxSize(0)
147     , scriptCodeResync(0)
148     , m_executingScript(0)
149     , m_requestingScript(false)
150     , m_timer(this, &HTMLTokenizer::timerFired)
151     , m_doc(doc)
152     , parser(0)
153     , inWrite(false)
154     , m_fragment(false)
155 {
156     begin();
157 }
158
159 HTMLTokenizer::HTMLTokenizer(DocumentFragment* frag)
160     : buffer(0)
161     , scriptCode(0)
162     , scriptCodeSize(0)
163     , scriptCodeMaxSize(0)
164     , scriptCodeResync(0)
165     , m_executingScript(0)
166     , m_requestingScript(false)
167     , m_timer(this, &HTMLTokenizer::timerFired)
168     , m_doc(frag->document())
169     , inWrite(false)
170     , m_fragment(true)
171 {
172     parser = new HTMLParser(frag);
173     begin();
174 }
175
176 void HTMLTokenizer::reset()
177 {
178     ASSERT(m_executingScript == 0);
179
180     while (!pendingScripts.isEmpty()) {
181       CachedScript *cs = pendingScripts.dequeue();
182       ASSERT(cs->accessCount() > 0);
183       cs->deref(this);
184     }
185     
186     fastFree(buffer);
187     buffer = dest = 0;
188     size = 0;
189
190     fastFree(scriptCode);
191     scriptCode = 0;
192     scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
193
194     m_timer.stop();
195     m_state.setAllowYield(false);
196     m_state.setForceSynchronous(false);
197
198     currToken.reset();
199 }
200
201 void HTMLTokenizer::begin()
202 {
203     m_executingScript = 0;
204     m_requestingScript = false;
205     m_state.setLoadingExtScript(false);
206     reset();
207     size = 254;
208     buffer = static_cast<UChar*>(fastMalloc(sizeof(UChar) * 254));
209     dest = buffer;
210     tquote = NoQuote;
211     searchCount = 0;
212     m_state.setEntityState(NoEntity);
213     scriptSrc = DeprecatedString::null;
214     pendingSrc.clear();
215     currentPrependingSrc = 0;
216     noMoreData = false;
217     brokenComments = false;
218     brokenServer = false;
219     lineno = 0;
220     scriptStartLineno = 0;
221     tagStartLineno = 0;
222     m_state.setForceSynchronous(false);
223 }
224
225 void HTMLTokenizer::setForceSynchronous(bool force)
226 {
227     m_state.setForceSynchronous(force);
228 }
229
230 HTMLTokenizer::State HTMLTokenizer::processListing(SegmentedString list, State state)
231 {
232     // This function adds the listing 'list' as
233     // preformatted text-tokens to the token-collection
234     while (!list.isEmpty()) {
235         if (state.skipLF()) {
236             state.setSkipLF(false);
237             if (*list == '\n') {
238                 ++list;
239                 continue;
240             }
241         }
242
243         checkBuffer();
244
245         if (*list == '\n' || *list == '\r') {
246             if (state.discardLF())
247                 // Ignore this LF
248                 state.setDiscardLF(false); // We have discarded 1 LF
249             else
250                 *dest++ = '\n';
251
252             /* Check for MS-DOS CRLF sequence */
253             if (*list == '\r')
254                 state.setSkipLF(true);
255
256             ++list;
257         } else {
258             state.setDiscardLF(false);
259             *dest++ = *list;
260             ++list;
261         }
262     }
263
264     return state;
265 }
266
267 HTMLTokenizer::State HTMLTokenizer::parseSpecial(SegmentedString &src, State state)
268 {
269     ASSERT(state.inTextArea() || state.inTitle() || !state.hasEntityState());
270     ASSERT(!state.hasTagState());
271     ASSERT(state.inXmp() + state.inTextArea() + state.inTitle() + state.inStyle() + state.inScript() == 1 );
272     if (state.inScript())
273         scriptStartLineno = lineno + src.lineCount();
274
275     if (state.inComment()) 
276         state = parseComment(src, state);
277
278     while ( !src.isEmpty() ) {
279         checkScriptBuffer();
280         UChar ch = *src;
281         if (!scriptCodeResync && !brokenComments && !state.inTextArea() && !state.inXmp() && !state.inTitle() && ch == '-' && scriptCodeSize >= 3 && !src.escaped() && scriptCode[scriptCodeSize-3] == '<' && scriptCode[scriptCodeSize-2] == '!' && scriptCode[scriptCodeSize-1] == '-') {
282             state.setInComment(true);
283             state = parseComment(src, state);
284             continue;
285         }
286         if (scriptCodeResync && !tquote && ch == '>') {
287             ++src;
288             scriptCodeSize = scriptCodeResync-1;
289             scriptCodeResync = 0;
290             scriptCode[ scriptCodeSize ] = scriptCode[ scriptCodeSize + 1 ] = 0;
291             if (state.inScript())
292                 state = scriptHandler(state);
293             else {
294                 state = processListing(SegmentedString(scriptCode, scriptCodeSize), state);
295                 processToken();
296                 if (state.inStyle()) { 
297                     currToken.tagName = styleTag.localName(); 
298                     currToken.beginTag = false; 
299                 } else if (state.inTextArea()) { 
300                     currToken.tagName = textareaTag.localName(); 
301                     currToken.beginTag = false; 
302                 } else if (state.inTitle()) { 
303                     currToken.tagName = titleTag.localName(); 
304                     currToken.beginTag = false; 
305                 } else if (state.inXmp()) {
306                     currToken.tagName = xmpTag.localName(); 
307                     currToken.beginTag = false; 
308                 }
309                 processToken();
310                 state.setInStyle(false);
311                 state.setInScript(false);
312                 state.setInTextArea(false);
313                 state.setInTitle(false);
314                 state.setInXmp(false);
315                 tquote = NoQuote;
316                 scriptCodeSize = scriptCodeResync = 0;
317             }
318             return state;
319         }
320         // possible end of tagname, lets check.
321         if (!scriptCodeResync && !state.escaped() && !src.escaped() && (ch == '>' || ch == '/' || ch <= ' ') && ch &&
322              scriptCodeSize >= searchStopperLen &&
323              tagMatch( searchStopper, scriptCode+scriptCodeSize-searchStopperLen, searchStopperLen )) {
324             scriptCodeResync = scriptCodeSize-searchStopperLen+1;
325             tquote = NoQuote;
326             continue;
327         }
328         if (scriptCodeResync && !state.escaped()) {
329             if (ch == '\"')
330                 tquote = (tquote == NoQuote) ? DoubleQuote : ((tquote == SingleQuote) ? SingleQuote : NoQuote);
331             else if (ch == '\'')
332                 tquote = (tquote == NoQuote) ? SingleQuote : (tquote == DoubleQuote) ? DoubleQuote : NoQuote;
333             else if (tquote != NoQuote && (ch == '\r' || ch == '\n'))
334                 tquote = NoQuote;
335         }
336         state.setEscaped(!state.escaped() && ch == '\\');
337         if (!scriptCodeResync && (state.inTextArea() || state.inTitle()) && !src.escaped() && ch == '&') {
338             UChar* scriptCodeDest = scriptCode+scriptCodeSize;
339             ++src;
340             state = parseEntity(src, scriptCodeDest, state, m_cBufferPos, true, false);
341             scriptCodeSize = scriptCodeDest-scriptCode;
342         } else {
343             scriptCode[scriptCodeSize++] = *src;
344             ++src;
345         }
346     }
347
348     return state;
349 }
350
351 HTMLTokenizer::State HTMLTokenizer::scriptHandler(State state)
352 {
353     // We are inside a <script>
354     bool doScriptExec = false;
355
356     // (Bugzilla 3837) Scripts following a frameset element should not execute or, 
357     // in the case of extern scripts, even load.
358     bool followingFrameset = (m_doc->body() && m_doc->body()->hasTagName(framesetTag));
359   
360     CachedScript* cs = 0;
361     // don't load external scripts for standalone documents (for now)
362     if (!inViewSourceMode()) {
363         if (!scriptSrc.isEmpty() && m_doc->frame()) {
364             // forget what we just got; load from src url instead
365             if (!parser->skipMode() && !followingFrameset) {
366     #if INSTRUMENT_LAYOUT_SCHEDULING
367                 if (!m_doc->ownerElement())
368                     printf("Requesting script at time %d\n", m_doc->elapsedTime());
369     #endif
370                 if ( (cs = m_doc->docLoader()->requestScript(scriptSrc, scriptSrcCharset) ))
371                     pendingScripts.enqueue(cs);
372                 else
373                     scriptNode = 0;
374             } else
375                 scriptNode = 0;
376             scriptSrc=DeprecatedString::null;
377         }
378         else {
379     #ifdef TOKEN_DEBUG
380             kdDebug( 6036 ) << "---START SCRIPT---" << endl;
381             kdDebug( 6036 ) << DeprecatedString(scriptCode, scriptCodeSize) << endl;
382             kdDebug( 6036 ) << "---END SCRIPT---" << endl;
383     #endif
384             scriptNode = 0;
385             // Parse scriptCode containing <script> info
386             doScriptExec = true;
387         }
388     }
389
390     state = processListing(SegmentedString(scriptCode, scriptCodeSize), state);
391     DeprecatedString exScript(reinterpret_cast<QChar*>(buffer), dest - buffer);
392     processToken();
393     currToken.tagName = scriptTag.localName();
394     currToken.beginTag = false;
395     processToken();
396
397     state.setInScript(false);
398     
399     // FIXME: The script should be syntax highlighted.
400     if (inViewSourceMode())
401         return state;
402
403     SegmentedString *savedPrependingSrc = currentPrependingSrc;
404     SegmentedString prependingSrc;
405     currentPrependingSrc = &prependingSrc;
406     scriptCodeSize = scriptCodeResync = 0;
407
408     if (!parser->skipMode() && !followingFrameset) {
409         if (cs) {
410             if (savedPrependingSrc)
411                 savedPrependingSrc->append(src);
412             else
413                 pendingSrc.prepend(src);
414             setSrc(SegmentedString());
415
416             // the ref() call below may call notifyFinished if the script is already in cache,
417             // and that mucks with the state directly, so we must write it back to the object.
418             m_state = state;
419             bool savedRequestingScript = m_requestingScript;
420             m_requestingScript = true;
421             cs->ref(this);
422             m_requestingScript = savedRequestingScript;
423             state = m_state;
424             // will be 0 if script was already loaded and ref() executed it
425             if (!pendingScripts.isEmpty())
426                 state.setLoadingExtScript(true);
427         }
428         else if (!m_fragment && doScriptExec && javascript ) {
429             if (!m_executingScript)
430                 pendingSrc.prepend(src);
431             else
432                 prependingSrc = src;
433             setSrc(SegmentedString());
434             state = scriptExecution(exScript, state, DeprecatedString::null, scriptStartLineno);
435         }
436     }
437
438     if (!m_executingScript && !state.loadingExtScript()) {
439         src.append(pendingSrc);
440         pendingSrc.clear();
441     } else if (!prependingSrc.isEmpty()) {
442         // restore first so that the write appends in the right place
443         // (does not hurt to do it again below)
444         currentPrependingSrc = savedPrependingSrc;
445
446         // we need to do this slightly modified bit of one of the write() cases
447         // because we want to prepend to pendingSrc rather than appending
448         // if there's no previous prependingSrc
449         if (state.loadingExtScript()) {
450             if (currentPrependingSrc) {
451                 currentPrependingSrc->append(prependingSrc);
452             } else {
453                 pendingSrc.prepend(prependingSrc);
454             }
455         } else {
456             m_state = state;
457             write(prependingSrc, false);
458             state = m_state;
459         }
460     }
461
462     currentPrependingSrc = savedPrependingSrc;
463
464     return state;
465 }
466
467 HTMLTokenizer::State HTMLTokenizer::scriptExecution(const DeprecatedString& str, State state, DeprecatedString scriptURL, int baseLine)
468 {
469     if (m_fragment || !m_doc->frame())
470         return state;
471     m_executingScript++;
472     DeprecatedString url = scriptURL.isNull() ? m_doc->frame()->document()->URL() : scriptURL;
473
474     SegmentedString *savedPrependingSrc = currentPrependingSrc;
475     SegmentedString prependingSrc;
476     currentPrependingSrc = &prependingSrc;
477
478 #if INSTRUMENT_LAYOUT_SCHEDULING
479     if (!m_doc->ownerElement())
480         printf("beginning script execution at %d\n", m_doc->elapsedTime());
481 #endif
482
483     m_state = state;
484     m_doc->frame()->executeScript(url,baseLine,0,str);
485     state = m_state;
486
487     state.setAllowYield(true);
488
489 #if INSTRUMENT_LAYOUT_SCHEDULING
490     if (!m_doc->ownerElement())
491         printf("ending script execution at %d\n", m_doc->elapsedTime());
492 #endif
493     
494     m_executingScript--;
495
496     if (!m_executingScript && !state.loadingExtScript()) {
497         src.append(pendingSrc);
498         pendingSrc.clear();
499     } else if (!prependingSrc.isEmpty()) {
500         // restore first so that the write appends in the right place
501         // (does not hurt to do it again below)
502         currentPrependingSrc = savedPrependingSrc;
503
504         // we need to do this slightly modified bit of one of the write() cases
505         // because we want to prepend to pendingSrc rather than appending
506         // if there's no previous prependingSrc
507         if (state.loadingExtScript()) {
508             if (currentPrependingSrc)
509                 currentPrependingSrc->append(prependingSrc);
510             else
511                 pendingSrc.prepend(prependingSrc);
512         } else {
513             m_state = state;
514             write(prependingSrc, false);
515             state = m_state;
516         }
517     }
518
519     currentPrependingSrc = savedPrependingSrc;
520
521     return state;
522 }
523
524 HTMLTokenizer::State HTMLTokenizer::parseComment(SegmentedString &src, State state)
525 {
526     // FIXME: Why does this code even run for comments inside <script> and <style>? This seems bogus.
527     checkScriptBuffer(src.length());
528     while ( !src.isEmpty() ) {
529         scriptCode[ scriptCodeSize++ ] = *src;
530
531         if (*src == '>') {
532             bool handleBrokenComments = brokenComments && !(state.inScript() || state.inStyle());
533             int endCharsCount = 1; // start off with one for the '>' character
534             if (scriptCodeSize > 2 && scriptCode[scriptCodeSize-3] == '-' && scriptCode[scriptCodeSize-2] == '-') {
535                 endCharsCount = 3;
536             }
537             else if (scriptCodeSize > 3 && scriptCode[scriptCodeSize-4] == '-' && scriptCode[scriptCodeSize-3] == '-' && 
538                 scriptCode[scriptCodeSize-2] == '!') {
539                 // Other browsers will accept --!> as a close comment, even though it's
540                 // not technically valid.
541                 endCharsCount = 4;
542             }
543             if (handleBrokenComments || endCharsCount > 1) {
544                 ++src;
545                 if (!(state.inScript() || state.inXmp() || state.inTextArea() || state.inStyle())) {
546 #ifdef INCLUDE_COMMENTS_IN_DOM // FIXME: Turn this on soon.
547                     checkScriptBuffer();
548                     scriptCode[scriptCodeSize] = 0;
549                     scriptCode[scriptCodeSize + 1] = 0;
550                     currToken.tagName = commentAtom;
551                     currToken.beginTag = true;
552                     state = processListing(SegmentedString(scriptCode, scriptCodeSize - endCharsCount), state);
553                     processToken();
554                     currToken.tagName = commentAtom;
555                     currToken.beginTag = false;
556                     processToken();
557 #endif
558                     scriptCodeSize = 0;
559                 }
560                 state.setInComment(false);
561                 return state; // Finished parsing comment
562             }
563         }
564         ++src;
565     }
566
567     return state;
568 }
569
570 HTMLTokenizer::State HTMLTokenizer::parseServer(SegmentedString& src, State state)
571 {
572     checkScriptBuffer(src.length());
573     while (!src.isEmpty()) {
574         scriptCode[scriptCodeSize++] = *src;
575         if (*src == '>' &&
576             scriptCodeSize > 1 && scriptCode[scriptCodeSize-2] == '%') {
577             ++src;
578             state.setInServer(false);
579             scriptCodeSize = 0;
580             return state; // Finished parsing server include
581         }
582         ++src;
583     }
584     return state;
585 }
586
587 HTMLTokenizer::State HTMLTokenizer::parseProcessingInstruction(SegmentedString &src, State state)
588 {
589     UChar oldchar = 0;
590     while (!src.isEmpty()) {
591         UChar chbegin = *src;
592         if (chbegin == '\'')
593             tquote = tquote == SingleQuote ? NoQuote : SingleQuote;
594         else if (chbegin == '\"')
595             tquote = tquote == DoubleQuote ? NoQuote : DoubleQuote;
596         // Look for '?>'
597         // Some crappy sites omit the "?" before it, so
598         // we look for an unquoted '>' instead. (IE compatible)
599         else if (chbegin == '>' && (!tquote || oldchar == '?')) {
600             // We got a '?>' sequence
601             state.setInProcessingInstruction(false);
602             ++src;
603             state.setDiscardLF(true);
604             return state; // Finished parsing comment!
605         }
606         ++src;
607         oldchar = chbegin;
608     }
609     
610     return state;
611 }
612
613 HTMLTokenizer::State HTMLTokenizer::parseText(SegmentedString &src, State state)
614 {
615     while (!src.isEmpty()) {
616         UChar cc = *src;
617
618         if (state.skipLF()) {
619             state.setSkipLF(false);
620             if (cc == '\n') {
621                 ++src;
622                 continue;
623             }
624         }
625
626         // do we need to enlarge the buffer?
627         checkBuffer();
628
629         if (cc == '\r') {
630             state.setSkipLF(true);
631             *dest++ = '\n';
632         } else
633             *dest++ = cc;
634         ++src;
635     }
636
637     return state;
638 }
639
640
641 HTMLTokenizer::State HTMLTokenizer::parseEntity(SegmentedString &src, UChar*& dest, State state, unsigned &cBufferPos, bool start, bool parsingTag)
642 {
643     if (start)
644     {
645         cBufferPos = 0;
646         state.setEntityState(SearchEntity);
647         EntityUnicodeValue = 0;
648     }
649
650     while(!src.isEmpty())
651     {
652         UChar cc = *src;
653         switch(state.entityState()) {
654         case NoEntity:
655             ASSERT(state.entityState() != NoEntity);
656             return state;
657         
658         case SearchEntity:
659             if(cc == '#') {
660                 cBuffer[cBufferPos++] = cc;
661                 ++src;
662                 state.setEntityState(NumericSearch);
663             }
664             else
665                 state.setEntityState(EntityName);
666
667             break;
668
669         case NumericSearch:
670             if (cc == 'x' || cc == 'X') {
671                 cBuffer[cBufferPos++] = cc;
672                 ++src;
673                 state.setEntityState(Hexadecimal);
674             } else if (cc >= '0' && cc <= '9')
675                 state.setEntityState(Decimal);
676             else
677                 state.setEntityState(SearchSemicolon);
678             break;
679
680         case Hexadecimal: {
681             int ll = min(src.length(), 10 - cBufferPos);
682             while (ll--) {
683                 cc = *src;
684                 if (!((cc >= '0' && cc <= '9') || (cc >= 'a' && cc <= 'f') || (cc >= 'A' && cc <= 'F'))) {
685                     state.setEntityState(SearchSemicolon);
686                     break;
687                 }
688                 int digit;
689                 if (cc < 'A')
690                     digit = cc - '0';
691                 else
692                     digit = (cc - 'A' + 10) & 0xF; // handle both upper and lower case without a branch
693                 EntityUnicodeValue = EntityUnicodeValue * 16 + digit;
694                 cBuffer[cBufferPos++] = cc;
695                 ++src;
696             }
697             if (cBufferPos == 10)  
698                 state.setEntityState(SearchSemicolon);
699             break;
700         }
701         case Decimal:
702         {
703             int ll = min(src.length(), 9-cBufferPos);
704             while(ll--) {
705                 cc = *src;
706
707                 if (!(cc >= '0' && cc <= '9')) {
708                     state.setEntityState(SearchSemicolon);
709                     break;
710                 }
711
712                 EntityUnicodeValue = EntityUnicodeValue * 10 + (cc - '0');
713                 cBuffer[cBufferPos++] = cc;
714                 ++src;
715             }
716             if (cBufferPos == 9)  
717                 state.setEntityState(SearchSemicolon);
718             break;
719         }
720         case EntityName:
721         {
722             int ll = min(src.length(), 9-cBufferPos);
723             while(ll--) {
724                 cc = *src;
725
726                 if (!((cc >= 'a' && cc <= 'z') || (cc >= '0' && cc <= '9') || (cc >= 'A' && cc <= 'Z'))) {
727                     state.setEntityState(SearchSemicolon);
728                     break;
729                 }
730
731                 cBuffer[cBufferPos++] = cc;
732                 ++src;
733             }
734             if (cBufferPos == 9) 
735                 state.setEntityState(SearchSemicolon);
736             if (state.entityState() == SearchSemicolon) {
737                 if(cBufferPos > 1) {
738                     const Entity *e = findEntity(cBuffer, cBufferPos);
739                     if(e)
740                         EntityUnicodeValue = e->code;
741
742                     // be IE compatible
743                     if(parsingTag && EntityUnicodeValue > 255 && *src != ';')
744                         EntityUnicodeValue = 0;
745                 }
746             }
747             else
748                 break;
749         }
750         case SearchSemicolon:
751             // Don't allow values that are more than 21 bits.
752             if (EntityUnicodeValue > 0 && EntityUnicodeValue <= 0x10FFFF) {
753                 if (!inViewSourceMode()) {
754                     if (*src == ';')
755                         ++src;
756                     if (EntityUnicodeValue <= 0xFFFF) {
757                         checkBuffer();
758                         src.push(fixUpChar(EntityUnicodeValue));
759                     } else {
760                         // Convert to UTF-16, using surrogate code points.
761                         checkBuffer(2);
762                         src.push(U16_LEAD(EntityUnicodeValue));
763                         src.push(U16_TRAIL(EntityUnicodeValue));
764                     }
765                 } else {
766                     // FIXME: We should eventually colorize entities by sending them as a special token.
767                     checkBuffer(11);
768                     *dest++ = '&';
769                     for (unsigned i = 0; i < cBufferPos; i++)
770                         dest[i] = cBuffer[i];
771                     dest += cBufferPos;
772                     if (*src == ';') {
773                         *dest++ = ';';
774                         ++src;
775                     }
776                 }
777             } else {
778                 checkBuffer(10);
779                 // ignore the sequence, add it to the buffer as plaintext
780                 *dest++ = '&';
781                 for (unsigned i = 0; i < cBufferPos; i++)
782                     dest[i] = cBuffer[i];
783                 dest += cBufferPos;
784             }
785
786             state.setEntityState(NoEntity);
787             return state;
788         }
789     }
790
791     return state;
792 }
793
794 HTMLTokenizer::State HTMLTokenizer::parseTag(SegmentedString &src, State state)
795 {
796     ASSERT(!state.hasEntityState());
797
798     unsigned cBufferPos = m_cBufferPos;
799
800     while (!src.isEmpty())
801     {
802         checkBuffer();
803         switch(state.tagState()) {
804         case NoTag:
805         {
806             m_cBufferPos = cBufferPos;
807             return state;
808         }
809         case TagName:
810         {
811 #if defined(TOKEN_DEBUG) &&  TOKEN_DEBUG > 1
812             qDebug("TagName");
813 #endif
814             if (searchCount > 0)
815             {
816                 if (*src == commentStart[searchCount])
817                 {
818                     searchCount++;
819                     if (searchCount == 4)
820                     {
821 #ifdef TOKEN_DEBUG
822                         kdDebug( 6036 ) << "Found comment" << endl;
823 #endif
824                         // Found '<!--' sequence
825                         ++src;
826                         dest = buffer; // ignore the previous part of this tag
827                         state.setInComment(true);
828                         state.setTagState(NoTag);
829
830                         // Fix bug 34302 at kde.bugs.org.  Go ahead and treat
831                         // <!--> as a valid comment, since both mozilla and IE on windows
832                         // can handle this case.  Only do this in quirks mode. -dwh
833                         if (!src.isEmpty() && *src == '>' && m_doc->inCompatMode()) {
834                           state.setInComment(false);
835                           ++src;
836                           if (!src.isEmpty())
837                               // cuts off high bits, which is okay
838                               cBuffer[cBufferPos++] = *src;
839                         }
840                         else
841                           state = parseComment(src, state);
842
843                         m_cBufferPos = cBufferPos;
844                         return state; // Finished parsing tag!
845                     }
846                     // cuts off high bits, which is okay
847                     cBuffer[cBufferPos++] = *src;
848                     ++src;
849                     break;
850                 }
851                 else
852                     searchCount = 0; // Stop looking for '<!--' sequence
853             }
854
855             bool finish = false;
856             unsigned int ll = min(src.length(), CBUFLEN-cBufferPos);
857             while(ll--) {
858                 UChar curchar = *src;
859                 if(curchar <= ' ' || curchar == '>' ) {
860                     finish = true;
861                     break;
862                 }
863                 
864                 // tolower() shows up on profiles. This is faster!
865                 if (curchar >= 'A' && curchar <= 'Z' && !inViewSourceMode())
866                     cBuffer[cBufferPos++] = curchar + ('a' - 'A');
867                 else
868                     cBuffer[cBufferPos++] = curchar;
869                 ++src;
870             }
871
872             // Disadvantage: we add the possible rest of the tag
873             // as attribute names. ### judge if this causes problems
874             if(finish || CBUFLEN == cBufferPos) {
875                 bool beginTag;
876                 char* ptr = cBuffer;
877                 unsigned int len = cBufferPos;
878                 cBuffer[cBufferPos] = '\0';
879                 if ((cBufferPos > 0) && (*ptr == '/')) {
880                     // End Tag
881                     beginTag = false;
882                     ptr++;
883                     len--;
884                 }
885                 else
886                     // Start Tag
887                     beginTag = true;
888
889                 // Ignore the / in fake xml tags like <br/>.  We trim off the "/" so that we'll get "br" as the tag name and not "br/".
890                 if (len > 1 && ptr[len-1] == '/' && !inViewSourceMode())
891                     ptr[--len] = '\0';
892
893                 // Now that we've shaved off any invalid / that might have followed the name), make the tag.
894                 // FIXME: FireFox and WinIE turn !foo nodes into comments, we ignore comments. (fast/parser/tag-with-exclamation-point.html)
895                 if (ptr[0] != '!') {
896                     currToken.tagName = AtomicString(ptr);
897                     currToken.beginTag = beginTag;
898                 }
899                 dest = buffer;
900                 state.setTagState(SearchAttribute);
901                 cBufferPos = 0;
902             }
903             break;
904         }
905         case SearchAttribute:
906 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
907             qDebug("SearchAttribute");
908 #endif
909             while(!src.isEmpty()) {
910                 UChar curchar = *src;
911                 // In this mode just ignore any quotes we encounter and treat them like spaces.
912                 if (curchar > ' ' && curchar != '\'' && curchar != '"') {
913                     if (curchar == '<' || curchar == '>')
914                         state.setTagState(SearchEnd);
915                     else
916                         state.setTagState(AttributeName);
917
918                     cBufferPos = 0;
919                     break;
920                 }
921                 ++src;
922             }
923             break;
924         case AttributeName:
925         {
926 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
927             qDebug("AttributeName");
928 #endif
929             int ll = min(src.length(), CBUFLEN-cBufferPos);
930             while(ll--) {
931                 UChar curchar = *src;
932                 if (curchar <= '>' && (curchar >= '=' || curchar <= ' ')) {
933                     cBuffer[cBufferPos] = '\0';
934                     attrName = AtomicString(cBuffer);
935                     dest = buffer;
936                     *dest++ = 0;
937                     state.setTagState(SearchEqual);
938                     // This is a deliberate quirk to match Mozilla and Opera.  We have to do this
939                     // since sites that use the "standards-compliant" path sometimes send
940                     // <script src="foo.js"/>.  Both Moz and Opera will honor this, despite it
941                     // being bogus HTML.  They do not honor the "/" for other tags.  This behavior
942                     // also deviates from WinIE, but in this case we'll just copy Moz and Opera.
943                     if (currToken.tagName == scriptTag && curchar == '>' && attrName == "/")
944                         currToken.flat = true;
945                     break;
946                 }
947                 
948                 // tolower() shows up on profiles. This is faster!
949                 if (curchar >= 'A' && curchar <= 'Z')
950                     cBuffer[cBufferPos++] = curchar + ('a' - 'A');
951                 else
952                     cBuffer[cBufferPos++] = curchar;
953                 ++src;
954             }
955             if ( cBufferPos == CBUFLEN ) {
956                 cBuffer[cBufferPos] = '\0';
957                 attrName = AtomicString(cBuffer);
958                 dest = buffer;
959                 *dest++ = 0;
960                 state.setTagState(SearchEqual);
961             }
962             break;
963         }
964         case SearchEqual:
965 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
966             qDebug("SearchEqual");
967 #endif
968             while(!src.isEmpty()) {
969                 UChar curchar = *src;
970                 // In this mode just ignore any quotes we encounter and treat them like spaces.
971                 if (curchar > ' ' && curchar != '\'' && curchar != '"') {
972                     if(curchar == '=') {
973 #ifdef TOKEN_DEBUG
974                         kdDebug(6036) << "found equal" << endl;
975 #endif
976                         state.setTagState(SearchValue);
977                         ++src;
978                     }
979                     else {
980                         currToken.addAttribute(m_doc, attrName, emptyAtom);
981                         dest = buffer;
982                         state.setTagState(SearchAttribute);
983                     }
984                     break;
985                 }
986                 ++src;
987             }
988             break;
989         case SearchValue:
990             while(!src.isEmpty()) {
991                 UChar curchar = *src;
992                 if(curchar > ' ') {
993                     if(( curchar == '\'' || curchar == '\"' )) {
994                         tquote = curchar == '\"' ? DoubleQuote : SingleQuote;
995                         state.setTagState(QuotedValue);
996                         ++src;
997                     } else
998                         state.setTagState(Value);
999
1000                     break;
1001                 }
1002                 ++src;
1003             }
1004             break;
1005         case QuotedValue:
1006 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
1007             qDebug("QuotedValue");
1008 #endif
1009             while(!src.isEmpty()) {
1010                 checkBuffer();
1011
1012                 UChar curchar = *src;
1013                 if (curchar == '>' && attrName.isEmpty()) {
1014                     // Handle a case like <img '>.  Just go ahead and be willing
1015                     // to close the whole tag.  Don't consume the character and
1016                     // just go back into SearchEnd while ignoring the whole
1017                     // value.
1018                     // FIXME: Note that this is actually not a very good solution. It's
1019                     // an interim hack and doesn't handle the general case of
1020                     // unmatched quotes among attributes that have names. -dwh
1021                     while(dest > buffer+1 && (*(dest-1) == '\n' || *(dest-1) == '\r'))
1022                         dest--; // remove trailing newlines
1023                     AtomicString v(buffer+1, dest-buffer-1);
1024                     attrName = v; // Just make the name/value match. (FIXME: Is this some WinIE quirk?)
1025                     currToken.addAttribute(m_doc, attrName, v);
1026                     state.setTagState(SearchAttribute);
1027                     dest = buffer;
1028                     tquote = NoQuote;
1029                     break;
1030                 }
1031                 
1032                 if(curchar <= '\'' && !src.escaped()) {
1033                     // ### attributes like '&{blaa....};' are supposed to be treated as jscript.
1034                     if ( curchar == '&' )
1035                     {
1036                         ++src;
1037                         state = parseEntity(src, dest, state, cBufferPos, true, true);
1038                         break;
1039                     }
1040                     else if ( (tquote == SingleQuote && curchar == '\'') ||
1041                               (tquote == DoubleQuote && curchar == '\"') )
1042                     {
1043                         // some <input type=hidden> rely on trailing spaces. argh
1044                         while(dest > buffer+1 && (*(dest-1) == '\n' || *(dest-1) == '\r'))
1045                             dest--; // remove trailing newlines
1046                         AtomicString v(buffer+1, dest-buffer-1);
1047                         if (attrName.isEmpty())
1048                             attrName = v; // Make the name match the value. (FIXME: Is this a WinIE quirk?)
1049                         currToken.addAttribute(m_doc, attrName, v);
1050
1051                         dest = buffer;
1052                         state.setTagState(SearchAttribute);
1053                         tquote = NoQuote;
1054                         ++src;
1055                         break;
1056                     }
1057                 }
1058                 *dest++ = *src;
1059                 ++src;
1060             }
1061             break;
1062         case Value:
1063 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
1064             qDebug("Value");
1065 #endif
1066             while(!src.isEmpty()) {
1067                 checkBuffer();
1068                 UChar curchar = *src;
1069                 if(curchar <= '>' && !src.escaped()) {
1070                     // parse Entities
1071                     if ( curchar == '&' )
1072                     {
1073                         ++src;
1074                         state = parseEntity(src, dest, state, cBufferPos, true, true);
1075                         break;
1076                     }
1077                     // no quotes. Every space means end of value
1078                     // '/' does not delimit in IE!
1079                     if ( curchar <= ' ' || curchar == '>' )
1080                     {
1081                         AtomicString v(buffer+1, dest-buffer-1);
1082                         currToken.addAttribute(m_doc, attrName, v);
1083                         dest = buffer;
1084                         state.setTagState(SearchAttribute);
1085                         break;
1086                     }
1087                 }
1088
1089                 *dest++ = *src;
1090                 ++src;
1091             }
1092             break;
1093         case SearchEnd:
1094         {
1095 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
1096                 qDebug("SearchEnd");
1097 #endif
1098             while(!src.isEmpty()) {
1099                 if (*src == '>' || *src == '<')
1100                     break;
1101
1102                 if (*src == '/')
1103                     currToken.flat = true;
1104
1105                 ++src;
1106             }
1107             if (src.isEmpty()) break;
1108
1109             searchCount = 0; // Stop looking for '<!--' sequence
1110             state.setTagState(NoTag);
1111             tquote = NoQuote;
1112
1113             if (*src != '<')
1114                 ++src;
1115
1116             if (currToken.tagName == nullAtom) { //stop if tag is unknown
1117                 m_cBufferPos = cBufferPos;
1118                 return state;
1119             }
1120
1121             AtomicString tagName = currToken.tagName;
1122 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 0
1123             kdDebug( 6036 ) << "appending Tag: " << tagName.deprecatedString() << endl;
1124 #endif
1125
1126             // Handle <script src="foo"/> like Mozilla/Opera. We have to do this now for Dashboard
1127             // compatibility.
1128             bool isSelfClosingScript = currToken.flat && currToken.beginTag && currToken.tagName == scriptTag;
1129             bool beginTag = !currToken.flat && currToken.beginTag;
1130             if (currToken.beginTag && currToken.tagName == scriptTag) {
1131                 Attribute* a = 0;
1132                 bool foundTypeAttribute = false;
1133                 scriptSrc = DeprecatedString::null;
1134                 scriptSrcCharset = DeprecatedString::null;
1135                 if ( currToken.attrs && /* potentially have a ATTR_SRC ? */
1136                      m_doc->frame() &&
1137                      m_doc->frame()->jScriptEnabled() && /* jscript allowed at all? */
1138                      !m_fragment /* are we a regular tokenizer or just for innerHTML ? */
1139                     ) {
1140                     if ((a = currToken.attrs->getAttributeItem(srcAttr)))
1141                         scriptSrc = m_doc->completeURL(parseURL(a->value()).deprecatedString());
1142                     if ((a = currToken.attrs->getAttributeItem(charsetAttr)))
1143                         scriptSrcCharset = a->value().deprecatedString().stripWhiteSpace();
1144                     if ( scriptSrcCharset.isEmpty() )
1145                         scriptSrcCharset = m_doc->frame()->encoding();
1146                     /* Check type before language, since language is deprecated */
1147                     if ((a = currToken.attrs->getAttributeItem(typeAttr)) != 0 && !a->value().isEmpty())
1148                         foundTypeAttribute = true;
1149                     else
1150                         a = currToken.attrs->getAttributeItem(languageAttr);
1151                 }
1152                 javascript = true;
1153
1154                 if( foundTypeAttribute ) {
1155                     /* 
1156                         Mozilla 1.5 accepts application/x-javascript, and some web references claim it is the only
1157                         correct variation, but WinIE 6 doesn't accept it.
1158                         Neither Mozilla 1.5 nor WinIE 6 accept application/javascript, application/ecmascript, or
1159                         application/x-ecmascript.
1160                         Mozilla 1.5 doesn't accept the text/javascript1.x formats, but WinIE 6 does.
1161                         Mozilla 1.5 doesn't accept text/jscript, text/ecmascript, and text/livescript, but WinIE 6 does.
1162                         Mozilla 1.5 allows leading and trailing whitespace, but WinIE 6 doesn't.
1163                         Mozilla 1.5 and WinIE 6 both accept the empty string, but neither accept a whitespace-only string.
1164                         We want to accept all the values that either of these browsers accept, but not other values.
1165                      */
1166                     DeprecatedString type = a->value().deprecatedString().stripWhiteSpace().lower();
1167                     if( type.compare("application/x-javascript") != 0 &&
1168                         type.compare("text/javascript") != 0 &&
1169                         type.compare("text/javascript1.0") != 0 &&
1170                         type.compare("text/javascript1.1") != 0 &&
1171                         type.compare("text/javascript1.2") != 0 &&
1172                         type.compare("text/javascript1.3") != 0 &&
1173                         type.compare("text/javascript1.4") != 0 &&
1174                         type.compare("text/javascript1.5") != 0 &&
1175                         type.compare("text/jscript") != 0 &&
1176                         type.compare("text/ecmascript") != 0 &&
1177                         type.compare("text/livescript") )
1178                         javascript = false;
1179                 } else if( a ) {
1180                     /* 
1181                      Mozilla 1.5 doesn't accept jscript or ecmascript, but WinIE 6 does.
1182                      Mozilla 1.5 accepts javascript1.0, javascript1.4, and javascript1.5, but WinIE 6 accepts only 1.1 - 1.3.
1183                      Neither Mozilla 1.5 nor WinIE 6 accept leading or trailing whitespace.
1184                      We want to accept all the values that either of these browsers accept, but not other values.
1185                      */
1186                     String lang = a->value().domString().lower();
1187                     if( lang != "" &&
1188                         lang != "javascript" &&
1189                         lang != "javascript1.0" &&
1190                         lang != "javascript1.1" &&
1191                         lang != "javascript1.2" &&
1192                         lang != "javascript1.3" &&
1193                         lang != "javascript1.4" &&
1194                         lang != "javascript1.5" &&
1195                         lang != "ecmascript" &&
1196                         lang != "livescript" &&
1197                         lang != "jscript")
1198                         javascript = false;
1199                 }
1200             }
1201
1202             RefPtr<Node> n = processToken();
1203
1204             if ((tagName == preTag || tagName == listingTag) && !inViewSourceMode()) {
1205                 if (beginTag)
1206                     state.setDiscardLF(true); // Discard the first LF after we open a pre.
1207             } else if (tagName == scriptTag) {
1208                 ASSERT(!scriptNode);
1209                 scriptNode = n;
1210                 if (beginTag) {
1211                     searchStopper = scriptEnd;
1212                     searchStopperLen = 8;
1213                     state.setInScript(true);
1214                     state = parseSpecial(src, state);
1215                 } else if (isSelfClosingScript) { // Handle <script src="foo"/>
1216                     state.setInScript(true);
1217                     state = scriptHandler(state);
1218                 }
1219             } else if (tagName == styleTag) {
1220                 if (beginTag) {
1221                     searchStopper = styleEnd;
1222                     searchStopperLen = 7;
1223                     state.setInStyle(true);
1224                     state = parseSpecial(src, state);
1225                 }
1226             } else if (tagName == textareaTag) {
1227                 if (beginTag) {
1228                     searchStopper = textareaEnd;
1229                     searchStopperLen = 10;
1230                     state.setInTextArea(true);
1231                     state = parseSpecial(src, state);
1232                 }
1233             } else if (tagName == titleTag) {
1234                 if (beginTag) {
1235                     searchStopper = titleEnd;
1236                     searchStopperLen = 7;
1237                     State savedState = state;
1238                     SegmentedString savedSrc = src;
1239                     long savedLineno = lineno;
1240                     state.setInTitle(true);
1241                     state = parseSpecial(src, state);
1242                     if (state.inTitle() && src.isEmpty()) {
1243                         // We just ate the rest of the document as the title #text node!
1244                         // Reset the state then retokenize without special title handling.
1245                         // Let the parser clean up the missing </title> tag.
1246                         // FIXME: This is incorrect, because src.isEmpty() doesn't mean we're
1247                         // at the end of the document unless noMoreData is also true. We need
1248                         // to detect this case elsewhere, and save the state somewhere other
1249                         // than a local variable.
1250                         state = savedState;
1251                         src = savedSrc;
1252                         lineno = savedLineno;
1253                         scriptCodeSize = 0;
1254                     }
1255                 }
1256             } else if (tagName == xmpTag) {
1257                 if (beginTag) {
1258                     searchStopper = xmpEnd;
1259                     searchStopperLen = 5;
1260                     state.setInXmp(true);
1261                     state = parseSpecial(src, state);
1262                 }
1263             } else if (tagName == selectTag)
1264                 state.setInSelect(beginTag);
1265             else if (tagName == plaintextTag)
1266                 state.setInPlainText(beginTag);
1267             m_cBufferPos = cBufferPos;
1268             return state; // Finished parsing tag!
1269         }
1270         } // end switch
1271     }
1272     m_cBufferPos = cBufferPos;
1273     return state;
1274 }
1275
1276 inline bool HTMLTokenizer::continueProcessing(int& processedCount, double startTime, State &state)
1277 {
1278     // We don't want to be checking elapsed time with every character, so we only check after we've
1279     // processed a certain number of characters.
1280     bool allowedYield = state.allowYield();
1281     state.setAllowYield(false);
1282     if (!state.loadingExtScript() && !state.forceSynchronous() && !m_executingScript && (processedCount > TOKENIZER_CHUNK_SIZE || allowedYield)) {
1283         processedCount = 0;
1284         if (currentTime() - startTime > tokenizerTimeDelay) {
1285             /* FIXME: We'd like to yield aggressively to give stylesheets the opportunity to
1286                load, but this hurts overall performance on slower machines.  For now turn this
1287                off.
1288             || (!m_doc->haveStylesheetsLoaded() && 
1289                 (m_doc->documentElement()->id() != ID_HTML || m_doc->body()))) {*/
1290             // Schedule the timer to keep processing as soon as possible.
1291             m_timer.startOneShot(0);
1292 #if INSTRUMENT_LAYOUT_SCHEDULING
1293             if (currentTime() - startTime > tokenizerTimeDelay)
1294                 printf("Deferring processing of data because 500ms elapsed away from event loop.\n");
1295 #endif
1296             return false;
1297         }
1298     }
1299     
1300     processedCount++;
1301     return true;
1302 }
1303
1304 bool HTMLTokenizer::write(const SegmentedString &str, bool appendData)
1305 {
1306 #ifdef TOKEN_DEBUG
1307     kdDebug( 6036 ) << this << " Tokenizer::write(\"" << str.toString() << "\"," << appendData << ")" << endl;
1308 #endif
1309
1310     if (!buffer)
1311         return false;
1312     
1313     if (m_parserStopped)
1314         return false;
1315
1316     if ( ( m_executingScript && appendData ) || !pendingScripts.isEmpty() ) {
1317         // don't parse; we will do this later
1318         if (currentPrependingSrc) {
1319             currentPrependingSrc->append(str);
1320         } else {
1321             pendingSrc.append(str);
1322         }
1323         return false;
1324     }
1325     
1326     if (!src.isEmpty())
1327         src.append(str);
1328     else
1329         setSrc(str);
1330
1331     // Once a timer is set, it has control of when the tokenizer continues.
1332     if (m_timer.isActive())
1333         return false;
1334
1335     bool wasInWrite = inWrite;
1336     inWrite = true;
1337     
1338 #if INSTRUMENT_LAYOUT_SCHEDULING
1339     if (!m_doc->ownerElement())
1340         printf("Beginning write at time %d\n", m_doc->elapsedTime());
1341 #endif
1342     
1343     int processedCount = 0;
1344     double startTime = currentTime();
1345
1346     Frame *frame = m_doc->frame();
1347
1348     State state = m_state;
1349
1350     while (!src.isEmpty() && (!frame || !frame->isScheduledLocationChangePending())) {
1351         if (!continueProcessing(processedCount, startTime, state))
1352             break;
1353
1354         // do we need to enlarge the buffer?
1355         checkBuffer();
1356
1357         UChar cc = *src;
1358
1359         bool wasSkipLF = state.skipLF();
1360         if (wasSkipLF)
1361             state.setSkipLF(false);
1362
1363         if (wasSkipLF && (cc == '\n'))
1364             ++src;
1365         else if (state.needsSpecialWriteHandling()) {
1366             // it's important to keep needsSpecialWriteHandling with the flags this block tests
1367             if (state.hasEntityState())
1368                 state = parseEntity(src, dest, state, m_cBufferPos, false, state.hasTagState());
1369             else if (state.inPlainText())
1370                 state = parseText(src, state);
1371             else if (state.inAnySpecial())
1372                 state = parseSpecial(src, state);
1373             else if (state.inComment())
1374                 state = parseComment(src, state);
1375             else if (state.inServer())
1376                 state = parseServer(src, state);
1377             else if (state.inProcessingInstruction())
1378                 state = parseProcessingInstruction(src, state);
1379             else if (state.hasTagState())
1380                 state = parseTag(src, state);
1381             else if (state.startTag()) {
1382                 state.setStartTag(false);
1383                 
1384                 switch(cc) {
1385                 case '/':
1386                     break;
1387                 case '!': {
1388                     // <!-- comment -->
1389                     searchCount = 1; // Look for '<!--' sequence to start comment
1390                     
1391                     break;
1392                 }
1393                 case '?': {
1394                     // xml processing instruction
1395                     state.setInProcessingInstruction(true);
1396                     tquote = NoQuote;
1397                     state = parseProcessingInstruction(src, state);
1398                     continue;
1399
1400                     break;
1401                 }
1402                 case '%':
1403                     if (!brokenServer) {
1404                         // <% server stuff, handle as comment %>
1405                         state.setInServer(true);
1406                         tquote = NoQuote;
1407                         state = parseServer(src, state);
1408                         continue;
1409                     }
1410                     // else fall through
1411                 default: {
1412                     if( ((cc >= 'a') && (cc <= 'z')) || ((cc >= 'A') && (cc <= 'Z'))) {
1413                         // Start of a Start-Tag
1414                     } else {
1415                         // Invalid tag
1416                         // Add as is
1417                         *dest = '<';
1418                         dest++;
1419                         continue;
1420                     }
1421                 }
1422                 }; // end case
1423
1424                 processToken();
1425
1426                 m_cBufferPos = 0;
1427                 state.setTagState(TagName);
1428                 state = parseTag(src, state);
1429             }
1430         } else if (cc == '&' && !src.escaped()) {
1431             ++src;
1432             state = parseEntity(src, dest, state, m_cBufferPos, true, state.hasTagState());
1433         } else if (cc == '<' && !src.escaped()) {
1434             tagStartLineno = lineno+src.lineCount();
1435             ++src;
1436             state.setStartTag(true);
1437         } else if (cc == '\n' || cc == '\r') {
1438             if (state.discardLF())
1439                 // Ignore this LF
1440                 state.setDiscardLF(false); // We have discarded 1 LF
1441             else
1442                 // Process this LF
1443                 *dest++ = '\n';
1444             
1445             /* Check for MS-DOS CRLF sequence */
1446             if (cc == '\r')
1447                 state.setSkipLF(true);
1448             ++src;
1449         } else {
1450             state.setDiscardLF(false);
1451             *dest++ = *src;
1452             ++src;
1453         }
1454     }
1455     
1456 #if INSTRUMENT_LAYOUT_SCHEDULING
1457     if (!m_doc->ownerElement())
1458         printf("Ending write at time %d\n", m_doc->elapsedTime());
1459 #endif
1460     
1461     inWrite = wasInWrite;
1462
1463     m_state = state;
1464
1465     if (noMoreData && !inWrite && !state.loadingExtScript() && !m_executingScript && !m_timer.isActive()) {
1466         end(); // this actually causes us to be deleted
1467         return true;
1468     }
1469     return false;
1470 }
1471
1472 void HTMLTokenizer::stopParsing()
1473 {
1474     Tokenizer::stopParsing();
1475     m_timer.stop();
1476
1477     // The part needs to know that the tokenizer has finished with its data,
1478     // regardless of whether it happened naturally or due to manual intervention.
1479     if (!m_fragment && m_doc->frame())
1480         m_doc->frame()->tokenizerProcessedData();
1481 }
1482
1483 bool HTMLTokenizer::processingData() const
1484 {
1485     return m_timer.isActive();
1486 }
1487
1488 void HTMLTokenizer::timerFired(Timer<HTMLTokenizer>*)
1489 {
1490 #if INSTRUMENT_LAYOUT_SCHEDULING
1491     if (!m_doc->ownerElement())
1492         printf("Beginning timer write at time %d\n", m_doc->elapsedTime());
1493 #endif
1494
1495     if (m_doc->view() && m_doc->view()->layoutPending() && !m_doc->minimumLayoutDelay()) {
1496         // Restart the timer and let layout win.  This is basically a way of ensuring that the layout
1497         // timer has higher priority than our timer.
1498         m_timer.startOneShot(0);
1499         return;
1500     }
1501     
1502     RefPtr<Frame> frame = m_fragment ? 0 : m_doc->frame();
1503
1504     // Invoke write() as though more data came in.
1505     bool didCallEnd = write(SegmentedString(), true);
1506   
1507     // If we called end() during the write,  we need to let WebKit know that we're done processing the data.
1508     if (didCallEnd && frame)
1509         frame->tokenizerProcessedData();
1510 }
1511
1512 void HTMLTokenizer::end()
1513 {
1514     ASSERT(!m_timer.isActive());
1515     m_timer.stop(); // Only helps if assertion above fires, but do it anyway.
1516
1517     if (buffer) {
1518         // parseTag is using the buffer for different matters
1519         if (!m_state.hasTagState())
1520             processToken();
1521
1522         fastFree(scriptCode);
1523         scriptCode = 0;
1524         scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
1525
1526         fastFree(buffer);
1527         buffer = 0;
1528     }
1529
1530     if (!inViewSourceMode())
1531         parser->finished();
1532     else
1533         m_doc->finishedParsing();
1534 }
1535
1536 void HTMLTokenizer::finish()
1537 {
1538     // do this as long as we don't find matching comment ends
1539     while((m_state.inComment() || m_state.inServer()) && scriptCode && scriptCodeSize) {
1540         // we've found an unmatched comment start
1541         if (m_state.inComment())
1542             brokenComments = true;
1543         else
1544             brokenServer = true;
1545         checkScriptBuffer();
1546         scriptCode[scriptCodeSize] = 0;
1547         scriptCode[scriptCodeSize + 1] = 0;
1548         int pos;
1549         DeprecatedString food;
1550         if (m_state.inScript() || m_state.inStyle())
1551             food.setUnicode(reinterpret_cast<QChar*>(scriptCode), scriptCodeSize);
1552         else if (m_state.inServer()) {
1553             food = "<";
1554             food += DeprecatedString(reinterpret_cast<QChar*>(scriptCode), scriptCodeSize);
1555         } else {
1556             pos = QConstString(reinterpret_cast<QChar*>(scriptCode), scriptCodeSize).string().find('>');
1557             food.setUnicode(reinterpret_cast<QChar*>(scriptCode) + pos + 1, scriptCodeSize - pos - 1); // deep copy
1558         }
1559         fastFree(scriptCode);
1560         scriptCode = 0;
1561         scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
1562         m_state.setInComment(false);
1563         m_state.setInServer(false);
1564         if (!food.isEmpty())
1565             write(food, true);
1566     }
1567     // this indicates we will not receive any more data... but if we are waiting on
1568     // an external script to load, we can't finish parsing until that is done
1569     noMoreData = true;
1570     if (!inWrite && !m_state.loadingExtScript() && !m_executingScript && !m_timer.isActive())
1571         end(); // this actually causes us to be deleted
1572 }
1573
1574 PassRefPtr<Node> HTMLTokenizer::processToken()
1575 {
1576     KJSProxy* jsProxy = (!m_fragment && m_doc->frame()) ? m_doc->frame()->jScript() : 0;
1577     if (jsProxy)
1578         jsProxy->setEventHandlerLineno(tagStartLineno);
1579     if (dest > buffer) {
1580 #ifdef TOKEN_DEBUG
1581         if(currToken.tagName.length()) {
1582             qDebug( "unexpected token: %s, str: *%s*", currToken.tagName.deprecatedString().latin1(),QConstString( buffer,dest-buffer ).deprecatedString().latin1() );
1583             ASSERT(0);
1584         }
1585
1586 #endif
1587         currToken.text = new StringImpl( buffer, dest - buffer );
1588         if (currToken.tagName != commentAtom)
1589             currToken.tagName = textAtom;
1590     } else if (currToken.tagName == nullAtom) {
1591         currToken.reset();
1592         if (jsProxy)
1593             jsProxy->setEventHandlerLineno(lineno+src.lineCount());
1594         return 0;
1595     }
1596
1597     dest = buffer;
1598
1599 #ifdef TOKEN_DEBUG
1600     DeprecatedString name = currToken.tagName.deprecatedString();
1601     DeprecatedString text;
1602     if(currToken.text)
1603         text = QConstString(currToken.text->unicode(), currToken.text->length()).deprecatedString();
1604
1605     kdDebug( 6036 ) << "Token --> " << name << endl;
1606     if (currToken.flat)
1607         kdDebug( 6036 ) << "Token is FLAT!" << endl;
1608     if(!text.isNull())
1609         kdDebug( 6036 ) << "text: \"" << text << "\"" << endl;
1610     unsigned l = currToken.attrs ? currToken.attrs->length() : 0;
1611     if(l) {
1612         kdDebug( 6036 ) << "Attributes: " << l << endl;
1613         for (unsigned i = 0; i < l; ++i) {
1614             Attribute* c = currToken.attrs->attributeItem(i);
1615             kdDebug( 6036 ) << "    " << c->localName().deprecatedString()
1616                             << "=\"" << c->value().deprecatedString() << "\"" << endl;
1617         }
1618     }
1619     kdDebug( 6036 ) << endl;
1620 #endif
1621
1622     RefPtr<Node> n;
1623     
1624     if (!m_parserStopped) {
1625         if (inViewSourceMode())
1626             static_cast<HTMLViewSourceDocument*>(m_doc)->addViewSourceToken(&currToken);
1627         else
1628             // pass the token over to the parser, the parser DOES NOT delete the token
1629             n = parser->parseToken(&currToken);
1630     }
1631     currToken.reset();
1632     if (jsProxy)
1633         jsProxy->setEventHandlerLineno(0);
1634
1635     return n.release();
1636 }
1637
1638 HTMLTokenizer::~HTMLTokenizer()
1639 {
1640     ASSERT(!inWrite);
1641     reset();
1642     delete parser;
1643 }
1644
1645
1646 void HTMLTokenizer::enlargeBuffer(int len)
1647 {
1648     int newSize = max(size * 2, size + len);
1649     int oldOffset = dest - buffer;
1650     buffer = static_cast<UChar*>(fastRealloc(buffer, newSize * sizeof(UChar)));
1651     dest = buffer + oldOffset;
1652     size = newSize;
1653 }
1654
1655 void HTMLTokenizer::enlargeScriptBuffer(int len)
1656 {
1657     int newSize = max(scriptCodeMaxSize * 2, scriptCodeMaxSize + len);
1658     scriptCode = static_cast<UChar*>(fastRealloc(scriptCode, newSize * sizeof(UChar)));
1659     scriptCodeMaxSize = newSize;
1660 }
1661
1662 void HTMLTokenizer::notifyFinished(CachedObject*)
1663 {
1664 #if INSTRUMENT_LAYOUT_SCHEDULING
1665     if (!m_doc->ownerElement())
1666         printf("script loaded at %d\n", m_doc->elapsedTime());
1667 #endif
1668
1669     ASSERT(!pendingScripts.isEmpty());
1670     bool finished = false;
1671     while (!finished && pendingScripts.head()->isLoaded()) {
1672 #ifdef TOKEN_DEBUG
1673         kdDebug( 6036 ) << "Finished loading an external script" << endl;
1674 #endif
1675         CachedScript* cs = pendingScripts.dequeue();
1676         ASSERT(cs->accessCount() > 0);
1677
1678         String scriptSource = cs->script();
1679 #ifdef TOKEN_DEBUG
1680         kdDebug( 6036 ) << "External script is:" << endl << scriptSource.deprecatedString() << endl;
1681 #endif
1682         setSrc(SegmentedString());
1683
1684         // make sure we forget about the script before we execute the new one
1685         // infinite recursion might happen otherwise
1686         DeprecatedString cachedScriptUrl( cs->url().deprecatedString() );
1687         bool errorOccurred = cs->errorOccurred();
1688         cs->deref(this);
1689         RefPtr<Node> n = scriptNode;
1690         scriptNode = 0;
1691
1692 #if INSTRUMENT_LAYOUT_SCHEDULING
1693         if (!m_doc->ownerElement())
1694             printf("external script beginning execution at %d\n", m_doc->elapsedTime());
1695 #endif
1696
1697         if (errorOccurred)
1698             EventTargetNodeCast(n.get())->dispatchHTMLEvent(errorEvent, true, false);
1699         else {
1700             m_state = scriptExecution(scriptSource.deprecatedString(), m_state, cachedScriptUrl);
1701             EventTargetNodeCast(n.get())->dispatchHTMLEvent(loadEvent, false, false);
1702         }
1703
1704         // The state of pendingScripts.isEmpty() can change inside the scriptExecution()
1705         // call above, so test afterwards.
1706         finished = pendingScripts.isEmpty();
1707         if (finished) {
1708             m_state.setLoadingExtScript(false);
1709 #if INSTRUMENT_LAYOUT_SCHEDULING
1710             if (!m_doc->ownerElement())
1711                 printf("external script finished execution at %d\n", m_doc->elapsedTime());
1712 #endif
1713         }
1714
1715         // 'm_requestingScript' is true when we are called synchronously from
1716         // scriptHandler(). In that case scriptHandler() will take care
1717         // of pendingSrc.
1718         if (!m_requestingScript) {
1719             SegmentedString rest = pendingSrc;
1720             pendingSrc.clear();
1721             write(rest, false);
1722             // we might be deleted at this point, do not
1723             // access any members.
1724         }
1725     }
1726 }
1727
1728 bool HTMLTokenizer::isWaitingForScripts() const
1729 {
1730     return m_state.loadingExtScript();
1731 }
1732
1733 void HTMLTokenizer::setSrc(const SegmentedString &source)
1734 {
1735     lineno += src.lineCount();
1736     src = source;
1737     src.resetLineCount();
1738 }
1739
1740 void parseHTMLDocumentFragment(const String &source, DocumentFragment *fragment)
1741 {
1742     HTMLTokenizer tok(fragment);
1743     tok.setForceSynchronous(true);
1744     tok.write(source.deprecatedString(), true);
1745     tok.finish();
1746     ASSERT(!tok.processingData());      // make sure we're done (see 3963151)
1747 }
1748
1749 UChar decodeNamedEntity(const char* name)
1750 {
1751     const Entity* e = findEntity(name, strlen(name));
1752     return e ? e->code : 0;
1753 }
1754
1755 }