Reviewed by Ken.
[WebKit-https.git] / WebCore / khtml / 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 Apple Computer, Inc.
11
12     This library is free software; you can redistribute it and/or
13     modify it under the terms of the GNU Library General Public
14     License as published by the Free Software Foundation; either
15     version 2 of the License, or (at your option) any later version.
16
17     This library is distributed in the hope that it will be useful,
18     but WITHOUT ANY WARRANTY; without even the implied warranty of
19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20     Library General Public License for more details.
21
22     You should have received a copy of the GNU Library General Public License
23     along with this library; see the file COPYING.LIB.  If not, write to
24     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
25     Boston, MA 02111-1307, USA.
26 */
27 //----------------------------------------------------------------------------
28 //
29 // KDE HTML Widget - Tokenizers
30
31 //#define TOKEN_DEBUG 1
32 //#define TOKEN_DEBUG 2
33
34 #ifdef HAVE_CONFIG_H
35 #include "config.h"
36 #endif
37
38 //#include <string.h>
39 #include "html/htmltokenizer.h"
40 #include "html/html_documentimpl.h"
41 #include "html/htmlparser.h"
42 #include "html/dtd.h"
43
44 #include "misc/loader.h"
45 #include "misc/htmlhashes.h"
46
47 #include "khtmlview.h"
48 #include "khtml_part.h"
49 #include "xml/dom_docimpl.h"
50 #include "css/csshelper.h"
51 #include "ecma/kjs_proxy.h"
52 #include <kcharsets.h>
53 #include <kglobal.h>
54 #include <ctype.h>
55 #include <assert.h>
56 #include <qvariant.h>
57 #include <kdebug.h>
58 #include <stdlib.h>
59
60 using DOM::AtomicString;
61 using DOM::AttributeImpl;
62 using DOM::DOMString;
63 using DOM::DOMStringImpl;
64 using DOM::DocumentImpl;
65 using DOM::FORBIDDEN;
66 using DOM::Node;
67 using DOM::emptyAtom;
68 using DOM::endTag;
69
70 // turn off inlining to void warning with newer gcc
71 #undef __inline
72 #define __inline
73 #include "kentities.c"
74 #undef __inline
75
76 // #define INSTRUMENT_LAYOUT_SCHEDULING 1
77
78 #define TOKENIZER_CHUNK_SIZE  4096
79
80 // FIXME: We would like this constant to be 200ms.  Yielding more aggressively results in increased
81 // responsiveness and better incremental rendering.  It slows down overall page-load on slower machines,
82 // though, so for now we set a value of 500.
83 #define TOKENIZER_TIME_DELAY  500
84
85 namespace khtml {
86
87 static const char commentStart [] = "<!--";
88 static const char scriptEnd [] = "</script";
89 static const char xmpEnd [] = "</xmp";
90 static const char styleEnd [] =  "</style";
91 static const char textareaEnd [] = "</textarea";
92 static const char titleEnd [] = "</title";
93
94 #define KHTML_ALLOC_QCHAR_VEC( N ) (QChar*) malloc( sizeof(QChar)*( N ) )
95 #define KHTML_REALLOC_QCHAR_VEC(P, N ) (QChar*) P = realloc(p, sizeof(QChar)*( N ))
96 #define KHTML_DELETE_QCHAR_VEC( P ) free((char*)( P ))
97
98 // Full support for MS Windows extensions to Latin-1.
99 // Technically these extensions should only be activated for pages
100 // marked "windows-1252" or "cp1252", but
101 // in the standard Microsoft way, these extensions infect hundreds of thousands
102 // of web pages.  Note that people with non-latin-1 Microsoft extensions
103 // are SOL.
104 //
105 // See: http://www.microsoft.com/globaldev/reference/WinCP.asp
106 //      http://www.bbsinc.com/iso8859.html
107 //      http://www.obviously.com/
108 //
109 // There may be better equivalents
110
111 #if APPLE_CHANGES
112
113 // Note that we have more Unicode characters than Qt, so we use the
114 // official mapping table from the Unicode 2.0 standard here instead of
115 // one with hacks to avoid certain Unicode characters. Also, we don't
116 // need the unrelated hacks to avoid Unicode characters that are in the
117 // original version.
118
119 // We need this for entities at least. For non-entity text, we could
120 // handle this in the text codec.
121
122 // To cover non-entity text, I think this function would need to be called
123 // in more places. There seem to be many places that don't call fixUpChar.
124
125 inline void fixUpChar(QChar& c) {
126     switch (c.unicode()) {
127         case 0x0080: c = 0x20AC; break;
128         case 0x0081: break;
129         case 0x0082: c = 0x201A; break;
130         case 0x0083: c = 0x0192; break;
131         case 0x0084: c = 0x201E; break;
132         case 0x0085: c = 0x2026; break;
133         case 0x0086: c = 0x2020; break;
134         case 0x0087: c = 0x2021; break;
135         case 0x0088: c = 0x02C6; break;
136         case 0x0089: c = 0x2030; break;
137         case 0x008A: c = 0x0160; break;
138         case 0x008B: c = 0x2039; break;
139         case 0x008C: c = 0x0152; break;
140         case 0x008D: break;
141         case 0x008E: c = 0x017D; break;
142         case 0x008F: break;
143         case 0x0090: break;
144         case 0x0091: c = 0x2018; break;
145         case 0x0092: c = 0x2019; break;
146         case 0x0093: c = 0x201C; break;
147         case 0x0094: c = 0x201D; break;
148         case 0x0095: c = 0x2022; break;
149         case 0x0096: c = 0x2013; break;
150         case 0x0097: c = 0x2014; break;
151         case 0x0098: c = 0x02DC; break;
152         case 0x0099: c = 0x2122; break;
153         case 0x009A: c = 0x0161; break;
154         case 0x009B: c = 0x203A; break;
155         case 0x009C: c = 0x0153; break;
156         case 0x009D: break;
157         case 0x009E: c = 0x017E; break;
158         case 0x009F: c = 0x0178; break;
159     }
160 }
161
162 #else // APPLE_CHANGES
163
164 #define fixUpChar(x) \
165             if (!(x).row() ) { \
166                 switch ((x).cell()) \
167                 { \
168                 /* ALL of these should be changed to Unicode SOON */ \
169                 case 0x80: (x) = 0x20ac; break; \
170                 case 0x82: (x) = ',';    break; \
171                 case 0x83: (x) = 0x0192; break; \
172                 case 0x84: (x) = '"';    break; \
173                 case 0x85: (x) = 0x2026; break; \
174                 case 0x86: (x) = 0x2020; break; \
175                 case 0x87: (x) = 0x2021; break; \
176                 case 0x88: (x) = 0x02C6; break; \
177                 case 0x89: (x) = 0x2030; break; \
178                 case 0x8A: (x) = 0x0160; break; \
179                 case 0x8b: (x) = '<';    break; \
180                 case 0x8C: (x) = 0x0152; break; \
181 \
182                 case 0x8E: (x) = 0x017D; break; \
183 \
184 \
185                 case 0x91: (x) = '\'';   break; \
186                 case 0x92: (x) = '\'';   break; \
187                 case 0x93: (x) = '"';    break; \
188                 case 0x94: (x) = '"';    break; \
189                 case 0x95: (x) = '*';    break; \
190                 case 0x96: (x) = '-';    break; \
191                 case 0x97: (x) = '-';    break; \
192                 case 0x98: (x) = '~';    break; \
193                 case 0x99: (x) = 0x2122; break; \
194                 case 0x9A: (x) = 0x0161; break; \
195                 case 0x9b: (x) = '>';    break; \
196                 case 0x9C: (x) = 0x0153; break; \
197 \
198                 case 0x9E: (x) = 0x017E; break; \
199                 case 0x9F: (x) = 0x0178; break; \
200                 /* This one should die */ \
201                 case 0xb7: (x) = '*';    break; \
202                 default: break; \
203                 } \
204             } \
205             else { \
206                 /* These should all die sooner rather than later */ \
207                 switch( (x).unicode() ) { \
208                 case 0x2013: (x) = '-'; break; \
209                 case 0x2014: (x) = '-'; break; \
210                 case 0x2018: (x) = '\''; break; \
211                 case 0x2019: (x) = '\''; break; \
212                 case 0x201c: (x) = '"'; break; \
213                 case 0x201d: (x) = '"'; break; \
214                 case 0x2022: (x) = '*'; break; \
215                 case 0x2122: (x) = 0x2122; break; \
216                 default: break; \
217                 } \
218             }
219
220 #endif // APPLE_CHANGES
221
222 inline bool tagMatch(const char *s1, const QChar *s2, uint length)
223 {
224     for (uint i = 0; i != length; ++i) {
225         char c1 = s1[i];
226         char uc1 = toupper(c1);
227         QChar c2 = s2[i];
228         if (c1 != c2 && uc1 != c2)
229             return false;
230     }
231     return true;
232 }
233
234 // ----------------------------------------------------------------------------
235
236 HTMLTokenizer::HTMLTokenizer(DOM::DocumentPtr *_doc, KHTMLView *_view, bool includesComments)
237 #ifndef NDEBUG
238     : inWrite(false)
239 #endif
240 {
241     view = _view;
242     buffer = 0;
243     scriptCode = 0;
244     scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
245     charsets = KGlobal::charsets();
246     parser = new KHTMLParser(_view, _doc, includesComments);
247     m_executingScript = 0;
248     loadingExtScript = false;
249     onHold = false;
250     attrNamePresent = false;
251     timerId = 0;
252     includesCommentsInDOM = includesComments;
253     
254     begin();
255 }
256
257 HTMLTokenizer::HTMLTokenizer(DOM::DocumentPtr *_doc, DOM::DocumentFragmentImpl *i, bool includesComments)
258 #ifndef NDEBUG
259     : inWrite(false)
260 #endif
261 {
262     view = 0;
263     buffer = 0;
264     scriptCode = 0;
265     scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
266     charsets = KGlobal::charsets();
267     parser = new KHTMLParser(i, _doc, includesComments);
268     m_executingScript = 0;
269     loadingExtScript = false;
270     onHold = false;
271     timerId = 0;
272     includesCommentsInDOM = includesComments;
273
274     begin();
275 }
276
277 void HTMLTokenizer::reset()
278 {
279     assert(m_executingScript == 0);
280     assert(onHold == false);
281
282     while (!cachedScript.isEmpty())
283         cachedScript.dequeue()->deref(this);
284
285     if ( buffer )
286         KHTML_DELETE_QCHAR_VEC(buffer);
287     buffer = dest = 0;
288     size = 0;
289
290     if ( scriptCode )
291         KHTML_DELETE_QCHAR_VEC(scriptCode);
292     scriptCode = 0;
293     scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
294
295     if (timerId) {
296         killTimer(timerId);
297         timerId = 0;
298     }
299     timerId = 0;
300     allowYield = false;
301
302     currToken.reset();
303 }
304
305 void HTMLTokenizer::begin()
306 {
307     m_executingScript = 0;
308     loadingExtScript = false;
309     onHold = false;
310     reset();
311     size = 254;
312     buffer = KHTML_ALLOC_QCHAR_VEC( 255 );
313     dest = buffer;
314     tag = NoTag;
315     pending = NonePending;
316     discard = NoneDiscard;
317     pre = false;
318     prePos = 0;
319     plaintext = false;
320     xmp = false;
321     processingInstruction = false;
322     script = false;
323     escaped = false;
324     style = false;
325     skipLF = false;
326     select = false;
327     comment = false;
328     server = false;
329     textarea = false;
330     title = false;
331     startTag = false;
332     tquote = NoQuote;
333     searchCount = 0;
334     Entity = NoEntity;
335     loadingExtScript = false;
336     scriptSrc = QString::null;
337     pendingSrc.clear();
338     currentPrependingSrc = 0;
339     noMoreData = false;
340     brokenComments = false;
341     brokenServer = false;
342     lineno = 0;
343     scriptStartLineno = 0;
344     tagStartLineno = 0;
345 }
346
347 void HTMLTokenizer::processListing(TokenizerString list)
348 {
349     bool old_pre = pre;
350     // This function adds the listing 'list' as
351     // preformatted text-tokens to the token-collection
352     // thereby converting TABs.
353     if(!style) pre = true;
354     prePos = 0;
355
356     while ( !list.isEmpty() )
357     {
358         checkBuffer(3*TAB_SIZE);
359
360         if (skipLF && ( *list != '\n' ))
361         {
362             skipLF = false;
363         }
364
365         if (skipLF)
366         {
367             skipLF = false;
368             ++list;
369         }
370         else if (( *list == '\n' ) || ( *list == '\r' ))
371         {
372             if (discard == LFDiscard)
373             {
374                 // Ignore this LF
375                 discard = NoneDiscard; // We have discarded 1 LF
376             }
377             else
378             {
379                 // Process this LF
380                 if (pending)
381                     addPending();
382                 pending = LFPending;
383             }
384             /* Check for MS-DOS CRLF sequence */
385             if (*list == '\r')
386             {
387                 skipLF = true;
388             }
389             ++list;
390         }
391         else if (( *list == ' ' ) || ( *list == '\t'))
392         {
393             if (pending)
394                 addPending();
395             if (*list == ' ')
396                 pending = SpacePending;
397             else
398                 pending = TabPending;
399
400             ++list;
401         }
402         else
403         {
404             discard = NoneDiscard;
405             if (pending)
406                 addPending();
407
408             prePos++;
409             *dest++ = *list;
410             ++list;
411         }
412
413     }
414
415     if (pending)
416         addPending();
417
418     prePos = 0;
419
420     pre = old_pre;
421 }
422
423 void HTMLTokenizer::parseSpecial(TokenizerString &src)
424 {
425     assert( textarea || title || !Entity );
426     assert( !tag );
427     assert( xmp+textarea+title+style+script == 1 );
428     if (script)
429         scriptStartLineno = lineno+src.lineCount();
430
431     if ( comment ) parseComment( src );
432
433     while ( !src.isEmpty() ) {
434         checkScriptBuffer();
435         unsigned char ch = src->latin1();
436         if ( !scriptCodeResync && !brokenComments && !textarea && !xmp && !title && ch == '-' && scriptCodeSize >= 3 && !src.escaped() && scriptCode[scriptCodeSize-3] == '<' && scriptCode[scriptCodeSize-2] == '!' && scriptCode[scriptCodeSize-1] == '-' ) {
437             comment = true;
438             parseComment( src );
439             continue;
440         }
441         if ( scriptCodeResync && !tquote && ( ch == '>' ) ) {
442             ++src;
443             scriptCodeSize = scriptCodeResync-1;
444             scriptCodeResync = 0;
445             scriptCode[ scriptCodeSize ] = scriptCode[ scriptCodeSize + 1 ] = 0;
446             if ( script )
447                 scriptHandler();
448             else {
449                 processListing(TokenizerString(scriptCode, scriptCodeSize));
450                 processToken();
451                 if ( style )         { currToken.id = ID_STYLE + ID_CLOSE_TAG; }
452                 else if ( textarea ) { currToken.id = ID_TEXTAREA + ID_CLOSE_TAG; }
453                 else if ( title ) { currToken.id = ID_TITLE + ID_CLOSE_TAG; }
454                 else if ( xmp )  { currToken.id = ID_XMP + ID_CLOSE_TAG; }
455                 processToken();
456                 style = script = style = textarea = title = xmp = false;
457                 tquote = NoQuote;
458                 scriptCodeSize = scriptCodeResync = 0;
459             }
460             return;
461         }
462         // possible end of tagname, lets check.
463         if ( !scriptCodeResync && !escaped && !src.escaped() && ( ch == '>' || ch == '/' || ch <= ' ' ) && ch &&
464              scriptCodeSize >= searchStopperLen &&
465              tagMatch( searchStopper, scriptCode+scriptCodeSize-searchStopperLen, searchStopperLen )) {
466             scriptCodeResync = scriptCodeSize-searchStopperLen+1;
467             tquote = NoQuote;
468             continue;
469         }
470         if ( scriptCodeResync && !escaped ) {
471             if(ch == '\"')
472                 tquote = (tquote == NoQuote) ? DoubleQuote : ((tquote == SingleQuote) ? SingleQuote : NoQuote);
473             else if(ch == '\'')
474                 tquote = (tquote == NoQuote) ? SingleQuote : (tquote == DoubleQuote) ? DoubleQuote : NoQuote;
475             else if (tquote != NoQuote && (ch == '\r' || ch == '\n'))
476                 tquote = NoQuote;
477         }
478         escaped = ( !escaped && ch == '\\' );
479         if (!scriptCodeResync && (textarea||title) && !src.escaped() && ch == '&') {
480             QChar *scriptCodeDest = scriptCode+scriptCodeSize;
481             ++src;
482             parseEntity(src,scriptCodeDest,true);
483             scriptCodeSize = scriptCodeDest-scriptCode;
484         }
485         else {
486             scriptCode[scriptCodeSize] = *src;
487             fixUpChar(scriptCode[scriptCodeSize]);
488             ++scriptCodeSize;
489             ++src;
490         }
491     }
492 }
493
494 void HTMLTokenizer::scriptHandler()
495 {
496     // We are inside a <script>
497     bool doScriptExec = false;
498     CachedScript* cs = 0;
499     // don't load external scripts for standalone documents (for now)
500     if (!scriptSrc.isEmpty() && parser->doc()->part()) {
501         // forget what we just got; load from src url instead
502         if ( !parser->skipMode() ) {
503 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
504             if (!parser->doc()->ownerElement())
505                 printf("Requesting script at time %d\n", parser->doc()->elapsedTime());
506 #endif
507             if ( (cs = parser->doc()->docLoader()->requestScript(scriptSrc, scriptSrcCharset) ))
508                 cachedScript.enqueue(cs);
509         }
510         scriptSrc=QString::null;
511     }
512     else {
513 #ifdef TOKEN_DEBUG
514         kdDebug( 6036 ) << "---START SCRIPT---" << endl;
515         kdDebug( 6036 ) << QString(scriptCode, scriptCodeSize) << endl;
516         kdDebug( 6036 ) << "---END SCRIPT---" << endl;
517 #endif
518         // Parse scriptCode containing <script> info
519         doScriptExec = true;
520     }
521     processListing(TokenizerString(scriptCode, scriptCodeSize));
522     QString exScript( buffer, dest-buffer );
523     processToken();
524     currToken.id = ID_SCRIPT + ID_CLOSE_TAG;
525     processToken();
526
527     TokenizerString *savedPrependingSrc = currentPrependingSrc;
528     TokenizerString prependingSrc;
529     currentPrependingSrc = &prependingSrc;
530     if ( !parser->skipMode() ) {
531         if (cs) {
532              //kdDebug( 6036 ) << "cachedscript extern!" << endl;
533              //kdDebug( 6036 ) << "src: *" << QString( src.current(), src.length() ).latin1() << "*" << endl;
534              //kdDebug( 6036 ) << "pending: *" << pendingSrc.latin1() << "*" << endl;
535             if (savedPrependingSrc) {
536                 savedPrependingSrc->append(src);
537             } else {
538                 pendingSrc.prepend(src);
539             }
540             setSrc(TokenizerString());
541             scriptCodeSize = scriptCodeResync = 0;
542             cs->ref(this);
543             // will be 0 if script was already loaded and ref() executed it
544             if (!cachedScript.isEmpty())
545                 loadingExtScript = true;
546         }
547         else if (view && doScriptExec && javascript ) {
548             if (!m_executingScript)
549                 pendingSrc.prepend(src);
550             else
551                 prependingSrc = src;
552             setSrc(TokenizerString());
553             scriptCodeSize = scriptCodeResync = 0;
554             //QTime dt;
555             //dt.start();
556             scriptExecution( exScript, QString::null, scriptStartLineno );
557             //kdDebug( 6036 ) << "script execution time:" << dt.elapsed() << endl;
558         }
559     }
560
561     script = false;
562     scriptCodeSize = scriptCodeResync = 0;
563
564     if ( !m_executingScript && !loadingExtScript ) {
565         // kdDebug( 6036 ) << "adding pending Output to parsed string" << endl;
566         src.append(pendingSrc);
567         pendingSrc.clear();
568     } else if (!prependingSrc.isEmpty()) {
569         // restore first so that the write appends in the right place
570         // (does not hurt to do it again below)
571         currentPrependingSrc = savedPrependingSrc;
572
573         // we need to do this slightly modified bit of one of the write() cases
574         // because we want to prepend to pendingSrc rather than appending
575         // if there's no previous prependingSrc
576         if (loadingExtScript) {
577             if (currentPrependingSrc) {
578                 currentPrependingSrc->append(prependingSrc);
579             } else {
580                 pendingSrc.prepend(prependingSrc);
581             }
582         } else {
583             write(prependingSrc, false);
584         }
585     }
586
587     currentPrependingSrc = savedPrependingSrc;
588 }
589
590 void HTMLTokenizer::scriptExecution( const QString& str, QString scriptURL,
591                                      int baseLine)
592 {
593 #if APPLE_CHANGES
594     if (!view || !view->part())
595         return;
596 #endif
597     bool oldscript = script;
598     m_executingScript++;
599     script = false;
600     QString url;    
601     if (scriptURL.isNull())
602       url = static_cast<DocumentImpl*>(view->part()->document().handle())->URL();
603     else
604       url = scriptURL;
605
606     TokenizerString *savedPrependingSrc = currentPrependingSrc;
607     TokenizerString prependingSrc;
608     currentPrependingSrc = &prependingSrc;
609
610 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
611     if (!parser->doc()->ownerElement())
612         printf("beginning script execution at %d\n", parser->doc()->elapsedTime());
613 #endif
614
615     view->part()->executeScript(url,baseLine,Node(),str);
616
617     allowYield = true;
618
619 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
620     if (!parser->doc()->ownerElement())
621         printf("ending script execution at %d\n", parser->doc()->elapsedTime());
622 #endif
623     
624     m_executingScript--;
625     script = oldscript;
626
627     if ( !m_executingScript && !loadingExtScript ) {
628         // kdDebug( 6036 ) << "adding pending Output to parsed string" << endl;
629         src.append(pendingSrc);
630         pendingSrc.clear();
631     } else if (!prependingSrc.isEmpty()) {
632         // restore first so that the write appends in the right place
633         // (does not hurt to do it again below)
634         currentPrependingSrc = savedPrependingSrc;
635
636         // we need to do this slightly modified bit of one of the write() cases
637         // because we want to prepend to pendingSrc rather than appending
638         // if there's no previous prependingSrc
639         if (loadingExtScript) {
640             if (currentPrependingSrc) {
641                 currentPrependingSrc->append(prependingSrc);
642             } else {
643                 pendingSrc.prepend(prependingSrc);
644             }
645         } else {
646             write(prependingSrc, false);
647         }
648     }
649
650     currentPrependingSrc = savedPrependingSrc;
651 }
652
653 void HTMLTokenizer::parseComment(TokenizerString &src)
654 {
655     checkScriptBuffer(src.length());
656     while ( !src.isEmpty() ) {
657         scriptCode[ scriptCodeSize++ ] = *src;
658 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
659         qDebug("comment is now: *%s*",
660                QConstString((QChar*)src.current(), QMIN(16, src.length())).string().latin1());
661 #endif
662         if (src->unicode() == '>') {
663             bool handleBrokenComments = brokenComments && !(script || style);
664             int endCharsCount = 1; // start off with one for the '>' character
665             if (scriptCodeSize > 2 && scriptCode[scriptCodeSize-3] == '-' && scriptCode[scriptCodeSize-2] == '-') {
666                 endCharsCount = 3;
667             }
668             else if (scriptCodeSize > 3 && scriptCode[scriptCodeSize-4] == '-' && scriptCode[scriptCodeSize-3] == '-' && 
669                 scriptCode[scriptCodeSize-2] == '!') {
670                 // Other browsers will accept --!> as a close comment, even though it's
671                 // not technically valid.
672                 endCharsCount = 4;
673             }
674             if (handleBrokenComments || endCharsCount > 1) {
675                 ++src;
676                 if (!( script || xmp || textarea || style)) {
677                     if (includesCommentsInDOM) {
678                         checkScriptBuffer();
679                         scriptCode[ scriptCodeSize ] = 0;
680                         scriptCode[ scriptCodeSize + 1 ] = 0;
681                         currToken.id = ID_COMMENT;
682                         processListing(TokenizerString(scriptCode, scriptCodeSize - endCharsCount));
683                         processToken();
684                         currToken.id = ID_COMMENT + ID_CLOSE_TAG;
685                         processToken();
686                     }
687                     scriptCodeSize = 0;
688                 }
689                 comment = false;
690                 return; // Finished parsing comment
691             }
692         }
693         ++src;
694     }
695 }
696
697 void HTMLTokenizer::parseServer(TokenizerString &src)
698 {
699     checkScriptBuffer(src.length());
700     while ( !src.isEmpty() ) {
701         scriptCode[ scriptCodeSize++ ] = *src;
702         if (src->unicode() == '>' &&
703             scriptCodeSize > 1 && scriptCode[scriptCodeSize-2] == '%') {
704             ++src;
705             server = false;
706             scriptCodeSize = 0;
707             return; // Finished parsing server include
708         }
709         ++src;
710     }
711 }
712
713 void HTMLTokenizer::parseProcessingInstruction(TokenizerString &src)
714 {
715     char oldchar = 0;
716     while ( !src.isEmpty() )
717     {
718         unsigned char chbegin = src->latin1();
719         if(chbegin == '\'') {
720             tquote = tquote == SingleQuote ? NoQuote : SingleQuote;
721         }
722         else if(chbegin == '\"') {
723             tquote = tquote == DoubleQuote ? NoQuote : DoubleQuote;
724         }
725         // Look for '?>'
726         // some crappy sites omit the "?" before it, so
727         // we look for an unquoted '>' instead. (IE compatible)
728         else if ( chbegin == '>' && ( !tquote || oldchar == '?' ) )
729         {
730             // We got a '?>' sequence
731             processingInstruction = false;
732             ++src;
733             discard=LFDiscard;
734             return; // Finished parsing comment!
735         }
736         ++src;
737         oldchar = chbegin;
738     }
739 }
740
741 void HTMLTokenizer::parseText(TokenizerString &src)
742 {
743     while ( !src.isEmpty() )
744     {
745         // do we need to enlarge the buffer?
746         checkBuffer();
747
748         // ascii is okay because we only do ascii comparisons
749         unsigned char chbegin = src->latin1();
750
751         if (skipLF && ( chbegin != '\n' ))
752         {
753             skipLF = false;
754         }
755
756         if (skipLF)
757         {
758             skipLF = false;
759             ++src;
760         }
761         else if (( chbegin == '\n' ) || ( chbegin == '\r' ))
762         {
763             if (chbegin == '\r')
764                 skipLF = true;
765
766             *dest++ = '\n';
767             ++src;
768         }
769         else {
770             *dest = *src;
771             fixUpChar(*dest);
772             ++dest;
773             ++src;
774         }
775     }
776 }
777
778
779 void HTMLTokenizer::parseEntity(TokenizerString &src, QChar *&dest, bool start)
780 {
781     if( start )
782     {
783         cBufferPos = 0;
784         Entity = SearchEntity;
785         EntityUnicodeValue = 0;
786     }
787
788     while( !src.isEmpty() )
789     {
790         ushort cc = src->unicode();
791         switch(Entity) {
792         case NoEntity:
793             assert(Entity != NoEntity);
794             return;
795         
796         case SearchEntity:
797             if(cc == '#') {
798                 cBuffer[cBufferPos++] = cc;
799                 ++src;
800                 Entity = NumericSearch;
801             }
802             else
803                 Entity = EntityName;
804
805             break;
806
807         case NumericSearch:
808             if(cc == 'x' || cc == 'X') {
809                 cBuffer[cBufferPos++] = cc;
810                 ++src;
811                 Entity = Hexadecimal;
812             }
813             else if(cc >= '0' && cc <= '9')
814                 Entity = Decimal;
815             else
816                 Entity = SearchSemicolon;
817
818             break;
819
820         case Hexadecimal:
821         {
822             int ll = kMin(src.length(), 8);
823             while(ll--) {
824                 QChar csrc(src->lower());
825                 cc = csrc.cell();
826
827                 if(csrc.row() || !((cc >= '0' && cc <= '9') || (cc >= 'a' && cc <= 'f'))) {
828                     break;
829                 }
830                 EntityUnicodeValue = EntityUnicodeValue*16 + (cc - ( cc < 'a' ? '0' : 'a' - 10));
831                 cBuffer[cBufferPos++] = cc;
832                 ++src;
833             }
834             Entity = SearchSemicolon;
835             break;
836         }
837         case Decimal:
838         {
839             int ll = kMin(src.length(), 9-cBufferPos);
840             while(ll--) {
841                 cc = src->cell();
842
843                 if(src->row() || !(cc >= '0' && cc <= '9')) {
844                     Entity = SearchSemicolon;
845                     break;
846                 }
847
848                 EntityUnicodeValue = EntityUnicodeValue * 10 + (cc - '0');
849                 cBuffer[cBufferPos++] = cc;
850                 ++src;
851             }
852             if(cBufferPos == 9)  Entity = SearchSemicolon;
853             break;
854         }
855         case EntityName:
856         {
857             int ll = kMin(src.length(), 9-cBufferPos);
858             while(ll--) {
859                 QChar csrc = *src;
860                 cc = csrc.cell();
861
862                 if(csrc.row() || !((cc >= 'a' && cc <= 'z') ||
863                                    (cc >= '0' && cc <= '9') || (cc >= 'A' && cc <= 'Z'))) {
864                     Entity = SearchSemicolon;
865                     break;
866                 }
867
868                 cBuffer[cBufferPos++] = cc;
869                 ++src;
870             }
871             if(cBufferPos == 9) Entity = SearchSemicolon;
872             if(Entity == SearchSemicolon) {
873                 if(cBufferPos > 1) {
874                     const entity *e = findEntity(cBuffer, cBufferPos);
875                     if(e)
876                         EntityUnicodeValue = e->code;
877
878                     // be IE compatible
879                     if(tag && EntityUnicodeValue > 255 && *src != ';')
880                         EntityUnicodeValue = 0;
881                 }
882             }
883             else
884                 break;
885         }
886         case SearchSemicolon:
887
888             //kdDebug( 6036 ) << "ENTITY " << EntityUnicodeValue << ", " << res << endl;
889
890             // Don't allow surrogate code points, or values that are more than 21 bits.
891             if ((EntityUnicodeValue > 0 && EntityUnicodeValue < 0xD800)
892                     || (EntityUnicodeValue >= 0xE000 && EntityUnicodeValue <= 0x1FFFFF)) {
893             
894                 if (*src == ';')
895                     ++src;
896
897                 if (EntityUnicodeValue <= 0xFFFF) {
898                     QChar c(EntityUnicodeValue);
899                     fixUpChar(c);
900                     checkBuffer();
901                     src.push(c);
902                 } else {
903                     // Convert to UTF-16, using surrogate code points.
904                     QChar c1(0xD800 | (((EntityUnicodeValue >> 16) - 1) << 6) | ((EntityUnicodeValue >> 10) & 0x3F));
905                     QChar c2(0xDC00 | (EntityUnicodeValue & 0x3FF));
906                     checkBuffer(2);
907                     src.push(c1);
908                     src.push(c2);
909                 }
910
911             } else {
912 #ifdef TOKEN_DEBUG
913                 kdDebug( 6036 ) << "unknown entity!" << endl;
914 #endif
915                 checkBuffer(10);
916                 // ignore the sequence, add it to the buffer as plaintext
917                 *dest++ = '&';
918                 for(unsigned int i = 0; i < cBufferPos; i++)
919                     dest[i] = cBuffer[i];
920                 dest += cBufferPos;
921                 if (pre)
922                     prePos += cBufferPos+1;
923             }
924
925             Entity = NoEntity;
926             return;
927         }
928     }
929 }
930
931 void HTMLTokenizer::parseTag(TokenizerString &src)
932 {
933     assert(!Entity );
934
935     while ( !src.isEmpty() )
936     {
937         checkBuffer();
938 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
939         uint l = 0;
940         while(l < src.length() && (*(src.current()+l)).latin1() != '>')
941             l++;
942         qDebug("src is now: *%s*, tquote: %d",
943                QConstString((QChar*)src.current(), l).string().latin1(), tquote);
944 #endif
945         switch(tag) {
946         case NoTag:
947         {
948             return;
949         }
950         case TagName:
951         {
952 #if defined(TOKEN_DEBUG) &&  TOKEN_DEBUG > 1
953             qDebug("TagName");
954 #endif
955             if (searchCount > 0)
956             {
957                 if (*src == commentStart[searchCount])
958                 {
959                     searchCount++;
960                     if (searchCount == 4)
961                     {
962 #ifdef TOKEN_DEBUG
963                         kdDebug( 6036 ) << "Found comment" << endl;
964 #endif
965                         // Found '<!--' sequence
966                         ++src;
967                         dest = buffer; // ignore the previous part of this tag
968                         comment = true;
969                         tag = NoTag;
970
971                         // Fix bug 34302 at kde.bugs.org.  Go ahead and treat
972                         // <!--> as a valid comment, since both mozilla and IE on windows
973                         // can handle this case.  Only do this in quirks mode. -dwh
974                         if (!src.isEmpty() && *src == '>' && parser->doc()->inCompatMode()) {
975                           comment = false;
976                           ++src;
977                           if (!src.isEmpty())
978                               cBuffer[cBufferPos++] = src->cell();
979                         }
980                         else
981                           parseComment(src);
982
983                         return; // Finished parsing tag!
984                     }
985                     // cuts of high part, is okay
986                     cBuffer[cBufferPos++] = src->cell();
987                     ++src;
988                     break;
989                 }
990                 else
991                     searchCount = 0; // Stop looking for '<!--' sequence
992             }
993
994             bool finish = false;
995             unsigned int ll = kMin(src.length(), CBUFLEN-cBufferPos);
996             while(ll--) {
997                 ushort curchar = *src;
998                 if(curchar <= ' ' || curchar == '>' ) {
999                     finish = true;
1000                     break;
1001                 }
1002                 // Use tolower() instead of | 0x20 to lowercase the char because there is no 
1003                 // performance gain in using | 0x20 since tolower() is optimized and 
1004                 // | 0x20 turns characters such as '_' into junk.
1005                 cBuffer[cBufferPos++] = tolower(curchar);
1006                 ++src;
1007             }
1008
1009             // Disadvantage: we add the possible rest of the tag
1010             // as attribute names. ### judge if this causes problems
1011             if(finish || CBUFLEN == cBufferPos) {
1012                 bool beginTag;
1013                 char* ptr = cBuffer;
1014                 unsigned int len = cBufferPos;
1015                 cBuffer[cBufferPos] = '\0';
1016                 if ((cBufferPos > 0) && (*ptr == '/'))
1017                 {
1018                     // End Tag
1019                     beginTag = false;
1020                     ptr++;
1021                     len--;
1022                 }
1023                 else
1024                     // Start Tag
1025                     beginTag = true;
1026
1027                 // Accept empty xml tags like <br/>.  We trim off the "/" so that when we call
1028                 // getTagID, we'll look up "br" as the tag name and not "br/".
1029                 if(len > 1 && ptr[len-1] == '/' )
1030                     ptr[--len] = '\0';
1031
1032                 // Look up the tagID for the specified tag name (now that we've shaved off any
1033                 // invalid / that might have followed the name).
1034                 unsigned short tagID = getTagID(ptr, len);
1035                 if (!tagID) {
1036                     DOMString tagName(ptr);
1037                     DocumentImpl *doc = parser->docPtr()->document();
1038                     if (doc->isValidName(tagName))
1039                         tagID = parser->docPtr()->document()->tagId(0, tagName.implementation(), false);
1040                 }
1041                 if (tagID) {
1042 #ifdef TOKEN_DEBUG
1043                     QCString tmp(ptr, len+1);
1044                     kdDebug( 6036 ) << "found tag id=" << tagID << ": " << tmp.data() << endl;
1045 #endif
1046                     currToken.id = beginTag ? tagID : tagID + ID_CLOSE_TAG;
1047                 }
1048                 dest = buffer;
1049                 tag = SearchAttribute;
1050                 cBufferPos = 0;
1051             }
1052             break;
1053         }
1054         case SearchAttribute:
1055         {
1056 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
1057                 qDebug("SearchAttribute");
1058 #endif
1059             bool atespace = false;
1060             ushort curchar;
1061             while(!src.isEmpty()) {
1062                 curchar = *src;
1063                 if(curchar > ' ') {
1064                     if (curchar == '<' || curchar == '>')
1065                         tag = SearchEnd;
1066                     else if(atespace && (curchar == '\'' || curchar == '"'))
1067                     {
1068                         tag = SearchValue;
1069                         *dest++ = 0;
1070                         attrName = QString::null;
1071                         attrNamePresent = false;
1072                     }
1073                     else
1074                         tag = AttributeName;
1075
1076                     cBufferPos = 0;
1077                     break;
1078                 }
1079                 atespace = true;
1080                 ++src;
1081             }
1082             break;
1083         }
1084         case AttributeName:
1085         {
1086 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
1087                 qDebug("AttributeName");
1088 #endif
1089             ushort curchar;
1090             int ll = kMin(src.length(), CBUFLEN-cBufferPos);
1091
1092             while(ll--) {
1093                 curchar = *src;
1094                 if(curchar <= '>') {
1095                     if(curchar <= ' ' || curchar == '=' || curchar == '>') {
1096                         unsigned int a;
1097                         cBuffer[cBufferPos] = '\0';
1098                         a = getAttrID(cBuffer, cBufferPos);
1099                         if (a)
1100                             attrNamePresent = true;
1101                         else {
1102                             attrName = QString::fromLatin1(QCString(cBuffer, cBufferPos+1).data());
1103                             attrNamePresent = !attrName.isEmpty();
1104
1105                             // This is a deliberate quirk to match Mozilla and Opera.  We have to do this
1106                             // since sites that use the "standards-compliant" path sometimes send
1107                             // <script src="foo.js"/>.  Both Moz and Opera will honor this, despite it
1108                             // being bogus HTML.  They do not honor the "/" for other tags.  This behavior
1109                             // also deviates from WinIE, but in this case we'll just copy Moz and Opera.
1110                             if (currToken.id == ID_SCRIPT && curchar == '>' &&
1111                                 attrName == "/")
1112                                 currToken.flat = true;
1113                         }
1114                         
1115                         dest = buffer;
1116                         *dest++ = a;
1117 #ifdef TOKEN_DEBUG
1118                         if (!a || (cBufferPos && *cBuffer == '!'))
1119                             kdDebug( 6036 ) << "Unknown attribute: *" << QCString(cBuffer, cBufferPos+1).data() << "*" << endl;
1120                         else
1121                             kdDebug( 6036 ) << "Known attribute: " << QCString(cBuffer, cBufferPos+1).data() << endl;
1122 #endif
1123
1124                         tag = SearchEqual;
1125                         break;
1126                     }
1127                 }
1128                 // Use tolower() instead of | 0x20 to lowercase the char because there is no 
1129                 // performance gain in using | 0x20 since tolower() is optimized and 
1130                 // | 0x20 turns characters such as '_' into junk.
1131                 cBuffer[cBufferPos++] = tolower(curchar);
1132                 ++src;
1133             }
1134             if ( cBufferPos == CBUFLEN ) {
1135                 cBuffer[cBufferPos] = '\0';
1136                 attrName = QString::fromLatin1(QCString(cBuffer, cBufferPos+1).data());
1137                 attrNamePresent = !attrName.isEmpty();
1138                 dest = buffer;
1139                 *dest++ = 0;
1140                 tag = SearchEqual;
1141             }
1142             break;
1143         }
1144         case SearchEqual:
1145         {
1146 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
1147                 qDebug("SearchEqual");
1148 #endif
1149             ushort curchar;
1150             bool atespace = false;
1151             while(!src.isEmpty()) {
1152                 curchar = src->unicode();
1153                 if(curchar > ' ') {
1154                     if(curchar == '=') {
1155 #ifdef TOKEN_DEBUG
1156                         kdDebug(6036) << "found equal" << endl;
1157 #endif
1158                         tag = SearchValue;
1159                         ++src;
1160                     }
1161                     else if(atespace && (curchar == '\'' || curchar == '"'))
1162                     {
1163                         tag = SearchValue;
1164                         *dest++ = 0;
1165                         attrName = QString::null;
1166                         attrNamePresent = false;
1167                     }
1168                     else {
1169                         currToken.addAttribute(parser->docPtr()->document(), buffer, attrName, emptyAtom);
1170                         dest = buffer;
1171                         tag = SearchAttribute;
1172                     }
1173                     break;
1174                 }
1175                 atespace = true;
1176                 ++src;
1177             }
1178             break;
1179         }
1180         case SearchValue:
1181         {
1182             ushort curchar;
1183             while(!src.isEmpty()) {
1184                 curchar = src->unicode();
1185                 if(curchar > ' ') {
1186                     if(( curchar == '\'' || curchar == '\"' )) {
1187                         tquote = curchar == '\"' ? DoubleQuote : SingleQuote;
1188                         tag = QuotedValue;
1189                         ++src;
1190                     } else
1191                         tag = Value;
1192
1193                     break;
1194                 }
1195                 ++src;
1196             }
1197             break;
1198         }
1199         case QuotedValue:
1200         {
1201 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
1202                 qDebug("QuotedValue");
1203 #endif
1204             ushort curchar;
1205             while(!src.isEmpty()) {
1206                 checkBuffer();
1207
1208                 curchar = src->unicode();
1209                 if (curchar == '>' && !attrNamePresent) {
1210                     // Handle a case like <img '>.  Just go ahead and be willing
1211                     // to close the whole tag.  Don't consume the character and
1212                     // just go back into SearchEnd while ignoring the whole
1213                     // value.
1214                     // FIXME: Note that this is actually not a very good solution. It's
1215                     // an interim hack and doesn't handle the general case of
1216                     // unmatched quotes among attributes that have names. -dwh
1217                     while(dest > buffer+1 && (*(dest-1) == '\n' || *(dest-1) == '\r'))
1218                         dest--; // remove trailing newlines
1219                     AtomicString v(buffer+1, dest-buffer-1);
1220                     attrName.setUnicode(buffer+1,dest-buffer-1); 
1221                     currToken.addAttribute(parser->docPtr()->document(), buffer, attrName, v);
1222                     tag = SearchAttribute;
1223                     dest = buffer;
1224                     tquote = NoQuote;
1225                     break;
1226                 }
1227                 
1228                 if(curchar <= '\'' && !src.escaped()) {
1229                     // ### attributes like '&{blaa....};' are supposed to be treated as jscript.
1230                     if ( curchar == '&' )
1231                     {
1232                         ++src;
1233                         parseEntity(src, dest, true);
1234                         break;
1235                     }
1236                     else if ( (tquote == SingleQuote && curchar == '\'') ||
1237                               (tquote == DoubleQuote && curchar == '\"') )
1238                     {
1239                         // some <input type=hidden> rely on trailing spaces. argh
1240                         while(dest > buffer+1 && (*(dest-1) == '\n' || *(dest-1) == '\r'))
1241                             dest--; // remove trailing newlines
1242                         AtomicString v(buffer+1, dest-buffer-1);
1243                         if (!attrNamePresent)
1244                             attrName.setUnicode(buffer+1,dest-buffer-1); 
1245                         currToken.addAttribute(parser->docPtr()->document(), buffer, attrName, v);
1246
1247                         dest = buffer;
1248                         tag = SearchAttribute;
1249                         tquote = NoQuote;
1250                         ++src;
1251                         break;
1252                     }
1253                 }
1254                 *dest = *src;
1255                 fixUpChar(*dest);
1256                 ++dest;
1257                 ++src;
1258             }
1259             break;
1260         }
1261         case Value:
1262         {
1263 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
1264             qDebug("Value");
1265 #endif
1266             ushort curchar;
1267             while(!src.isEmpty()) {
1268                 checkBuffer();
1269                 curchar = src->unicode();
1270                 if(curchar <= '>' && !src.escaped()) {
1271                     // parse Entities
1272                     if ( curchar == '&' )
1273                     {
1274                         ++src;
1275                         parseEntity(src, dest, true);
1276                         break;
1277                     }
1278                     // no quotes. Every space means end of value
1279                     // '/' does not delimit in IE!
1280                     if ( curchar <= ' ' || curchar == '>' )
1281                     {
1282                         AtomicString v(buffer+1, dest-buffer-1);
1283                         currToken.addAttribute(parser->docPtr()->document(), buffer, attrName, v);
1284                         dest = buffer;
1285                         tag = SearchAttribute;
1286                         break;
1287                     }
1288                 }
1289
1290                 *dest = *src;
1291                 fixUpChar(*dest);
1292                 ++dest;
1293                 ++src;
1294             }
1295             break;
1296         }
1297         case SearchEnd:
1298         {
1299 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 1
1300                 qDebug("SearchEnd");
1301 #endif
1302             while(!src.isEmpty()) {
1303                 if (*src == '>' || *src == '<')
1304                     break;
1305
1306                 if (*src == '/')
1307                     currToken.flat = true;
1308
1309                 ++src;
1310             }
1311             if (src.isEmpty()) break;
1312
1313             searchCount = 0; // Stop looking for '<!--' sequence
1314             tag = NoTag;
1315             tquote = NoQuote;
1316
1317             if (*src != '<')
1318                 ++src;
1319
1320             if ( !currToken.id ) //stop if tag is unknown
1321                 return;
1322
1323             uint tagID = currToken.id;
1324 #if defined(TOKEN_DEBUG) && TOKEN_DEBUG > 0
1325             kdDebug( 6036 ) << "appending Tag: " << tagID << endl;
1326 #endif
1327             bool beginTag = !currToken.flat && (tagID <= ID_CLOSE_TAG);
1328
1329             if (tagID > ID_CLOSE_TAG)
1330                 tagID -= ID_CLOSE_TAG;
1331             else if (tagID == ID_SCRIPT) {
1332                 AttributeImpl* a = 0;
1333                 bool foundTypeAttribute = false;
1334                 scriptSrc = QString::null;
1335                 scriptSrcCharset = QString::null;
1336                 if ( currToken.attrs && /* potentially have a ATTR_SRC ? */
1337                      parser->doc()->part() &&
1338                      parser->doc()->part()->jScriptEnabled() && /* jscript allowed at all? */
1339                      view /* are we a regular tokenizer or just for innerHTML ? */
1340                     ) {
1341                     if ( ( a = currToken.attrs->getAttributeItem( ATTR_SRC ) ) )
1342                         scriptSrc = parser->doc()->completeURL(parseURL( a->value() ).string() );
1343                     if ( ( a = currToken.attrs->getAttributeItem( ATTR_CHARSET ) ) )
1344                         scriptSrcCharset = a->value().string().stripWhiteSpace();
1345                     if ( scriptSrcCharset.isEmpty() )
1346                         scriptSrcCharset = parser->doc()->part()->encoding();
1347                     /* Check type before language, since language is deprecated */
1348                     if ((a = currToken.attrs->getAttributeItem(ATTR_TYPE)) != 0 && !a->value().string().isEmpty())
1349                         foundTypeAttribute = true;
1350                     else
1351                         a = currToken.attrs->getAttributeItem(ATTR_LANGUAGE);
1352                 }
1353                 javascript = true;
1354
1355                 if( foundTypeAttribute ) {
1356                     /* 
1357                         Mozilla 1.5 accepts application/x-javascript, and some web references claim it is the only
1358                         correct variation, but WinIE 6 doesn't accept it.
1359                         Neither Mozilla 1.5 nor WinIE 6 accept application/javascript, application/ecmascript, or
1360                         application/x-ecmascript.
1361                         Mozilla 1.5 doesn't accept the text/javascript1.x formats, but WinIE 6 does.
1362                         Mozilla 1.5 doesn't accept text/jscript, text/ecmascript, and text/livescript, but WinIE 6 does.
1363                         Mozilla 1.5 allows leading and trailing whitespace, but WinIE 6 doesn't.
1364                         Mozilla 1.5 and WinIE 6 both accept the empty string, but neither accept a whitespace-only string.
1365                         We want to accept all the values that either of these browsers accept, but not other values.
1366                      */
1367                     QString type = a->value().string().stripWhiteSpace().lower();
1368                     if( type.compare("application/x-javascript") != 0 &&
1369                         type.compare("text/javascript") != 0 &&
1370                         type.compare("text/javascript1.0") != 0 &&
1371                         type.compare("text/javascript1.1") != 0 &&
1372                         type.compare("text/javascript1.2") != 0 &&
1373                         type.compare("text/javascript1.3") != 0 &&
1374                         type.compare("text/javascript1.4") != 0 &&
1375                         type.compare("text/javascript1.5") != 0 &&
1376                         type.compare("text/jscript") != 0 &&
1377                         type.compare("text/ecmascript") != 0 &&
1378                         type.compare("text/livescript") )
1379                         javascript = false;
1380                 } else if( a ) {
1381                     /* 
1382                      Mozilla 1.5 doesn't accept jscript or ecmascript, but WinIE 6 does.
1383                      Mozilla 1.5 accepts javascript1.0, javascript1.4, and javascript1.5, but WinIE 6 accepts only 1.1 - 1.3.
1384                      Neither Mozilla 1.5 nor WinIE 6 accept leading or trailing whitespace.
1385                      We want to accept all the values that either of these browsers accept, but not other values.
1386                      */
1387                     QString lang = a->value().string();
1388                     lang = lang.lower();
1389                     if( lang.compare("") != 0 &&
1390                         lang.compare("javascript") != 0 &&
1391                         lang.compare("javascript1.0") != 0 &&
1392                         lang.compare("javascript1.1") != 0 &&
1393                         lang.compare("javascript1.2") != 0 &&
1394                         lang.compare("javascript1.3") != 0 &&
1395                         lang.compare("javascript1.4") != 0 &&
1396                         lang.compare("javascript1.5") != 0 &&
1397                         lang.compare("ecmascript") != 0 &&
1398                         lang.compare("livescript") != 0 &&
1399                         lang.compare("jscript") )
1400                         javascript = false;
1401                 }
1402             }
1403
1404             processToken();
1405
1406             // we have to take care to close the pre block in
1407             // case we encounter an unallowed element....
1408             if(pre && beginTag && !DOM::checkChild(ID_PRE, tagID)) {
1409                 kdDebug(6036) << " not allowed in <pre> " << (int)tagID << endl;
1410                 pre = false;
1411             }
1412
1413             switch( tagID ) {
1414             case ID_PRE:
1415                 prePos = 0;
1416                 pre = beginTag;
1417                 break;
1418             case ID_SCRIPT:
1419                 if (beginTag) {
1420                     searchStopper = scriptEnd;
1421                     searchStopperLen = 8;
1422                     script = true;
1423                     parseSpecial(src);
1424                 }
1425                 else if (tagID <= ID_CLOSE_TAG) // Handle <script src="foo"/>
1426                     scriptHandler();
1427                 break;
1428             case ID_STYLE:
1429                 if (beginTag) {
1430                     searchStopper = styleEnd;
1431                     searchStopperLen = 7;
1432                     style = true;
1433                     parseSpecial(src);
1434                 }
1435                 break;
1436             case ID_TEXTAREA:
1437                 if(beginTag) {
1438                     searchStopper = textareaEnd;
1439                     searchStopperLen = 10;
1440                     textarea = true;
1441                     parseSpecial(src);
1442                 }
1443                 break;
1444             case ID_TITLE:
1445                 if (beginTag) {
1446                     searchStopper = titleEnd;
1447                     searchStopperLen = 7;
1448                     title = true;
1449                     parseSpecial(src);
1450                 }
1451                 break;
1452             case ID_XMP:
1453                 if (beginTag) {
1454                     searchStopper = xmpEnd;
1455                     searchStopperLen = 5;
1456                     xmp = true;
1457                     parseSpecial(src);
1458                 }
1459                 break;
1460             case ID_SELECT:
1461                 select = beginTag;
1462                 break;
1463             case ID_PLAINTEXT:
1464                 plaintext = beginTag;
1465                 break;
1466             }
1467             
1468             if (beginTag && endTag[tagID] == FORBIDDEN)
1469                 // Don't discard LFs since this element has no end tag.
1470                 discard = NoneDiscard;
1471                 
1472             return; // Finished parsing tag!
1473         }
1474         } // end switch
1475     }
1476     return;
1477 }
1478
1479 void HTMLTokenizer::addPending()
1480 {
1481     if ( select && !script )
1482     {
1483         *dest++ = ' ';
1484     }
1485     else if ( textarea || script )
1486     {
1487         switch(pending) {
1488         case LFPending:  *dest++ = '\n'; prePos = 0; break;
1489         case SpacePending: *dest++ = ' '; ++prePos; break;
1490         case TabPending: *dest++ = '\t'; prePos += TAB_SIZE - (prePos % TAB_SIZE); break;
1491         case NonePending:
1492             assert(0);
1493         }
1494     }
1495     else
1496     {
1497         int p;
1498
1499         switch (pending)
1500         {
1501         case SpacePending:
1502             // Insert a breaking space
1503             *dest++ = QChar(' ');
1504             prePos++;
1505             break;
1506
1507         case LFPending:
1508             *dest = '\n';
1509             dest++;
1510             prePos = 0;
1511             break;
1512
1513         case TabPending:
1514             p = TAB_SIZE - ( prePos % TAB_SIZE );
1515 #ifdef TOKEN_DEBUG
1516             qDebug("tab pending, prePos: %d, toadd: %d", prePos, p);
1517 #endif
1518
1519             for ( int x = 0; x < p; x++ )
1520                 *dest++ = QChar(' ');
1521             prePos += p;
1522             break;
1523
1524         case NonePending:
1525             assert(0);
1526             break;
1527         }
1528     }
1529     
1530     pending = NonePending;
1531 }
1532
1533 void HTMLTokenizer::write(const TokenizerString &str, bool appendData)
1534 {
1535 #ifdef TOKEN_DEBUG
1536     kdDebug( 6036 ) << this << " Tokenizer::write(\"" << str << "\"," << appendData << ")" << endl;
1537 #endif
1538
1539     if (!buffer)
1540         return;
1541
1542     if ( ( m_executingScript && appendData ) || !cachedScript.isEmpty() ) {
1543         // don't parse; we will do this later
1544         if (currentPrependingSrc) {
1545             currentPrependingSrc->append(str);
1546         } else {
1547             pendingSrc.append(str);
1548         }
1549         return;
1550     }
1551
1552     if ( onHold ) {
1553         src.append(str);
1554         return;
1555     }
1556     
1557     if (!src.isEmpty())
1558         src.append(str);
1559     else
1560         setSrc(str);
1561
1562     // Once a timer is set, it has control of when the tokenizer continues.
1563     if (timerId)
1564         return;
1565
1566 #ifndef NDEBUG
1567     inWrite = true;
1568 #endif
1569     
1570 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1571     if (!parser->doc()->ownerElement())
1572         printf("Beginning write at time %d\n", parser->doc()->elapsedTime());
1573 #endif
1574     
1575 //     if (Entity)
1576 //         parseEntity(src, dest);
1577
1578     int processedCount = 0;
1579     QTime startTime;
1580     startTime.start();
1581     KWQUIEventTime eventTime;
1582
1583     while (!src.isEmpty() && (!parser->doc()->part() || !parser->doc()->part()->isScheduledLocationChangePending())) {
1584         if (!continueProcessing(processedCount, startTime, eventTime))
1585             break;
1586
1587         // do we need to enlarge the buffer?
1588         checkBuffer();
1589
1590         ushort cc = src->unicode();
1591
1592         if (skipLF && (cc != '\n'))
1593             skipLF = false;
1594
1595         if (skipLF) {
1596             skipLF = false;
1597             ++src;
1598         }
1599         else if ( Entity )
1600             parseEntity( src, dest );
1601         else if ( plaintext )
1602             parseText( src );
1603         else if (script)
1604             parseSpecial(src);
1605         else if (style)
1606             parseSpecial(src);
1607         else if (xmp)
1608             parseSpecial(src);
1609         else if (textarea)
1610             parseSpecial(src);
1611         else if (title)
1612             parseSpecial(src);
1613         else if (comment)
1614             parseComment(src);
1615         else if (server)
1616             parseServer(src);
1617         else if (processingInstruction)
1618             parseProcessingInstruction(src);
1619         else if (tag)
1620             parseTag(src);
1621         else if ( startTag )
1622         {
1623             startTag = false;
1624
1625             switch(cc) {
1626             case '/':
1627                 break;
1628             case '!':
1629             {
1630                 // <!-- comment -->
1631                 searchCount = 1; // Look for '<!--' sequence to start comment
1632
1633                 break;
1634             }
1635             case '?':
1636             {
1637                 // xml processing instruction
1638                 processingInstruction = true;
1639                 tquote = NoQuote;
1640                 parseProcessingInstruction(src);
1641                 continue;
1642
1643                 break;
1644             }
1645             case '%':
1646                 if (!brokenServer) {
1647                     // <% server stuff, handle as comment %>
1648                     server = true;
1649                     tquote = NoQuote;
1650                     parseServer(src);
1651                     continue;
1652                 }
1653                 // else fall through
1654             default:
1655             {
1656                 if( ((cc >= 'a') && (cc <= 'z')) || ((cc >= 'A') && (cc <= 'Z')))
1657                 {
1658                     // Start of a Start-Tag
1659                 }
1660                 else
1661                 {
1662                     // Invalid tag
1663                     // Add as is
1664                     if (pending)
1665                         addPending();
1666                     *dest = '<';
1667                     dest++;
1668                     continue;
1669                 }
1670             }
1671             }; // end case
1672
1673             if ( pending ) {
1674                 // pre context always gets its spaces/linefeeds
1675                 if ( pre || script || (!parser->selectMode() &&
1676                              (!parser->noSpaces() || dest > buffer ))) {
1677                     addPending();
1678                     discard = AllDiscard; // So we discard the first LF after the open tag.
1679                 }
1680                 // just forget it
1681                 else
1682                     pending = NonePending;
1683             }
1684
1685             if (cc == '/' && discard == AllDiscard)
1686                 discard = NoneDiscard; // A close tag. No need to discard LF.
1687                     
1688             processToken();
1689
1690             cBufferPos = 0;
1691             tag = TagName;
1692             parseTag(src);
1693         }
1694         else if ( cc == '&' && !src.escaped())
1695         {
1696             ++src;
1697             if ( pending )
1698                 addPending();
1699             parseEntity(src, dest, true);
1700         }
1701         else if ( cc == '<' && !src.escaped())
1702         {
1703             tagStartLineno = lineno+src.lineCount();
1704             ++src;
1705             startTag = true;
1706         }
1707         else if (( cc == '\n' ) || ( cc == '\r' ))
1708         {
1709             if (select && !script)
1710             {
1711                 if (discard == LFDiscard)
1712                 {
1713                     // Ignore this LF
1714                     discard = NoneDiscard; // We have discarded 1 LF
1715                 }
1716                 else if(discard == AllDiscard)
1717                 {
1718                 }
1719                 else
1720                  {
1721                      // Process this LF
1722                     if (pending == NonePending)
1723                          pending = LFPending;
1724                 }
1725             }
1726             else {
1727                 if (discard == LFDiscard || discard == AllDiscard)
1728                 {
1729                     // Ignore this LF
1730                     discard = NoneDiscard; // We have discarded 1 LF
1731                 }
1732                 else
1733                 {
1734                     // Process this LF
1735                     if (pending)
1736                         addPending();
1737                     pending = LFPending;
1738                 }
1739             }
1740             
1741             /* Check for MS-DOS CRLF sequence */
1742             if (cc == '\r')
1743             {
1744                 skipLF = true;
1745             }
1746             ++src;
1747         }
1748         else if (( cc == ' ' ) || ( cc == '\t' ))
1749         {
1750             if (select && !script) {
1751                 if(discard == SpaceDiscard)
1752                     discard = NoneDiscard;
1753                  else if(discard == AllDiscard)
1754                  { }
1755                  else
1756                      pending = SpacePending;
1757             
1758             }
1759             else {
1760                 if (discard == AllDiscard)
1761                     discard = NoneDiscard;
1762             
1763                 if (pending)
1764                     addPending();
1765                 if (cc == ' ')
1766                     pending = SpacePending;
1767                 else
1768                     pending = TabPending;
1769             }
1770             
1771             ++src;
1772         }
1773         else
1774         {
1775             if (pending)
1776                 addPending();
1777
1778             discard = NoneDiscard;
1779             if ( pre )
1780             {
1781                 prePos++;
1782             }
1783 #if QT_VERSION < 300
1784             unsigned char row = src->row();
1785             if ( row > 0x05 && row < 0x10 || row > 0xfd )
1786                     currToken.complexText = true;
1787 #endif
1788             *dest = *src;
1789             fixUpChar( *dest );
1790             ++dest;
1791             ++src;
1792         }
1793     }
1794     
1795 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1796     if (!parser->doc()->ownerElement())
1797         printf("Ending write at time %d\n", parser->doc()->elapsedTime());
1798 #endif
1799     
1800 #ifndef NDEBUG
1801     inWrite = false;
1802 #endif
1803
1804     if (noMoreData && !loadingExtScript && !m_executingScript && !timerId)
1805         end(); // this actually causes us to be deleted
1806 }
1807
1808 void HTMLTokenizer::stopped()
1809 {
1810     if (timerId) {
1811         killTimer(timerId);
1812         timerId = 0;
1813     }
1814 }
1815
1816 bool HTMLTokenizer::processingData() const
1817 {
1818     return timerId != 0;
1819 }
1820
1821 bool HTMLTokenizer::continueProcessing(int& processedCount, const QTime& startTime, const KWQUIEventTime& eventTime)
1822 {
1823     // We don't want to be checking elapsed time with every character, so we only check after we've
1824     // processed a certain number of characters.
1825     bool allowedYield = allowYield;
1826     allowYield = false;
1827     if (!loadingExtScript && !m_executingScript && (processedCount > TOKENIZER_CHUNK_SIZE || allowedYield)) {
1828         processedCount = 0;
1829         if (startTime.elapsed() > TOKENIZER_TIME_DELAY) {
1830             /* FIXME: We'd like to yield aggressively to give stylesheets the opportunity to
1831                load, but this hurts overall performance on slower machines.  For now turn this
1832                off.
1833             || (!parser->doc()->haveStylesheetsLoaded() && 
1834                 (parser->doc()->documentElement()->id() != ID_HTML || parser->doc()->body()))) {*/
1835             // Schedule the timer to keep processing as soon as possible.
1836             if (!timerId)
1837                 timerId = startTimer(0);
1838 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1839             if (eventTime.uiEventPending())
1840                 printf("Deferring processing of data because of UI event.\n");
1841             else if (startTime.elapsed() > TOKENIZER_TIME_DELAY)
1842                 printf("Deferring processing of data because 200ms elapsed away from event loop.\n");
1843 #endif
1844             return false;
1845         }
1846     }
1847     
1848     processedCount++;
1849     return true;
1850 }
1851
1852 void HTMLTokenizer::timerEvent(QTimerEvent* e)
1853 {
1854     if (e->timerId() == timerId) {
1855         // Kill the timer.
1856         killTimer(timerId);
1857         timerId = 0;
1858
1859 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1860         if (!parser->doc()->ownerElement())
1861             printf("Beginning timer write at time %d\n", parser->doc()->elapsedTime());
1862 #endif
1863
1864         if (parser->doc()->view() && parser->doc()->view()->layoutPending() && !parser->doc()->minimumLayoutDelay()) {
1865             // Restart the timer and let layout win.  This is basically a way of ensuring that the layout
1866             // timer has higher priority than our timer.
1867             timerId = startTimer(0);
1868             return;
1869         }
1870         
1871         // Invoke write() as though more data came in.
1872         bool oldNoMoreData = noMoreData;
1873         noMoreData = false;  // This prevents write() from deleting the tokenizer.
1874         write(TokenizerString(), true);
1875         noMoreData = oldNoMoreData;
1876         
1877         // If the timer dies (and stays dead after the write),  we need to let WebKit know that we're done processing the data.
1878         allDataProcessed();
1879     }
1880 }
1881
1882 void HTMLTokenizer::allDataProcessed()
1883 {
1884     if (noMoreData && !loadingExtScript && !m_executingScript && !onHold && !timerId) {
1885         if (!parser || !parser->doc() || !parser->doc()->part())
1886             return;
1887         KHTMLPart* part = parser->doc()->part();
1888         end();
1889         part->tokenizerProcessedData();
1890     }
1891 }
1892
1893 void HTMLTokenizer::end()
1894 {
1895     assert(timerId == 0);
1896     if (timerId) {
1897         // Clean up anyway.
1898         killTimer(timerId);
1899         timerId = 0;
1900     }
1901
1902     if ( buffer == 0 ) {
1903         parser->finished();
1904         emit finishedParsing();
1905         return;
1906     }
1907
1908     // parseTag is using the buffer for different matters
1909     if ( !tag )
1910         processToken();
1911
1912     if(buffer)
1913         KHTML_DELETE_QCHAR_VEC(buffer);
1914
1915     if(scriptCode)
1916         KHTML_DELETE_QCHAR_VEC(scriptCode);
1917
1918     scriptCode = 0;
1919     scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
1920     buffer = 0;
1921     parser->finished();
1922     emit finishedParsing();
1923 }
1924
1925 void HTMLTokenizer::finish()
1926 {
1927     // do this as long as we don't find matching comment ends
1928     while((comment || server) && scriptCode && scriptCodeSize)
1929     {
1930         // we've found an unmatched comment start
1931         if (comment)
1932             brokenComments = true;
1933         else
1934             brokenServer = true;
1935         checkScriptBuffer();
1936         scriptCode[ scriptCodeSize ] = 0;
1937         scriptCode[ scriptCodeSize + 1 ] = 0;
1938         int pos;
1939         QString food;
1940         if (script || style) {
1941             food.setUnicode(scriptCode, scriptCodeSize);
1942         }
1943         else if (server) {
1944             food = "<";
1945             food += QString(scriptCode, scriptCodeSize);
1946         }
1947         else {
1948             pos = QConstString(scriptCode, scriptCodeSize).string().find('>');
1949             food.setUnicode(scriptCode+pos+1, scriptCodeSize-pos-1); // deep copy
1950         }
1951         KHTML_DELETE_QCHAR_VEC(scriptCode);
1952         scriptCode = 0;
1953         scriptCodeSize = scriptCodeMaxSize = scriptCodeResync = 0;
1954         comment = server = false;
1955         if ( !food.isEmpty() )
1956             write(food, true);
1957     }
1958     // this indicates we will not receive any more data... but if we are waiting on
1959     // an external script to load, we can't finish parsing until that is done
1960     noMoreData = true;
1961     if (!loadingExtScript && !m_executingScript && !onHold && !timerId)
1962         end(); // this actually causes us to be deleted
1963 }
1964
1965 void HTMLTokenizer::processToken()
1966 {
1967     KJSProxy *jsProxy = (view && view->part()) ? view->part()->jScript() : 0L;    
1968     if (jsProxy)
1969         jsProxy->setEventHandlerLineno(tagStartLineno);
1970     if ( dest > buffer )
1971     {
1972 #ifdef TOKEN_DEBUG
1973         if(currToken.id) {
1974             qDebug( "unexpected token id: %d, str: *%s*", currToken.id,QConstString( buffer,dest-buffer ).string().latin1() );
1975             assert(0);
1976         }
1977
1978 #endif
1979         currToken.text = new DOMStringImpl( buffer, dest - buffer );
1980         currToken.text->ref();
1981         if (currToken.id != ID_COMMENT)
1982             currToken.id = ID_TEXT;
1983     }
1984     else if(!currToken.id) {
1985         currToken.reset();
1986         if (jsProxy)
1987             jsProxy->setEventHandlerLineno(lineno+src.lineCount());
1988         return;
1989     }
1990
1991     dest = buffer;
1992
1993 #ifdef TOKEN_DEBUG
1994     QString name = getTagName(currToken.id).string();
1995     QString text;
1996     if(currToken.text)
1997         text = QConstString(currToken.text->s, currToken.text->l).string();
1998
1999     kdDebug( 6036 ) << "Token --> " << name << "   id = " << currToken.id << endl;
2000     if (currToken.flat)
2001         kdDebug( 6036 ) << "Token is FLAT!" << endl;
2002     if(!text.isNull())
2003         kdDebug( 6036 ) << "text: \"" << text << "\"" << endl;
2004     unsigned long l = currToken.attrs ? currToken.attrs->length() : 0;
2005     if(l) {
2006         kdDebug( 6036 ) << "Attributes: " << l << endl;
2007         for (unsigned long i = 0; i < l; ++i) {
2008             AttributeImpl* c = currToken.attrs->attributeItem(i);
2009             kdDebug( 6036 ) << "    " << c->id() << " " << parser->doc()->getDocument()->attrName(c->id()).string()
2010                             << "=\"" << c->value().string() << "\"" << endl;
2011         }
2012     }
2013     kdDebug( 6036 ) << endl;
2014 #endif
2015     // pass the token over to the parser, the parser DOES NOT delete the token
2016     parser->parseToken(&currToken);
2017
2018     currToken.reset();
2019     if (jsProxy)
2020         jsProxy->setEventHandlerLineno(0);
2021 }
2022
2023 HTMLTokenizer::~HTMLTokenizer()
2024 {
2025     assert(!inWrite);
2026     reset();
2027     delete parser;
2028 }
2029
2030
2031 void HTMLTokenizer::enlargeBuffer(int len)
2032 {
2033     int newsize = kMax(size*2, size+len);
2034     int oldoffs = (dest - buffer);
2035
2036     buffer = (QChar*)realloc(buffer, newsize*sizeof(QChar));
2037     dest = buffer + oldoffs;
2038     size = newsize;
2039 }
2040
2041 void HTMLTokenizer::enlargeScriptBuffer(int len)
2042 {
2043     int newsize = kMax(scriptCodeMaxSize*2, scriptCodeMaxSize+len);
2044     scriptCode = (QChar*)realloc(scriptCode, newsize*sizeof(QChar));
2045     scriptCodeMaxSize = newsize;
2046 }
2047
2048 void HTMLTokenizer::notifyFinished(CachedObject */*finishedObj*/)
2049 {
2050 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2051     if (!parser->doc()->ownerElement())
2052         printf("script loaded at %d\n", parser->doc()->elapsedTime());
2053 #endif
2054
2055     assert(!cachedScript.isEmpty());
2056     bool finished = false;
2057     while (!finished && cachedScript.head()->isLoaded()) {
2058 #ifdef TOKEN_DEBUG
2059         kdDebug( 6036 ) << "Finished loading an external script" << endl;
2060 #endif
2061         CachedScript* cs = cachedScript.dequeue();
2062         DOMString scriptSource = cs->script();
2063 #ifdef TOKEN_DEBUG
2064         kdDebug( 6036 ) << "External script is:" << endl << scriptSource.string() << endl;
2065 #endif
2066         setSrc(TokenizerString());
2067
2068         // make sure we forget about the script before we execute the new one
2069         // infinite recursion might happen otherwise
2070         QString cachedScriptUrl( cs->url().string() );
2071         cs->deref(this);
2072
2073 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2074         if (!parser->doc()->ownerElement())
2075             printf("external script beginning execution at %d\n", parser->doc()->elapsedTime());
2076 #endif
2077
2078         scriptExecution( scriptSource.string(), cachedScriptUrl );
2079
2080         // The state of cachedScript.isEmpty() can change inside the scriptExecution()
2081         // call above, so test afterwards.
2082         finished = cachedScript.isEmpty();
2083         if (finished) {
2084             loadingExtScript = false;
2085 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
2086             if (!parser->doc()->ownerElement())
2087                 printf("external script finished execution at %d\n", parser->doc()->elapsedTime());
2088 #endif
2089         }
2090
2091         // 'script' is true when we are called synchronously from
2092         // parseScript(). In that case parseScript() will take care
2093         // of 'scriptOutput'.
2094         if ( !script ) {
2095             TokenizerString rest = pendingSrc;
2096             pendingSrc.clear();
2097             write(rest, false);
2098             // we might be deleted at this point, do not
2099             // access any members.
2100         }
2101     }
2102 }
2103
2104 bool HTMLTokenizer::isWaitingForScripts() const
2105 {
2106     return loadingExtScript;
2107 }
2108
2109 void HTMLTokenizer::setSrc(const TokenizerString &source)
2110 {
2111     lineno += src.lineCount();
2112     src = source;
2113     src.resetLineCount();
2114 }
2115
2116 void HTMLTokenizer::setOnHold(bool _onHold)
2117 {
2118     onHold = _onHold;
2119 }
2120
2121 }