X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f23e92e72ae94e775a9931ba3a9f40cbdf774c71..94a2af76726bde98e76f4417d33e91f10aea1771:/src/html/htmlpars.cpp?ds=inline

diff --git a/src/html/htmlpars.cpp b/src/html/htmlpars.cpp
index 57a7406d03..9d3bf3cb8e 100644
--- a/src/html/htmlpars.cpp
+++ b/src/html/htmlpars.cpp
@@ -1,29 +1,26 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        htmlpars.cpp
+// Name:        src/html/htmlpars.cpp
 // Purpose:     wxHtmlParser class (generic parser)
 // Author:      Vaclav Slavik
 // RCS-ID:      $Id$
 // Copyright:   (c) 1999 Vaclav Slavik
-// Licence:     wxWindows Licence
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
+#include "wx/wxprec.h"
 
-#ifdef __GNUG__
-#pragma implementation
+#ifdef __BORLANDC__
+    #pragma hdrstop
 #endif
 
-#include "wx/wxprec.h"
-
-#include "wx/defs.h"
 #if wxUSE_HTML && wxUSE_STREAMS
 
-#ifdef __BORDLANDC__
-#pragma hdrstop
-#endif
-
-#ifndef WXPRECOMP
+#ifndef WX_PRECOMP
+    #include "wx/dynarray.h"
     #include "wx/log.h"
     #include "wx/intl.h"
+    #include "wx/app.h"
+    #include "wx/wxcrtvararg.h"
 #endif
 
 #include "wx/tokenzr.h"
@@ -32,9 +29,17 @@
 #include "wx/fontmap.h"
 #include "wx/html/htmldefs.h"
 #include "wx/html/htmlpars.h"
-#include "wx/dynarray.h"
 #include "wx/arrimpl.cpp"
 
+#ifdef __WXWINCE__
+    #include "wx/msw/wince/missing.h"       // for bsearch()
+#endif
+
+// DLL options compatibility check:
+WX_CHECK_BUILD_OPTIONS("wxHTML")
+
+const wxChar *wxTRACE_HTML_DEBUG = _T("htmldebug");
+
 //-----------------------------------------------------------------------------
 // wxHtmlParser helpers
 //-----------------------------------------------------------------------------
@@ -47,7 +52,7 @@ public:
 };
 
 WX_DECLARE_OBJARRAY(wxHtmlTextPiece, wxHtmlTextPieces);
-WX_DEFINE_OBJARRAY(wxHtmlTextPieces);
+WX_DEFINE_OBJARRAY(wxHtmlTextPieces)
 
 class wxHtmlParserState
 {
@@ -80,22 +85,28 @@ wxHtmlParser::wxHtmlParser()
 
 wxHtmlParser::~wxHtmlParser()
 {
-    while (RestoreState())
-        DestroyDOMTree();
+    while (RestoreState()) {}
+    DestroyDOMTree();
+
+    if (m_HandlersStack)
+    {
+        wxList& tmp = *m_HandlersStack;
+        wxList::iterator it, en;
+        for( it = tmp.begin(), en = tmp.end(); it != en; ++it )
+            delete (wxHashTable*)*it;
+        tmp.clear();
+    }
     delete m_HandlersStack;
     m_HandlersHash.Clear();
-    m_HandlersList.DeleteContents(TRUE);
-    m_HandlersList.Clear();
+    WX_CLEAR_LIST(wxList, m_HandlersList);
     delete m_entitiesParser;
 }
 
 wxObject* wxHtmlParser::Parse(const wxString& source)
 {
-    wxObject *result;
-
     InitParser(source);
     DoParsing();
-    result = GetProduct();
+    wxObject *result = GetProduct();
     DoneParser();
     return result;
 }
@@ -103,6 +114,7 @@ wxObject* wxHtmlParser::Parse(const wxString& source)
 void wxHtmlParser::InitParser(const wxString& source)
 {
     SetSource(source);
+    m_stopParsing = false;
 }
 
 void wxHtmlParser::DoneParser()
@@ -123,10 +135,12 @@ void wxHtmlParser::CreateDOMTree()
 {
     wxHtmlTagsCache cache(m_Source);
     m_TextPieces = new wxHtmlTextPieces;
-    CreateDOMSubTree(NULL, 0, m_Source.Length(), &cache);
+    CreateDOMSubTree(NULL, 0, m_Source.length(), &cache);
     m_CurTextPiece = 0;
 }
 
+extern bool wxIsCDATAElement(const wxChar *tag);
+
 void wxHtmlParser::CreateDOMSubTree(wxHtmlTag *cur,
                                     int begin_pos, int end_pos,
                                     wxHtmlTagsCache *cache)
@@ -137,6 +151,15 @@ void wxHtmlParser::CreateDOMSubTree(wxHtmlTag *cur,
     int i = begin_pos;
     int textBeginning = begin_pos;
 
+    // If the tag contains CDATA text, we include the text between beginning
+    // and ending tag verbosely. Setting i=end_pos will skip to the very
+    // end of this function where text piece is added, bypassing any child
+    // tags parsing (CDATA element can't have child elements by definition):
+    if (cur != NULL && wxIsCDATAElement(cur->GetName().c_str()))
+    {
+        i = end_pos;
+    }
+
     while (i < end_pos)
     {
         c = m_Source.GetChar(i);
@@ -149,34 +172,16 @@ void wxHtmlParser::CreateDOMSubTree(wxHtmlTag *cur,
                     wxHtmlTextPiece(textBeginning, i - textBeginning));
 
             // if it is a comment, skip it:
-            if (i < end_pos-6 && m_Source.GetChar(i+1) == wxT('!') &&
-                                 m_Source.GetChar(i+2) == wxT('-') &&
-                                 m_Source.GetChar(i+3) == wxT('-'))
+            wxString::const_iterator iter = m_Source.begin() + i;
+            if ( SkipCommentTag(iter, m_Source.end()) )
             {
-                // Comments begin with "<!--" and end with "--[ \t\r\n]*>"
-                // according to HTML 4.0
-                int dashes = 0;
-                i += 4;
-                while (i < end_pos)
-                {
-                    c = m_Source.GetChar(i++);
-                    if ((c == wxT(' ') || c == wxT('\n') ||
-                        c == wxT('\r') || c == wxT('\t')) && dashes >= 2) {}
-                    else if (c == wxT('>') && dashes >= 2)
-                    {
-                        textBeginning = i;
-                        break;
-                    }
-                    else if (c == wxT('-'))
-                        dashes++;
-                    else
-                        dashes = 0;
-                }
+                textBeginning =
+                i = iter - m_Source.begin() + 1; // skip closing '>' too
             }
 
             // add another tag to the tree:
             else if (i < end_pos-1 && m_Source.GetChar(i+1) != wxT('/'))
-	        {
+            {
                 wxHtmlTag *chd;
                 if (cur)
                     chd = new wxHtmlTag(cur, m_Source,
@@ -209,6 +214,7 @@ void wxHtmlParser::CreateDOMSubTree(wxHtmlTag *cur,
                 }
                 else
                     i = chd->GetBeginPos();
+
                 textBeginning = i;
             }
 
@@ -248,7 +254,7 @@ void wxHtmlParser::DoParsing()
 {
     m_CurTag = m_Tags;
     m_CurTextPiece = 0;
-    DoParsing(0, m_Source.Length());
+    DoParsing(0, m_Source.length());
 }
 
 void wxHtmlParser::DoParsing(int begin_pos, int end_pos)
@@ -280,17 +286,15 @@ void wxHtmlParser::DoParsing(int begin_pos, int end_pos)
         }
         else if (m_CurTag)
         {
-            // Add tag:
-            if (m_CurTag)
-            {
-                if (m_CurTag->HasEnding())
-                    begin_pos = m_CurTag->GetEndPos2();
-                else
-                    begin_pos = m_CurTag->GetBeginPos();
-            }
+            if (m_CurTag->HasEnding())
+                begin_pos = m_CurTag->GetEndPos2();
+            else
+                begin_pos = m_CurTag->GetBeginPos();
             wxHtmlTag *t = m_CurTag;
             m_CurTag = m_CurTag->GetNextTag();
             AddTag(*t);
+            if (m_stopParsing)
+                return;
         }
         else break;
     }
@@ -299,11 +303,15 @@ void wxHtmlParser::DoParsing(int begin_pos, int end_pos)
 void wxHtmlParser::AddTag(const wxHtmlTag& tag)
 {
     wxHtmlTagHandler *h;
-    bool inner = FALSE;
+    bool inner = false;
 
     h = (wxHtmlTagHandler*) m_HandlersHash.Get(tag.GetName());
     if (h)
+    {
         inner = h->HandleTag(tag);
+        if (m_stopParsing)
+            return;
+    }
     if (!inner)
     {
         if (tag.HasEnding())
@@ -317,7 +325,7 @@ void wxHtmlParser::AddTagHandler(wxHtmlTagHandler *handler)
     wxStringTokenizer tokenizer(s, wxT(", "));
 
     while (tokenizer.HasMoreTokens())
-        m_HandlersHash.Put(tokenizer.NextToken(), handler);
+        m_HandlersHash.Put(tokenizer.GetNextToken(), handler);
 
     if (m_HandlersList.IndexOf(handler) == wxNOT_FOUND)
         m_HandlersList.Append(handler);
@@ -325,7 +333,7 @@ void wxHtmlParser::AddTagHandler(wxHtmlTagHandler *handler)
     handler->SetParser(this);
 }
 
-void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
+void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, const wxString& tags)
 {
     wxStringTokenizer tokenizer(tags, wxT(", "));
     wxString key;
@@ -333,14 +341,13 @@ void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
     if (m_HandlersStack == NULL)
     {
         m_HandlersStack = new wxList;
-        m_HandlersStack->DeleteContents(TRUE);
     }
 
-    m_HandlersStack->Insert(new wxHashTable(m_HandlersHash));
+    m_HandlersStack->Insert((wxObject*)new wxHashTable(m_HandlersHash));
 
     while (tokenizer.HasMoreTokens())
     {
-        key = tokenizer.NextToken();
+        key = tokenizer.GetNextToken();
         m_HandlersHash.Delete(key);
         m_HandlersHash.Put(key, handler);
     }
@@ -348,16 +355,22 @@ void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
 
 void wxHtmlParser::PopTagHandler()
 {
-    wxNode *first;
-
-    if (m_HandlersStack == NULL ||
-        (first = m_HandlersStack->GetFirst()) == NULL)
+    wxList::compatibility_iterator first;
+
+    if ( !m_HandlersStack ||
+#if wxUSE_STL
+         !(first = m_HandlersStack->GetFirst())
+#else // !wxUSE_STL
+         ((first = m_HandlersStack->GetFirst()) == NULL)
+#endif // wxUSE_STL/!wxUSE_STL
+        )
     {
         wxLogWarning(_("Warning: attempt to remove HTML tag handler from empty stack."));
         return;
     }
     m_HandlersHash = *((wxHashTable*) first->GetData());
-    m_HandlersStack->DeleteNode(first);
+    delete (wxHashTable*) first->GetData();
+    m_HandlersStack->Erase(first);
 }
 
 void wxHtmlParser::SetSourceAndSaveState(const wxString& src)
@@ -384,7 +397,9 @@ void wxHtmlParser::SetSourceAndSaveState(const wxString& src)
 
 bool wxHtmlParser::RestoreState()
 {
-    if (!m_SavedStates) return FALSE;
+    if (!m_SavedStates) return false;
+
+    DestroyDOMTree();
 
     wxHtmlParserState *s = m_SavedStates;
     m_SavedStates = s->m_nextState;
@@ -396,7 +411,13 @@ bool wxHtmlParser::RestoreState()
     m_Source = s->m_source;
 
     delete s;
-    return TRUE;
+    return true;
+}
+
+wxString wxHtmlParser::GetInnerSource(const wxHtmlTag& tag)
+{
+    return GetSource()->Mid(tag.GetBeginPos(),
+                            tag.GetEndPos1() - tag.GetBeginPos());
 }
 
 //-----------------------------------------------------------------------------
@@ -405,6 +426,15 @@ bool wxHtmlParser::RestoreState()
 
 IMPLEMENT_ABSTRACT_CLASS(wxHtmlTagHandler,wxObject)
 
+void wxHtmlTagHandler::ParseInnerSource(const wxString& source)
+{
+    // It is safe to temporarily change the source being parsed,
+    // provided we restore the state back after parsing
+    m_Parser->SetSourceAndSaveState(source);
+    m_Parser->DoParsing();
+    m_Parser->RestoreState();
+}
+
 
 //-----------------------------------------------------------------------------
 // wxHtmlEntitiesParser
@@ -429,11 +459,15 @@ wxHtmlEntitiesParser::~wxHtmlEntitiesParser()
 void wxHtmlEntitiesParser::SetEncoding(wxFontEncoding encoding)
 {
 #if wxUSE_WCHAR_T && !wxUSE_UNICODE
-    if (encoding == m_encoding) return;
+    if (encoding == m_encoding)
+        return;
+
     delete m_conv;
-    m_conv = NULL;
+
     m_encoding = encoding;
-    if (m_encoding != wxFONTENCODING_SYSTEM)
+    if (m_encoding == wxFONTENCODING_SYSTEM)
+        m_conv = NULL;
+    else
         m_conv = new wxCSConv(wxFontMapper::GetEncodingName(m_encoding));
 #else
     (void) encoding;
@@ -446,15 +480,21 @@ wxString wxHtmlEntitiesParser::Parse(const wxString& input)
     const wxChar *in_str = input.c_str();
     wxString output;
 
+    output.reserve(input.length());
+
     for (c = in_str, last = in_str; *c != wxT('\0'); c++)
     {
         if (*c == wxT('&'))
         {
             if (c - last > 0)
                 output.append(last, c - last);
-            if (++c == wxT('\0')) break;
+            if ( *++c == wxT('\0') )
+                break;
+
             wxString entity;
             const wxChar *ent_s = c;
+            wxChar entity_char;
+
             for (; (*c >= wxT('a') && *c <= wxT('z')) ||
                    (*c >= wxT('A') && *c <= wxT('Z')) ||
                    (*c >= wxT('0') && *c <= wxT('9')) ||
@@ -462,7 +502,16 @@ wxString wxHtmlEntitiesParser::Parse(const wxString& input)
             entity.append(ent_s, c - ent_s);
             if (*c != wxT(';')) c--;
             last = c+1;
-            output << GetEntityChar(entity);
+            entity_char = GetEntityChar(entity);
+            if (entity_char)
+                output << entity_char;
+            else
+            {
+                output.append(ent_s-1, c-ent_s+2);
+                wxLogTrace(wxTRACE_HTML_DEBUG,
+                           wxT("Unrecognized HTML entity: '%s'"),
+                           entity.c_str());
+            }
         }
     }
     if (*last != wxT('\0'))
@@ -470,22 +519,10 @@ wxString wxHtmlEntitiesParser::Parse(const wxString& input)
     return output;
 }
 
-struct wxHtmlEntityInfo
-{
-    const wxChar *name;
-    unsigned code;
-};
-
-static int LINKAGEMODE compar_entity(const void *key, const void *item)
-{
-    return wxStrcmp((wxChar*)key, ((wxHtmlEntityInfo*)item)->name);
-}
-
+#if !wxUSE_UNICODE
 wxChar wxHtmlEntitiesParser::GetCharForCode(unsigned code)
 {
-#if wxUSE_UNICODE
-    return (wxChar)code;
-#elif wxUSE_WCHAR_T
+#if wxUSE_WCHAR_T
     char buf[2];
     wchar_t wbuf[2];
     wbuf[0] = (wchar_t)code;
@@ -498,6 +535,22 @@ wxChar wxHtmlEntitiesParser::GetCharForCode(unsigned code)
     return (code < 256) ? (wxChar)code : '?';
 #endif
 }
+#endif
+
+struct wxHtmlEntityInfo
+{
+    const wxStringCharType *name;
+    unsigned code;
+};
+
+extern "C" int LINKAGEMODE wxHtmlEntityCompare(const void *key, const void *item)
+{
+#if wxUSE_UNICODE_UTF8
+    return strcmp((char*)key, ((wxHtmlEntityInfo*)item)->name);
+#else
+    return wxStrcmp((wxChar*)key, ((wxHtmlEntityInfo*)item)->name);
+#endif
+}
 
 wxChar wxHtmlEntitiesParser::GetEntityChar(const wxString& entity)
 {
@@ -522,279 +575,423 @@ wxChar wxHtmlEntitiesParser::GetEntityChar(const wxString& entity)
     }
     else
     {
+        // store the literals in wx's internal representation (either char*
+        // in UTF-8 or wchar_t*) for best performance:
+        #define ENTITY(name, code) { wxSTRING_TEXT(name), code }
+
         static wxHtmlEntityInfo substitutions[] = {
-            { wxT("AElig"),198 },
-            { wxT("Aacute"),193 },
-            { wxT("Acirc"),194 },
-            { wxT("Agrave"),192 },
-            { wxT("Alpha"),913 },
-            { wxT("Aring"),197 },
-            { wxT("Atilde"),195 },
-            { wxT("Auml"),196 },
-            { wxT("Beta"),914 },
-            { wxT("Ccedil"),199 },
-            { wxT("Chi"),935 },
-            { wxT("Dagger"),8225 },
-            { wxT("Delta"),916 },
-            { wxT("ETH"),208 },
-            { wxT("Eacute"),201 },
-            { wxT("Ecirc"),202 },
-            { wxT("Egrave"),200 },
-            { wxT("Epsilon"),917 },
-            { wxT("Eta"),919 },
-            { wxT("Euml"),203 },
-            { wxT("Gamma"),915 },
-            { wxT("Iacute"),205 },
-            { wxT("Icirc"),206 },
-            { wxT("Igrave"),204 },
-            { wxT("Iota"),921 },
-            { wxT("Iuml"),207 },
-            { wxT("Kappa"),922 },
-            { wxT("Lambda"),923 },
-            { wxT("Mu"),924 },
-            { wxT("Ntilde"),209 },
-            { wxT("Nu"),925 },
-            { wxT("OElig"),338 },
-            { wxT("Oacute"),211 },
-            { wxT("Ocirc"),212 },
-            { wxT("Ograve"),210 },
-            { wxT("Omega"),937 },
-            { wxT("Omicron"),927 },
-            { wxT("Oslash"),216 },
-            { wxT("Otilde"),213 },
-            { wxT("Ouml"),214 },
-            { wxT("Phi"),934 },
-            { wxT("Pi"),928 },
-            { wxT("Prime"),8243 },
-            { wxT("Psi"),936 },
-            { wxT("Rho"),929 },
-            { wxT("Scaron"),352 },
-            { wxT("Sigma"),931 },
-            { wxT("THORN"),222 },
-            { wxT("Tau"),932 },
-            { wxT("Theta"),920 },
-            { wxT("Uacute"),218 },
-            { wxT("Ucirc"),219 },
-            { wxT("Ugrave"),217 },
-            { wxT("Upsilon"),933 },
-            { wxT("Uuml"),220 },
-            { wxT("Xi"),926 },
-            { wxT("Yacute"),221 },
-            { wxT("Yuml"),376 },
-            { wxT("Zeta"),918 },
-            { wxT("aacute"),225 },
-            { wxT("acirc"),226 },
-            { wxT("acute"),180 },
-            { wxT("aelig"),230 },
-            { wxT("agrave"),224 },
-            { wxT("alefsym"),8501 },
-            { wxT("alpha"),945 },
-            { wxT("amp"),38 },
-            { wxT("and"),8743 },
-            { wxT("ang"),8736 },
-            { wxT("aring"),229 },
-            { wxT("asymp"),8776 },
-            { wxT("atilde"),227 },
-            { wxT("auml"),228 },
-            { wxT("bdquo"),8222 },
-            { wxT("beta"),946 },
-            { wxT("brvbar"),166 },
-            { wxT("bull"),8226 },
-            { wxT("cap"),8745 },
-            { wxT("ccedil"),231 },
-            { wxT("cedil"),184 },
-            { wxT("cent"),162 },
-            { wxT("chi"),967 },
-            { wxT("circ"),710 },
-            { wxT("clubs"),9827 },
-            { wxT("cong"),8773 },
-            { wxT("copy"),169 },
-            { wxT("crarr"),8629 },
-            { wxT("cup"),8746 },
-            { wxT("curren"),164 },
-            { wxT("dArr"),8659 },
-            { wxT("dagger"),8224 },
-            { wxT("darr"),8595 },
-            { wxT("deg"),176 },
-            { wxT("delta"),948 },
-            { wxT("diams"),9830 },
-            { wxT("divide"),247 },
-            { wxT("eacute"),233 },
-            { wxT("ecirc"),234 },
-            { wxT("egrave"),232 },
-            { wxT("empty"),8709 },
-            { wxT("emsp"),8195 },
-            { wxT("ensp"),8194 },
-            { wxT("epsilon"),949 },
-            { wxT("equiv"),8801 },
-            { wxT("eta"),951 },
-            { wxT("eth"),240 },
-            { wxT("euml"),235 },
-            { wxT("euro"),8364 },
-            { wxT("exist"),8707 },
-            { wxT("fnof"),402 },
-            { wxT("forall"),8704 },
-            { wxT("frac12"),189 },
-            { wxT("frac14"),188 },
-            { wxT("frac34"),190 },
-            { wxT("frasl"),8260 },
-            { wxT("gamma"),947 },
-            { wxT("ge"),8805 },
-            { wxT("gt"),62 },
-            { wxT("hArr"),8660 },
-            { wxT("harr"),8596 },
-            { wxT("hearts"),9829 },
-            { wxT("hellip"),8230 },
-            { wxT("iacute"),237 },
-            { wxT("icirc"),238 },
-            { wxT("iexcl"),161 },
-            { wxT("igrave"),236 },
-            { wxT("image"),8465 },
-            { wxT("infin"),8734 },
-            { wxT("int"),8747 },
-            { wxT("iota"),953 },
-            { wxT("iquest"),191 },
-            { wxT("isin"),8712 },
-            { wxT("iuml"),239 },
-            { wxT("kappa"),954 },
-            { wxT("lArr"),8656 },
-            { wxT("lambda"),955 },
-            { wxT("lang"),9001 },
-            { wxT("laquo"),171 },
-            { wxT("larr"),8592 },
-            { wxT("lceil"),8968 },
-            { wxT("ldquo"),8220 },
-            { wxT("le"),8804 },
-            { wxT("lfloor"),8970 },
-            { wxT("lowast"),8727 },
-            { wxT("loz"),9674 },
-            { wxT("lrm"),8206 },
-            { wxT("lsaquo"),8249 },
-            { wxT("lsquo"),8216 },
-            { wxT("lt"),60 },
-            { wxT("macr"),175 },
-            { wxT("mdash"),8212 },
-            { wxT("micro"),181 },
-            { wxT("middot"),183 },
-            { wxT("minus"),8722 },
-            { wxT("mu"),956 },
-            { wxT("nabla"),8711 },
-            { wxT("nbsp"),160 },
-            { wxT("ndash"),8211 },
-            { wxT("ne"),8800 },
-            { wxT("ni"),8715 },
-            { wxT("not"),172 },
-            { wxT("notin"),8713 },
-            { wxT("nsub"),8836 },
-            { wxT("ntilde"),241 },
-            { wxT("nu"),957 },
-            { wxT("oacute"),243 },
-            { wxT("ocirc"),244 },
-            { wxT("oelig"),339 },
-            { wxT("ograve"),242 },
-            { wxT("oline"),8254 },
-            { wxT("omega"),969 },
-            { wxT("omicron"),959 },
-            { wxT("oplus"),8853 },
-            { wxT("or"),8744 },
-            { wxT("ordf"),170 },
-            { wxT("ordm"),186 },
-            { wxT("oslash"),248 },
-            { wxT("otilde"),245 },
-            { wxT("otimes"),8855 },
-            { wxT("ouml"),246 },
-            { wxT("para"),182 },
-            { wxT("part"),8706 },
-            { wxT("permil"),8240 },
-            { wxT("perp"),8869 },
-            { wxT("phi"),966 },
-            { wxT("pi"),960 },
-            { wxT("piv"),982 },
-            { wxT("plusmn"),177 },
-            { wxT("pound"),163 },
-            { wxT("prime"),8242 },
-            { wxT("prod"),8719 },
-            { wxT("prop"),8733 },
-            { wxT("psi"),968 },
-            { wxT("quot"),34 },
-            { wxT("rArr"),8658 },
-            { wxT("radic"),8730 },
-            { wxT("rang"),9002 },
-            { wxT("raquo"),187 },
-            { wxT("rarr"),8594 },
-            { wxT("rceil"),8969 },
-            { wxT("rdquo"),8221 },
-            { wxT("real"),8476 },
-            { wxT("reg"),174 },
-            { wxT("rfloor"),8971 },
-            { wxT("rho"),961 },
-            { wxT("rlm"),8207 },
-            { wxT("rsaquo"),8250 },
-            { wxT("rsquo"),8217 },
-            { wxT("sbquo"),8218 },
-            { wxT("scaron"),353 },
-            { wxT("sdot"),8901 },
-            { wxT("sect"),167 },
-            { wxT("shy"),173 },
-            { wxT("sigma"),963 },
-            { wxT("sigmaf"),962 },
-            { wxT("sim"),8764 },
-            { wxT("spades"),9824 },
-            { wxT("sub"),8834 },
-            { wxT("sube"),8838 },
-            { wxT("sum"),8721 },
-            { wxT("sup"),8835 },
-            { wxT("sup1"),185 },
-            { wxT("sup2"),178 },
-            { wxT("sup3"),179 },
-            { wxT("supe"),8839 },
-            { wxT("szlig"),223 },
-            { wxT("tau"),964 },
-            { wxT("there4"),8756 },
-            { wxT("theta"),952 },
-            { wxT("thetasym"),977 },
-            { wxT("thinsp"),8201 },
-            { wxT("thorn"),254 },
-            { wxT("tilde"),732 },
-            { wxT("times"),215 },
-            { wxT("trade"),8482 },
-            { wxT("uArr"),8657 },
-            { wxT("uacute"),250 },
-            { wxT("uarr"),8593 },
-            { wxT("ucirc"),251 },
-            { wxT("ugrave"),249 },
-            { wxT("uml"),168 },
-            { wxT("upsih"),978 },
-            { wxT("upsilon"),965 },
-            { wxT("uuml"),252 },
-            { wxT("weierp"),8472 },
-            { wxT("xi"),958 },
-            { wxT("yacute"),253 },
-            { wxT("yen"),165 },
-            { wxT("yuml"),255 },
-            { wxT("zeta"),950 },
-            { wxT("zwj"),8205 },
-            { wxT("zwnj"),8204 },
+            ENTITY("AElig", 198),
+            ENTITY("Aacute", 193),
+            ENTITY("Acirc", 194),
+            ENTITY("Agrave", 192),
+            ENTITY("Alpha", 913),
+            ENTITY("Aring", 197),
+            ENTITY("Atilde", 195),
+            ENTITY("Auml", 196),
+            ENTITY("Beta", 914),
+            ENTITY("Ccedil", 199),
+            ENTITY("Chi", 935),
+            ENTITY("Dagger", 8225),
+            ENTITY("Delta", 916),
+            ENTITY("ETH", 208),
+            ENTITY("Eacute", 201),
+            ENTITY("Ecirc", 202),
+            ENTITY("Egrave", 200),
+            ENTITY("Epsilon", 917),
+            ENTITY("Eta", 919),
+            ENTITY("Euml", 203),
+            ENTITY("Gamma", 915),
+            ENTITY("Iacute", 205),
+            ENTITY("Icirc", 206),
+            ENTITY("Igrave", 204),
+            ENTITY("Iota", 921),
+            ENTITY("Iuml", 207),
+            ENTITY("Kappa", 922),
+            ENTITY("Lambda", 923),
+            ENTITY("Mu", 924),
+            ENTITY("Ntilde", 209),
+            ENTITY("Nu", 925),
+            ENTITY("OElig", 338),
+            ENTITY("Oacute", 211),
+            ENTITY("Ocirc", 212),
+            ENTITY("Ograve", 210),
+            ENTITY("Omega", 937),
+            ENTITY("Omicron", 927),
+            ENTITY("Oslash", 216),
+            ENTITY("Otilde", 213),
+            ENTITY("Ouml", 214),
+            ENTITY("Phi", 934),
+            ENTITY("Pi", 928),
+            ENTITY("Prime", 8243),
+            ENTITY("Psi", 936),
+            ENTITY("Rho", 929),
+            ENTITY("Scaron", 352),
+            ENTITY("Sigma", 931),
+            ENTITY("THORN", 222),
+            ENTITY("Tau", 932),
+            ENTITY("Theta", 920),
+            ENTITY("Uacute", 218),
+            ENTITY("Ucirc", 219),
+            ENTITY("Ugrave", 217),
+            ENTITY("Upsilon", 933),
+            ENTITY("Uuml", 220),
+            ENTITY("Xi", 926),
+            ENTITY("Yacute", 221),
+            ENTITY("Yuml", 376),
+            ENTITY("Zeta", 918),
+            ENTITY("aacute", 225),
+            ENTITY("acirc", 226),
+            ENTITY("acute", 180),
+            ENTITY("aelig", 230),
+            ENTITY("agrave", 224),
+            ENTITY("alefsym", 8501),
+            ENTITY("alpha", 945),
+            ENTITY("amp", 38),
+            ENTITY("and", 8743),
+            ENTITY("ang", 8736),
+            ENTITY("aring", 229),
+            ENTITY("asymp", 8776),
+            ENTITY("atilde", 227),
+            ENTITY("auml", 228),
+            ENTITY("bdquo", 8222),
+            ENTITY("beta", 946),
+            ENTITY("brvbar", 166),
+            ENTITY("bull", 8226),
+            ENTITY("cap", 8745),
+            ENTITY("ccedil", 231),
+            ENTITY("cedil", 184),
+            ENTITY("cent", 162),
+            ENTITY("chi", 967),
+            ENTITY("circ", 710),
+            ENTITY("clubs", 9827),
+            ENTITY("cong", 8773),
+            ENTITY("copy", 169),
+            ENTITY("crarr", 8629),
+            ENTITY("cup", 8746),
+            ENTITY("curren", 164),
+            ENTITY("dArr", 8659),
+            ENTITY("dagger", 8224),
+            ENTITY("darr", 8595),
+            ENTITY("deg", 176),
+            ENTITY("delta", 948),
+            ENTITY("diams", 9830),
+            ENTITY("divide", 247),
+            ENTITY("eacute", 233),
+            ENTITY("ecirc", 234),
+            ENTITY("egrave", 232),
+            ENTITY("empty", 8709),
+            ENTITY("emsp", 8195),
+            ENTITY("ensp", 8194),
+            ENTITY("epsilon", 949),
+            ENTITY("equiv", 8801),
+            ENTITY("eta", 951),
+            ENTITY("eth", 240),
+            ENTITY("euml", 235),
+            ENTITY("euro", 8364),
+            ENTITY("exist", 8707),
+            ENTITY("fnof", 402),
+            ENTITY("forall", 8704),
+            ENTITY("frac12", 189),
+            ENTITY("frac14", 188),
+            ENTITY("frac34", 190),
+            ENTITY("frasl", 8260),
+            ENTITY("gamma", 947),
+            ENTITY("ge", 8805),
+            ENTITY("gt", 62),
+            ENTITY("hArr", 8660),
+            ENTITY("harr", 8596),
+            ENTITY("hearts", 9829),
+            ENTITY("hellip", 8230),
+            ENTITY("iacute", 237),
+            ENTITY("icirc", 238),
+            ENTITY("iexcl", 161),
+            ENTITY("igrave", 236),
+            ENTITY("image", 8465),
+            ENTITY("infin", 8734),
+            ENTITY("int", 8747),
+            ENTITY("iota", 953),
+            ENTITY("iquest", 191),
+            ENTITY("isin", 8712),
+            ENTITY("iuml", 239),
+            ENTITY("kappa", 954),
+            ENTITY("lArr", 8656),
+            ENTITY("lambda", 955),
+            ENTITY("lang", 9001),
+            ENTITY("laquo", 171),
+            ENTITY("larr", 8592),
+            ENTITY("lceil", 8968),
+            ENTITY("ldquo", 8220),
+            ENTITY("le", 8804),
+            ENTITY("lfloor", 8970),
+            ENTITY("lowast", 8727),
+            ENTITY("loz", 9674),
+            ENTITY("lrm", 8206),
+            ENTITY("lsaquo", 8249),
+            ENTITY("lsquo", 8216),
+            ENTITY("lt", 60),
+            ENTITY("macr", 175),
+            ENTITY("mdash", 8212),
+            ENTITY("micro", 181),
+            ENTITY("middot", 183),
+            ENTITY("minus", 8722),
+            ENTITY("mu", 956),
+            ENTITY("nabla", 8711),
+            ENTITY("nbsp", 160),
+            ENTITY("ndash", 8211),
+            ENTITY("ne", 8800),
+            ENTITY("ni", 8715),
+            ENTITY("not", 172),
+            ENTITY("notin", 8713),
+            ENTITY("nsub", 8836),
+            ENTITY("ntilde", 241),
+            ENTITY("nu", 957),
+            ENTITY("oacute", 243),
+            ENTITY("ocirc", 244),
+            ENTITY("oelig", 339),
+            ENTITY("ograve", 242),
+            ENTITY("oline", 8254),
+            ENTITY("omega", 969),
+            ENTITY("omicron", 959),
+            ENTITY("oplus", 8853),
+            ENTITY("or", 8744),
+            ENTITY("ordf", 170),
+            ENTITY("ordm", 186),
+            ENTITY("oslash", 248),
+            ENTITY("otilde", 245),
+            ENTITY("otimes", 8855),
+            ENTITY("ouml", 246),
+            ENTITY("para", 182),
+            ENTITY("part", 8706),
+            ENTITY("permil", 8240),
+            ENTITY("perp", 8869),
+            ENTITY("phi", 966),
+            ENTITY("pi", 960),
+            ENTITY("piv", 982),
+            ENTITY("plusmn", 177),
+            ENTITY("pound", 163),
+            ENTITY("prime", 8242),
+            ENTITY("prod", 8719),
+            ENTITY("prop", 8733),
+            ENTITY("psi", 968),
+            ENTITY("quot", 34),
+            ENTITY("rArr", 8658),
+            ENTITY("radic", 8730),
+            ENTITY("rang", 9002),
+            ENTITY("raquo", 187),
+            ENTITY("rarr", 8594),
+            ENTITY("rceil", 8969),
+            ENTITY("rdquo", 8221),
+            ENTITY("real", 8476),
+            ENTITY("reg", 174),
+            ENTITY("rfloor", 8971),
+            ENTITY("rho", 961),
+            ENTITY("rlm", 8207),
+            ENTITY("rsaquo", 8250),
+            ENTITY("rsquo", 8217),
+            ENTITY("sbquo", 8218),
+            ENTITY("scaron", 353),
+            ENTITY("sdot", 8901),
+            ENTITY("sect", 167),
+            ENTITY("shy", 173),
+            ENTITY("sigma", 963),
+            ENTITY("sigmaf", 962),
+            ENTITY("sim", 8764),
+            ENTITY("spades", 9824),
+            ENTITY("sub", 8834),
+            ENTITY("sube", 8838),
+            ENTITY("sum", 8721),
+            ENTITY("sup", 8835),
+            ENTITY("sup1", 185),
+            ENTITY("sup2", 178),
+            ENTITY("sup3", 179),
+            ENTITY("supe", 8839),
+            ENTITY("szlig", 223),
+            ENTITY("tau", 964),
+            ENTITY("there4", 8756),
+            ENTITY("theta", 952),
+            ENTITY("thetasym", 977),
+            ENTITY("thinsp", 8201),
+            ENTITY("thorn", 254),
+            ENTITY("tilde", 732),
+            ENTITY("times", 215),
+            ENTITY("trade", 8482),
+            ENTITY("uArr", 8657),
+            ENTITY("uacute", 250),
+            ENTITY("uarr", 8593),
+            ENTITY("ucirc", 251),
+            ENTITY("ugrave", 249),
+            ENTITY("uml", 168),
+            ENTITY("upsih", 978),
+            ENTITY("upsilon", 965),
+            ENTITY("uuml", 252),
+            ENTITY("weierp", 8472),
+            ENTITY("xi", 958),
+            ENTITY("yacute", 253),
+            ENTITY("yen", 165),
+            ENTITY("yuml", 255),
+            ENTITY("zeta", 950),
+            ENTITY("zwj", 8205),
+            ENTITY("zwnj", 8204),
             {NULL, 0}};
+        #undef ENTITY
         static size_t substitutions_cnt = 0;
 
         if (substitutions_cnt == 0)
             while (substitutions[substitutions_cnt].code != 0)
                 substitutions_cnt++;
 
-        wxHtmlEntityInfo *info;
-        info = (wxHtmlEntityInfo*) bsearch(entity.c_str(), substitutions,
+        wxHtmlEntityInfo *info = NULL;
+#ifdef __WXWINCE__
+        // bsearch crashes under WinCE for some reason
+        size_t i;
+        for (i = 0; i < substitutions_cnt; i++)
+        {
+            if (entity == substitutions[i].name)
+            {
+                info = & substitutions[i];
+                break;
+            }
+        }
+#else
+        info = (wxHtmlEntityInfo*) bsearch(entity.wx_str(), substitutions,
                                            substitutions_cnt,
                                            sizeof(wxHtmlEntityInfo),
-                                           compar_entity);
+                                           wxHtmlEntityCompare);
+#endif
         if (info)
             code = info->code;
     }
 
     if (code == 0)
-        return wxT('?');
+        return 0;
     else
         return GetCharForCode(code);
 }
 
-#endif
+wxFSFile *wxHtmlParser::OpenURL(wxHtmlURLType WXUNUSED(type),
+                                const wxString& url) const
+{
+    return m_FS ? m_FS->OpenFile(url) : NULL;
+
+}
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlParser::ExtractCharsetInformation
+//-----------------------------------------------------------------------------
+
+class wxMetaTagParser : public wxHtmlParser
+{
+public:
+    wxMetaTagParser() { }
+
+    wxObject* GetProduct() { return NULL; }
+
+protected:
+    virtual void AddText(const wxString& WXUNUSED(txt)) {}
+
+    DECLARE_NO_COPY_CLASS(wxMetaTagParser)
+};
+
+class wxMetaTagHandler : public wxHtmlTagHandler
+{
+public:
+    wxMetaTagHandler(wxString *retval) : wxHtmlTagHandler(), m_retval(retval) {}
+    wxString GetSupportedTags() { return wxT("META,BODY"); }
+    bool HandleTag(const wxHtmlTag& tag);
+
+private:
+    wxString *m_retval;
+
+    DECLARE_NO_COPY_CLASS(wxMetaTagHandler)
+};
+
+bool wxMetaTagHandler::HandleTag(const wxHtmlTag& tag)
+{
+    if (tag.GetName() == _T("BODY"))
+    {
+        m_Parser->StopParsing();
+        return false;
+    }
+
+    if (tag.HasParam(_T("HTTP-EQUIV")) &&
+        tag.GetParam(_T("HTTP-EQUIV")).IsSameAs(_T("Content-Type"), false) &&
+        tag.HasParam(_T("CONTENT")))
+    {
+        wxString content = tag.GetParam(_T("CONTENT")).Lower();
+        if (content.Left(19) == _T("text/html; charset="))
+        {
+            *m_retval = content.Mid(19);
+            m_Parser->StopParsing();
+        }
+    }
+    return false;
+}
+
+
+/*static*/
+wxString wxHtmlParser::ExtractCharsetInformation(const wxString& markup)
+{
+    wxString charset;
+    wxMetaTagParser *parser = new wxMetaTagParser();
+    if(parser)
+    {
+        parser->AddTagHandler(new wxMetaTagHandler(&charset));
+        parser->Parse(markup);
+        delete parser;
+    }
+    return charset;
+}
+
+/* static */
+bool
+wxHtmlParser::SkipCommentTag(wxString::const_iterator& start,
+                             wxString::const_iterator end)
+{
+    wxASSERT_MSG( *start == '<', _T("should be called on the tag start") );
+
+    wxString::const_iterator p = start;
+
+    // comments begin with "<!--" in HTML 4.0
+    if ( end - p < 3 || *++p != '!' || *++p != '-' || *++p != '-' )
+    {
+        // not a comment at all
+        return false;
+    }
+
+    // skip the start of the comment tag in any case, if we don't find the
+    // closing tag we should ignore broken markup
+    start = p;
+
+    // comments end with "--[ \t\r\n]*>", i.e. white space is allowed between
+    // comment delimiter and the closing tag character (section 3.2.4 of
+    // http://www.w3.org/TR/html401/)
+    int dashes = 0;
+    while ( ++p < end )
+    {
+        const wxChar c = *p;
+
+        if ( (c == wxT(' ') || c == wxT('\n') ||
+              c == wxT('\r') || c == wxT('\t')) && dashes >= 2 )
+        {
+            // ignore white space before potential tag end
+            continue;
+        }
+
+        if ( c == wxT('>') && dashes >= 2 )
+        {
+            // found end of comment
+            start = p;
+            break;
+        }
+
+        if ( c == wxT('-') )
+            dashes++;
+        else
+            dashes = 0;
+    }
+
+    return true;
+}
+
+#endif // wxUSE_HTML