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(defaultEncodingName.isNull() ? "iso8859-1" : defaultEncodingName.latin1())
 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     m_decoder.set(StreamingTextDecoder::create(m_encoding));
 276 }
 277
 278 Decoder::~Decoder()
 279 {
 280 }
 281
 282 void Decoder::setEncodingName(const char* encodingName, EncodingSource type)
 283 {
 284     m_encodingName = encodingName;
 285     m_encodingName = m_encodingName.lower();
 286
 287     if (m_encodingName.isEmpty())
 288         return;
 289
 290     bool eightBitOnly = type == EncodingFromMetaTag || type == EncodingFromXMLHeader || type == EncodingFromCSSCharset;
 291     TextEncoding encoding = TextEncoding(m_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();
 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                 m_type = AutoDetectedEncoding;
 413                 m_encoding = TextEncoding(autoDetectedEncoding);
 414                 ASSERT(m_encoding.isValid());
 415                 m_encodingName = m_encoding.name();
 416                 m_decoder.set(StreamingTextDecoder::create(m_encoding));
 417             }
 418         }
 419         m_checkedForBOM = true;
 420     }
 421
 422     bool currentChunkInBuffer = false;
 423
 424     if (m_type == DefaultEncoding && m_contentType == CSS && !m_checkedForCSSCharset) {
 425         m_buffer.append(data, len);
 426         currentChunkInBuffer = true;
 427
 428         if (len > 8) { // strlen("@charset") == 8
 429             const char* dataStart = m_buffer.latin1();
 430             const char* dataEnd = dataStart + m_buffer.length();
 431
 432             if (dataStart[0] == '@' && dataStart[1] == 'c' && dataStart[2] == 'h' && dataStart[3] == 'a' && dataStart[4] == 'r' &&
 433                 dataStart[5] == 's' && dataStart[6] == 'e' && dataStart[7] == 't') {
 434
 435                 dataStart += 8;
 436                 const char* pos = dataStart;
 437                 if (!skipWhitespace(pos, dataEnd))
 438                     return DeprecatedString::null;
 439
 440                 if (*pos == '"' || *pos == '\'') {
 441                     char quotationMark = *pos;
 442                     ++pos;
 443                     dataStart = pos;
 444
 445                     while (pos < dataEnd && *pos != quotationMark)
 446                         ++pos;
 447                     if (pos == dataEnd)
 448                         return DeprecatedString::null;
 449
 450                     DeprecatedCString encodingName(dataStart, pos - dataStart + 1);
 451
 452                     ++pos;
 453                     if (!skipWhitespace(pos, dataEnd))
 454                         return DeprecatedString::null;
 455
 456                     if (*pos == ';')
 457                         setEncodingName(encodingName, EncodingFromCSSCharset);
 458                 }
 459             }
 460             m_checkedForCSSCharset = true;
 461         }
 462         return DeprecatedString::null;
 463
 464     } else if (m_type == DefaultEncoding && m_contentType != PlainText && !m_reachedBody) { // HTML and XML
 465         // this is not completely efficient, since the function might go
 466         // through the html head several times...
 467
 468         m_buffer.append(data, len);
 469         currentChunkInBuffer = true;
 470
 471         // we still don't have an encoding, and are in the head
 472         // the following tags are allowed in <head>:
 473         // SCRIPT|STYLE|META|LINK|OBJECT|TITLE|BASE
 474
 475         // We stop scanning when a tag that is not permitted in <head>
 476         // is seen, rather when </head> is seen, because that more closely
 477         // matches behavior in other browsers; more details in
 478         // <http://bugzilla.opendarwin.org/show_bug.cgi?id=3590>.
 479
 480         // Additionally, we ignore things that looks like tags in <title>; see
 481         // <http://bugzilla.opendarwin.org/show_bug.cgi?id=4560>.
 482
 483         bool withinTitle = false;
 484
 485         const char *ptr = m_buffer.latin1();
 486         const char *pEnd = ptr + m_buffer.length();
 487         while (ptr != pEnd) {
 488             if (*ptr == '<') {
 489                 bool end = false;
 490                 ptr++;
 491
 492                 // Handle comments.
 493                 if (ptr[0] == '!' && ptr[1] == '-' && ptr[2] == '-') {
 494                     ptr += 3;
 495                     skipComment(ptr, pEnd);
 496                     continue;
 497                 }
 498
 499                 // Handle XML declaration, which can have encoding in it.
 500                 // This encoding is honored even for HTML documents.
 501                 if (ptr[0] == '?' && ptr[1] == 'x' && ptr[2] == 'm' && ptr[3] == 'l') {
 502                     const char *end = ptr;
 503                     while (*end != '>' && *end != '\0')
 504                         end++;
 505                     if (*end == '\0')
 506                         break;
 507                     DeprecatedCString str(ptr, end - ptr);
 508                     int len;
 509                     int pos = findXMLEncoding(str, len);
 510                     if (pos != -1)
 511                         setEncodingName(str.mid(pos, len), EncodingFromXMLHeader);
 512                     // continue looking for a charset - it may be specified in an HTTP-Equiv meta
 513                 } 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') {
 514                     // UTF-16 without BOM
 515                     setEncodingName(((ptr - m_buffer.latin1()) % 2) ? "UTF-16LE" : "UTF-16BE", AutoDetectedEncoding);
 516                     goto found;
 517                 }
 518
 519                 // the HTTP-EQUIV meta has no effect on XHTML
 520                 if (m_contentType == XML)
 521                     goto found;
 522
 523                 if (*ptr == '/') {
 524                     ++ptr;
 525                     end=true;
 526                 }
 527
 528                 char tmp[20];
 529                 int len = 0;
 530                 while (
 531                     ((*ptr >= 'a') && (*ptr <= 'z') ||
 532                      (*ptr >= 'A') && (*ptr <= 'Z') ||
 533                      (*ptr >= '0') && (*ptr <= '9'))
 534                     && len < 19 )
 535                 {
 536                     tmp[len] = tolower(*ptr);
 537                     ptr++;
 538                     len++;
 539                 }
 540                 tmp[len] = 0;
 541                 AtomicString tag(tmp);
 542
 543                 if (tag == titleTag)
 544                     withinTitle = !end;
 545
 546                 if (!end && tag == metaTag) {
 547                     const char* end = ptr;
 548                     while (*end != '>' && *end != '\0')
 549                         end++;
 550                     if (*end == '\0')
 551                         break;
 552                     DeprecatedCString str(ptr, (end-ptr)+1);
 553                     str = str.lower();
 554                     int pos = 0;
 555                     while (pos < (int)str.length()) {
 556                         if ((pos = str.find("charset", pos, false)) == -1)
 557                             break;
 558                         pos += 7;
 559                         // skip whitespace..
 560                         while (pos < (int)str.length() && str[pos] <= ' ')
 561                             pos++;
 562                         if (pos == (int)str.length())
 563                             break;
 564                         if (str[pos++] != '=')
 565                             continue;
 566                         while (pos < (int)str.length() &&
 567                                 (str[pos] <= ' ') || str[pos] == '=' || str[pos] == '"' || str[pos] == '\'')
 568                             pos++;
 569
 570                         // end ?
 571                         if (pos == (int)str.length())
 572                             break;
 573                         unsigned endpos = pos;
 574                         while (endpos < str.length() &&
 575                                str[endpos] != ' ' && str[endpos] != '"' && str[endpos] != '\'' &&
 576                                str[endpos] != ';' && str[endpos] != '>')
 577                             endpos++;
 578                         setEncodingName(str.mid(pos, endpos-pos), EncodingFromMetaTag);
 579                         if (m_type == EncodingFromMetaTag)
 580                             goto found;
 581
 582                         if (endpos >= str.length() || str[endpos] == '/' || str[endpos] == '>')
 583                             break;
 584
 585                         pos = endpos + 1;
 586                     }
 587                 } else if (tag != scriptTag && tag != noscriptTag && tag != styleTag &&
 588                            tag != linkTag && tag != metaTag && tag != objectTag &&
 589                            tag != titleTag && tag != baseTag &&
 590                            (end || tag != htmlTag) && !withinTitle &&
 591                            (tag != headTag) && isalpha(tmp[0])) {
 592                     m_reachedBody = true;
 593                     goto found;
 594                 }
 595             }
 596             else
 597                 ptr++;
 598         }
 599         return DeprecatedString::null;
 600     }
 601
 602  found:
 603     // Do the auto-detect if our default encoding is one of the Japanese ones.
 604     if (m_type != UserChosenEncoding && m_type != AutoDetectedEncoding && m_encoding.isJapanese()) {
 605         const char *autoDetectedEncoding;
 606         switch (KanjiCode::judge(data, len)) {
 607             case KanjiCode::JIS:
 608                 autoDetectedEncoding = "jis7";
 609                 break;
 610             case KanjiCode::EUC:
 611                 autoDetectedEncoding = "eucjp";
 612                 break;
 613             case KanjiCode::SJIS:
 614                 autoDetectedEncoding = "sjis";
 615                 break;
 616             default:
 617                 autoDetectedEncoding = NULL;
 618                 break;
 619         }
 620         if (autoDetectedEncoding)
 621             setEncodingName(autoDetectedEncoding, AutoDetectedEncoding);
 622     }
 623
 624     // If we still haven't found an encoding, assume latin1
 625     // (this can happen if an empty name is passed from outside).
 626     if (m_encodingName.isEmpty() || !m_encoding.isValid()) {
 627         m_encodingName = "iso8859-1";
 628         m_encoding = TextEncoding(Latin1Encoding);
 629     }
 630     m_decoder.set(StreamingTextDecoder::create(m_encoding));
 631
 632     DeprecatedString out;
 633
 634     if (!m_buffer.isEmpty()) {
 635         if (!currentChunkInBuffer)
 636             m_buffer.append(data, len);
 637         out = m_decoder->toUnicode(m_buffer.latin1(), m_buffer.length());
 638         m_buffer.truncate(0);
 639     } else
 640         out = m_decoder->toUnicode(data, len);
 641
 642     return out;
 643 }
 644
 645 DeprecatedString Decoder::flush() const
 646 {
 647     return m_decoder->toUnicode(m_buffer.latin1(), m_buffer.length(), true);
 648 }
 649
 650 // -----------------------------------------------------------------------------