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