8b6769d41b83e467e54723c800d0b48f814f7d5b
[WebKit-https.git] / WebCore / loader / Decoder.cpp
1 /*
2     This file is part of the KDE libraries
3
4     Copyright (C) 1999 Lars Knoll (knoll@mpi-hd.mpg.de)
5     Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.
6     Copyright (C) 2005, 2006 Alexey Proskuryakov (ap@nypop.com)
7
8     This library is free software; you can redistribute it and/or
9     modify it under the terms of the GNU Library General Public
10     License as published by the Free Software Foundation; either
11     version 2 of the License, or (at your option) any later version.
12
13     This library is distributed in the hope that it will be useful,
14     but WITHOUT ANY WARRANTY; without even the implied warranty of
15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16     Library General Public License for more details.
17
18     You should have received a copy of the GNU Library General Public License
19     along with this library; see the file COPYING.LIB.  If not, write to
20     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21     Boston, MA 02111-1307, USA.
22 */
23
24
25 #include "config.h"
26 #include "Decoder.h"
27
28 #include "CString.h"
29 #include "DOMImplementation.h"
30 #include "HTMLNames.h"
31 #include "StreamingTextDecoder.h"
32 #include "RegularExpression.h"
33
34 using namespace WebCore;
35 using namespace HTMLNames;
36
37 class KanjiCode
38 {
39 public:
40     enum Type { ASCII, JIS, EUC, SJIS, UTF16, UTF8 };
41     static enum Type judge(const char *str, int length);
42     static const int ESC;
43     static const int _SS2_;
44     static const unsigned char kanji_map_sjis[];
45     static int ISkanji(int code)
46     {
47         if (code >= 0x100)
48                     return 0;
49         return (kanji_map_sjis[code & 0xff] & 1);
50     }
51
52     static int ISkana(int code)
53     {
54         if (code >= 0x100)
55                     return 0;
56         return (kanji_map_sjis[code & 0xff] & 2);
57     }
58
59 };
60
61 const int KanjiCode::ESC = 0x1b;
62 const int KanjiCode::_SS2_ = 0x8e;
63
64 const unsigned char KanjiCode::kanji_map_sjis[] =
65 {
66     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
67     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
68     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
69     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
70     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
71     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
72     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
73     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
74     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
75     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
76     0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
77     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
78     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
79     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
80     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
81     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0
82 };
83
84 /*
85  * EUC-JP is
86  *     [0xa1 - 0xfe][0xa1 - 0xfe]
87  *     0x8e[0xa1 - 0xfe](SS2)
88  *     0x8f[0xa1 - 0xfe][0xa1 - 0xfe](SS3)
89  *
90  * Shift_Jis is
91  *     [0x81 - 0x9f, 0xe0 - 0xef(0xfe?)][0x40 - 0x7e, 0x80 - 0xfc]
92  *
93  * Shift_Jis Hankaku Kana is
94  *     [0xa1 - 0xdf]
95  */
96
97 /*
98  * KanjiCode::judge() is based on judge_jcode() from jvim
99  *     http://hp.vector.co.jp/authors/VA003457/vim/
100  *
101  * Special Thanks to Kenichi Tsuchida
102  */
103
104 enum KanjiCode::Type KanjiCode::judge(const char *str, int size)
105 {
106     enum Type code;
107     int i;
108     int bfr = false;            /* Kana Moji */
109     int bfk = 0;                /* EUC Kana */
110     int sjis = 0;
111     int euc = 0;
112
113     const unsigned char *ptr = (const unsigned char *) str;
114
115     code = ASCII;
116
117     i = 0;
118     while (i < size) {
119         if (ptr[i] == ESC && (size - i >= 3)) {
120             if ((ptr[i + 1] == '$' && ptr[i + 2] == 'B')
121             || (ptr[i + 1] == '(' && ptr[i + 2] == 'B')) {
122                 code = JIS;
123                 goto breakBreak;
124             } else if ((ptr[i + 1] == '$' && ptr[i + 2] == '@')
125                     || (ptr[i + 1] == '(' && ptr[i + 2] == 'J')) {
126                 code = JIS;
127                 goto breakBreak;
128             } else if (ptr[i + 1] == '(' && ptr[i + 2] == 'I') {
129                 code = JIS;
130                 i += 3;
131             } else if (ptr[i + 1] == ')' && ptr[i + 2] == 'I') {
132                 code = JIS;
133                 i += 3;
134             } else {
135                 i++;
136             }
137             bfr = false;
138             bfk = 0;
139         } else {
140             if (ptr[i] < 0x20) {
141                 bfr = false;
142                 bfk = 0;
143                 /* ?? check kudokuten ?? && ?? hiragana ?? */
144                 if ((i >= 2) && (ptr[i - 2] == 0x81)
145                         && (0x41 <= ptr[i - 1] && ptr[i - 1] <= 0x49)) {
146                     code = SJIS;
147                     sjis += 100;        /* kudokuten */
148                 } else if ((i >= 2) && (ptr[i - 2] == 0xa1)
149                         && (0xa2 <= ptr[i - 1] && ptr[i - 1] <= 0xaa)) {
150                     code = EUC;
151                     euc += 100;         /* kudokuten */
152                 } else if ((i >= 2) && (ptr[i - 2] == 0x82) && (0xa0 <= ptr[i - 1])) {
153                     sjis += 40;         /* hiragana */
154                 } else if ((i >= 2) && (ptr[i - 2] == 0xa4) && (0xa0 <= ptr[i - 1])) {
155                     euc += 40;          /* hiragana */
156                 }
157             } else {
158                 /* ?? check hiragana or katana ?? */
159                 if ((size - i > 1) && (ptr[i] == 0x82) && (0xa0 <= ptr[i + 1])) {
160                     sjis++;     /* hiragana */
161                 } else if ((size - i > 1) && (ptr[i] == 0x83)
162                          && (0x40 <= ptr[i + 1] && ptr[i + 1] <= 0x9f)) {
163                     sjis++;     /* katakana */
164                 } else if ((size - i > 1) && (ptr[i] == 0xa4) && (0xa0 <= ptr[i + 1])) {
165                     euc++;      /* hiragana */
166                 } else if ((size - i > 1) && (ptr[i] == 0xa5) && (0xa0 <= ptr[i + 1])) {
167                     euc++;      /* katakana */
168                 }
169                 if (bfr) {
170                     if ((i >= 1) && (0x40 <= ptr[i] && ptr[i] <= 0xa0) && ISkanji(ptr[i - 1])) {
171                         code = SJIS;
172                         goto breakBreak;
173                     } else if ((i >= 1) && (0x81 <= ptr[i - 1] && ptr[i - 1] <= 0x9f) && ((0x40 <= ptr[i] && ptr[i] < 0x7e) || (0x7e < ptr[i] && ptr[i] <= 0xfc))) {
174                         code = SJIS;
175                         goto breakBreak;
176                     } else if ((i >= 1) && (0xfd <= ptr[i] && ptr[i] <= 0xfe) && (0xa1 <= ptr[i - 1] && ptr[i - 1] <= 0xfe)) {
177                         code = EUC;
178                         goto breakBreak;
179                     } else if ((i >= 1) && (0xfd <= ptr[i - 1] && ptr[i - 1] <= 0xfe) && (0xa1 <= ptr[i] && ptr[i] <= 0xfe)) {
180                         code = EUC;
181                         goto breakBreak;
182                     } else if ((i >= 1) && (ptr[i] < 0xa0 || 0xdf < ptr[i]) && (0x8e == ptr[i - 1])) {
183                         code = SJIS;
184                         goto breakBreak;
185                     } else if (ptr[i] <= 0x7f) {
186                         code = SJIS;
187                         goto breakBreak;
188                     } else {
189                         if (0xa1 <= ptr[i] && ptr[i] <= 0xa6) {
190                             euc++;      /* sjis hankaku kana kigo */
191                         } else if (0xa1 <= ptr[i] && ptr[i] <= 0xdf) {
192                             ;           /* sjis hankaku kana */
193                         } else if (0xa1 <= ptr[i] && ptr[i] <= 0xfe) {
194                             euc++;
195                         } else if (0x8e == ptr[i]) {
196                             euc++;
197                         } else if (0x20 <= ptr[i] && ptr[i] <= 0x7f) {
198                             sjis++;
199                         }
200                         bfr = false;
201                         bfk = 0;
202                     }
203                 } else if (0x8e == ptr[i]) {
204                     if (size - i <= 1) {
205                         ;
206                     } else if (0xa1 <= ptr[i + 1] && ptr[i + 1] <= 0xdf) {
207                         /* EUC KANA or SJIS KANJI */
208                         if (bfk == 1) {
209                             euc += 100;
210                         }
211                         bfk++;
212                         i++;
213                     } else {
214                         /* SJIS only */
215                         code = SJIS;
216                         goto breakBreak;
217                     }
218                 } else if (0x81 <= ptr[i] && ptr[i] <= 0x9f) {
219                     /* SJIS only */
220                     code = SJIS;
221                     if ((size - i >= 1)
222                             && ((0x40 <= ptr[i + 1] && ptr[i + 1] <= 0x7e)
223                             || (0x80 <= ptr[i + 1] && ptr[i + 1] <= 0xfc))) {
224                         goto breakBreak;
225                     }
226                 } else if (0xfd <= ptr[i] && ptr[i] <= 0xfe) {
227                     /* EUC only */
228                     code = EUC;
229                     if ((size - i >= 1)
230                             && (0xa1 <= ptr[i + 1] && ptr[i + 1] <= 0xfe)) {
231                         goto breakBreak;
232                     }
233                 } else if (ptr[i] <= 0x7f) {
234                     ;
235                 } else {
236                     bfr = true;
237                     bfk = 0;
238                 }
239             }
240             i++;
241         }
242     }
243     if (code == ASCII) {
244         if (sjis > euc) {
245             code = SJIS;
246         } else if (sjis < euc) {
247             code = EUC;
248         }
249     }
250 breakBreak:
251     return (code);
252 }
253
254 Decoder::Decoder(const String& mimeType, const String& defaultEncodingName)
255   : m_encoding(defaultEncodingName.isNull() ? "iso8859-1" : defaultEncodingName.latin1())
256   , m_encodingName(m_encoding.name())
257   , m_type(DefaultEncoding)
258   , m_reachedBody(false)
259   , m_checkedForCSSCharset(false)
260   , m_checkedForBOM(false)
261 {
262     if (mimeType == "text/css")
263         m_contentType = CSS;
264     else if (mimeType == "text/html")
265         m_contentType = HTML;
266     else if (DOMImplementation::isXMLMIMEType(mimeType)) {
267         m_contentType = XML;
268         // Despite 8.5 "Text/xml with Omitted Charset" of RFC 3023, we do not assume us-ascii 
269         // for text/xml, to match Firefox.
270         m_encoding = TextEncoding(UTF8Encoding);
271         m_encodingName = "UTF-8";
272     } else
273         m_contentType = PlainText;
274
275     if (m_encoding.isValid())
276         m_decoder.set(StreamingTextDecoder::create(m_encoding));
277     else
278         setEncodingName("iso-8859-1", DefaultEncoding);
279 }
280
281 Decoder::~Decoder()
282 {
283 }
284
285 void Decoder::setEncodingName(const char* encodingName, EncodingSource type)
286 {
287     if (encodingName[0] == '\0')
288         return;
289
290     bool eightBitOnly = type == EncodingFromMetaTag || type == EncodingFromXMLHeader || type == EncodingFromCSSCharset;
291     TextEncoding encoding = TextEncoding(encodingName, eightBitOnly);
292
293     // in case the encoding didn't exist, we keep the old one (fixes some sites specifying invalid encodings)
294     if (encoding.isValid()) {
295         m_encodingName = encoding.name(); // use a standard name for the encoding
296         m_encoding = encoding;
297         m_type = type;
298         m_decoder.set(StreamingTextDecoder::create(m_encoding));
299     }
300 }
301
302 const char* Decoder::encodingName() const
303 {
304     return m_encodingName;
305 }
306
307 // Other browsers allow comments in the head section, so we need to also.
308 // It's important not to look for tags inside the comments.
309 static void skipComment(const char *&ptr, const char *pEnd)
310 {
311     const char *p = ptr;
312     // Allow <!-->; other browsers do.
313     if (*p == '>') {
314         p++;
315     } else {
316         while (p != pEnd) {
317             if (*p == '-') {
318                 // This is the real end of comment, "-->".
319                 if (p[1] == '-' && p[2] == '>') {
320                     p += 3;
321                     break;
322                 }
323                 // This is the incorrect end of comment that other browsers allow, "--!>".
324                 if (p[1] == '-' && p[2] == '!' && p[3] == '>') {
325                     p += 4;
326                     break;
327                 }
328             }
329             p++;
330         }
331     }
332     ptr = p;
333 }
334
335 // Returns the position of the encoding string.
336 static int findXMLEncoding(const DeprecatedCString &str, int &encodingLength)
337 {
338     int len = str.length();
339
340     int pos = str.find("encoding");
341     if (pos == -1)
342         return -1;
343     pos += 8;
344     
345     // Skip spaces and stray control characters.
346     while (str[pos] <= ' ' && pos != len)
347         ++pos;
348
349     // Skip equals sign.
350     if (str[pos] != '=')
351         return -1;
352     ++pos;
353
354     // Skip spaces and stray control characters.
355     while (str[pos] <= ' ' && pos != len)
356         ++pos;
357
358     // Skip quotation mark.
359     char quoteMark = str[pos];
360     if (quoteMark != '"' && quoteMark != '\'')
361         return -1;
362     ++pos;
363
364     // Find the trailing quotation mark.
365     int end = pos;
366     while (str[end] != quoteMark)
367         ++end;
368
369     if (end == len)
370         return -1;
371     
372     encodingLength = end - pos;
373     return pos;
374 }
375
376 // true if there is more to parse
377 static inline bool skipWhitespace(const char*& pos, const char* dataEnd)
378 {
379     while (pos < dataEnd && (*pos == '\t' || *pos == ' '))
380         ++pos;
381     return pos != dataEnd;
382 }
383
384 DeprecatedString Decoder::decode(const char *data, int len)
385 {
386     // Check for UTF-16 or UTF-8 BOM mark at the beginning, which is a sure sign of a Unicode encoding.
387     int bufferLength = m_buffer.length();
388     const int maximumBOMLength = 3;
389     if (!m_checkedForBOM && bufferLength + len >= maximumBOMLength) {
390         if (m_type != UserChosenEncoding) {
391             // Extract the first three bytes.
392             // Handle the case where some of bytes are already in the buffer.
393             // The last byte is always guaranteed to not be in the buffer.
394             const unsigned char *udata = (const unsigned char *)data;
395             unsigned char c1 = bufferLength >= 1 ? m_buffer[0].unicode() : *udata++;
396             unsigned char c2 = bufferLength >= 2 ? m_buffer[1].unicode() : *udata++;
397             ASSERT(bufferLength < 3);
398             unsigned char c3 = *udata;
399
400             // Check for the BOM.
401             const char *autoDetectedEncoding;
402             if ((c1 == 0xFE && c2 == 0xFF) || (c1 == 0xFF && c2 == 0xFE)) {
403                 autoDetectedEncoding = "ISO-10646-UCS-2";
404             } else if (c1 == 0xEF && c2 == 0xBB && c3 == 0xBF) {
405                 autoDetectedEncoding = "UTF-8";
406             } else {
407                 autoDetectedEncoding = 0;
408             }
409
410             // If we found a BOM, use the encoding it implies.
411             if (autoDetectedEncoding != 0)
412                 setEncodingName(autoDetectedEncoding, AutoDetectedEncoding);
413         }
414         m_checkedForBOM = true;
415     }
416     
417     bool currentChunkInBuffer = false;
418     
419     if (m_type == DefaultEncoding && m_contentType == CSS && !m_checkedForCSSCharset) {
420         m_buffer.append(data, len);
421         currentChunkInBuffer = true;
422
423         if (len > 8) { // strlen("@charset") == 8
424             const char* dataStart = m_buffer.latin1();
425             const char* dataEnd = dataStart + m_buffer.length();
426
427             if (dataStart[0] == '@' && dataStart[1] == 'c' && dataStart[2] == 'h' && dataStart[3] == 'a' && dataStart[4] == 'r' && 
428                 dataStart[5] == 's' && dataStart[6] == 'e' && dataStart[7] == 't') {
429         
430                 dataStart += 8;
431                 const char* pos = dataStart;
432                 if (!skipWhitespace(pos, dataEnd))
433                     return DeprecatedString::null;
434
435                 if (*pos == '"' || *pos == '\'') {
436                     char quotationMark = *pos;
437                     ++pos;
438                     dataStart = pos;
439                 
440                     while (pos < dataEnd && *pos != quotationMark)
441                         ++pos;
442                     if (pos == dataEnd)
443                         return DeprecatedString::null;
444
445                     DeprecatedCString encodingName(dataStart, pos - dataStart + 1);
446                     
447                     ++pos;
448                     if (!skipWhitespace(pos, dataEnd))
449                         return DeprecatedString::null;
450
451                     if (*pos == ';')
452                         setEncodingName(encodingName, EncodingFromCSSCharset);
453                 }
454             }
455             m_checkedForCSSCharset = true;
456         }
457         return DeprecatedString::null;
458
459     } else if (m_type == DefaultEncoding && m_contentType != PlainText && !m_reachedBody) { // HTML and XML
460         // this is not completely efficient, since the function might go
461         // through the html head several times...
462     
463         m_buffer.append(data, len);
464         currentChunkInBuffer = true;
465         
466         // we still don't have an encoding, and are in the head
467         // the following tags are allowed in <head>:
468         // SCRIPT|STYLE|META|LINK|OBJECT|TITLE|BASE
469         
470         // We stop scanning when a tag that is not permitted in <head>
471         // is seen, rather when </head> is seen, because that more closely
472         // matches behavior in other browsers; more details in
473         // <http://bugzilla.opendarwin.org/show_bug.cgi?id=3590>.
474         
475         // Additionally, we ignore things that looks like tags in <title>; see
476         // <http://bugzilla.opendarwin.org/show_bug.cgi?id=4560>.
477         
478         bool withinTitle = false;
479
480         const char *ptr = m_buffer.latin1();
481         const char *pEnd = ptr + m_buffer.length();
482         while (ptr != pEnd) {
483             if (*ptr == '<') {
484                 bool end = false;
485                 ptr++;
486
487                 // Handle comments.
488                 if (ptr[0] == '!' && ptr[1] == '-' && ptr[2] == '-') {
489                     ptr += 3;
490                     skipComment(ptr, pEnd);
491                     continue;
492                 }
493                 
494                 // Handle XML declaration, which can have encoding in it.
495                 // This encoding is honored even for HTML documents.
496                 if (ptr[0] == '?' && ptr[1] == 'x' && ptr[2] == 'm' && ptr[3] == 'l') {
497                     const char *end = ptr;
498                     while (*end != '>' && *end != '\0')
499                         end++;
500                     if (*end == '\0')
501                         break;
502                     DeprecatedCString str(ptr, end - ptr);
503                     int len;
504                     int pos = findXMLEncoding(str, len);
505                     if (pos != -1)
506                         setEncodingName(str.mid(pos, len), EncodingFromXMLHeader);
507                     // continue looking for a charset - it may be specified in an HTTP-Equiv meta
508                 } else if (ptr[0] == 0 && ptr[1] == '?' && ptr[2] == 0 && ptr[3] == 'x' && ptr[4] == 0 && ptr[5] == 'm' && ptr[6] == 0 && ptr[7] == 'l') {
509                     // UTF-16 without BOM
510                     setEncodingName(((ptr - m_buffer.latin1()) % 2) ? "UTF-16LE" : "UTF-16BE", AutoDetectedEncoding);
511                     goto found;
512                 }
513                 
514                 // the HTTP-EQUIV meta has no effect on XHTML
515                 if (m_contentType == XML)
516                     goto found;
517
518                 if (*ptr == '/') {
519                     ++ptr;
520                     end=true;
521                 }
522
523                 char tmp[20];
524                 int len = 0;
525                 while (
526                     ((*ptr >= 'a') && (*ptr <= 'z') ||
527                      (*ptr >= 'A') && (*ptr <= 'Z') ||
528                      (*ptr >= '0') && (*ptr <= '9'))
529                     && len < 19 )
530                 {
531                     tmp[len] = tolower(*ptr);
532                     ptr++;
533                     len++;
534                 }
535                 tmp[len] = 0;
536                 AtomicString tag(tmp);
537                 
538                 if (tag == titleTag)
539                     withinTitle = !end;
540                 
541                 if (!end && tag == metaTag) {
542                     const char* end = ptr;
543                     while (*end != '>' && *end != '\0')
544                         end++;
545                     if (*end == '\0')
546                         break;
547                     DeprecatedCString str(ptr, (end-ptr)+1);
548                     str = str.lower();
549                     int pos = 0;
550                     while (pos < (int)str.length()) {
551                         if ((pos = str.find("charset", pos, false)) == -1)
552                             break;
553                         pos += 7;
554                         // skip whitespace..
555                         while (pos < (int)str.length() && str[pos] <= ' ')
556                             pos++;
557                         if (pos == (int)str.length())
558                             break;
559                         if (str[pos++] != '=')
560                             continue;
561                         while (pos < (int)str.length() &&
562                                 (str[pos] <= ' ') || str[pos] == '=' || str[pos] == '"' || str[pos] == '\'')
563                             pos++;
564
565                         // end ?
566                         if (pos == (int)str.length())
567                             break;
568                         unsigned endpos = pos;
569                         while (endpos < str.length() &&
570                                str[endpos] != ' ' && str[endpos] != '"' && str[endpos] != '\'' &&
571                                str[endpos] != ';' && str[endpos] != '>')
572                             endpos++;
573                         setEncodingName(str.mid(pos, endpos-pos), EncodingFromMetaTag);
574                         if (m_type == EncodingFromMetaTag)
575                             goto found;
576
577                         if (endpos >= str.length() || str[endpos] == '/' || str[endpos] == '>')
578                             break;
579
580                         pos = endpos + 1;
581                     }
582                 } else if (tag != scriptTag && tag != noscriptTag && tag != styleTag &&
583                            tag != linkTag && tag != metaTag && tag != objectTag &&
584                            tag != titleTag && tag != baseTag && 
585                            (end || tag != htmlTag) && !withinTitle &&
586                            (tag != headTag) && isalpha(tmp[0])) {
587                     m_reachedBody = true;
588                     goto found;
589                 }
590             }
591             else
592                 ptr++;
593         }
594         return DeprecatedString::null;
595     }
596
597  found:
598     // Do the auto-detect if our default encoding is one of the Japanese ones.
599     if (m_type != UserChosenEncoding && m_type != AutoDetectedEncoding && m_encoding.isJapanese()) {
600         const char *autoDetectedEncoding;
601         switch (KanjiCode::judge(data, len)) {
602             case KanjiCode::JIS:
603                 autoDetectedEncoding = "jis7";
604                 break;
605             case KanjiCode::EUC:
606                 autoDetectedEncoding = "eucjp";
607                 break;
608             case KanjiCode::SJIS:
609                 autoDetectedEncoding = "sjis";
610                 break;
611             default:
612                 autoDetectedEncoding = NULL;
613                 break;
614         }
615         if (autoDetectedEncoding)
616             setEncodingName(autoDetectedEncoding, AutoDetectedEncoding);
617     }
618
619     ASSERT(m_encoding.isValid());
620
621     DeprecatedString out;
622
623     if (!m_buffer.isEmpty()) {
624         if (!currentChunkInBuffer)
625             m_buffer.append(data, len);
626         out = m_decoder->toUnicode(m_buffer.latin1(), m_buffer.length());
627         m_buffer.truncate(0);
628     } else
629         out = m_decoder->toUnicode(data, len);
630
631     return out;
632 }
633
634 DeprecatedString Decoder::flush() const
635 {
636     return m_decoder->toUnicode(m_buffer.latin1(), m_buffer.length(), true);
637 }
638
639 // -----------------------------------------------------------------------------