no real changes

[wxWidgets.git] / src / html / htmlpars.cpp

diff --git a/src/html/htmlpars.cpp b/src/html/htmlpars.cpp
index 1b9c06726d608765b2c68e8766aa07188cb01e59..09f7c0ecd96041630d469b283e8613f609ab4cfa 100644 (file)
--- a/src/html/htmlpars.cpp
+++ b/src/html/htmlpars.cpp
@@ -22,7 +22,8 @@
 #endif
 
 #ifndef WXPRECOMP
 #endif
 
 #ifndef WXPRECOMP

-#include "wx/wx.h"
+    #include "wx/log.h"
+    #include "wx/intl.h"

 #endif
 
 #include "wx/tokenzr.h"
 #endif
 
 #include "wx/tokenzr.h"


@@ -31,8 +32,33 @@
 #include "wx/fontmap.h"
 #include "wx/html/htmldefs.h"
 #include "wx/html/htmlpars.h"
 #include "wx/fontmap.h"
 #include "wx/html/htmldefs.h"
 #include "wx/html/htmlpars.h"

+#include "wx/dynarray.h"
+#include "wx/arrimpl.cpp"

 
 

+//-----------------------------------------------------------------------------
+// wxHtmlParser helpers
+//-----------------------------------------------------------------------------
+
+class wxHtmlTextPiece
+{
+public:
+    wxHtmlTextPiece(int pos, int lng) : m_pos(pos), m_lng(lng) {}
+    int m_pos, m_lng;
+};

 
 

+WX_DECLARE_OBJARRAY(wxHtmlTextPiece, wxHtmlTextPieces);
+WX_DEFINE_OBJARRAY(wxHtmlTextPieces);
+
+class wxHtmlParserState
+{
+public:
+    wxHtmlTag         *m_curTag;
+    wxHtmlTag         *m_tags;
+    wxHtmlTextPieces  *m_textPieces;
+    int                m_curTextPiece;
+    wxString           m_source;
+    wxHtmlParserState *m_nextState;
+};

 
 //-----------------------------------------------------------------------------
 // wxHtmlParser
 
 //-----------------------------------------------------------------------------
 // wxHtmlParser


@@ -40,15 +66,23 @@
 
 IMPLEMENT_ABSTRACT_CLASS(wxHtmlParser,wxObject)
 
 
 IMPLEMENT_ABSTRACT_CLASS(wxHtmlParser,wxObject)
 

-wxHtmlParser::wxHtmlParser() 
-    : wxObject(), m_Cache(NULL), m_HandlersHash(wxKEY_STRING), 
+wxHtmlParser::wxHtmlParser()
+    : wxObject(), m_HandlersHash(wxKEY_STRING),

       m_FS(NULL), m_HandlersStack(NULL)
 {
     m_entitiesParser = new wxHtmlEntitiesParser;
       m_FS(NULL), m_HandlersStack(NULL)
 {
     m_entitiesParser = new wxHtmlEntitiesParser;

+    m_Tags = NULL;
+    m_CurTag = NULL;
+    m_TextPieces = NULL;
+    m_CurTextPiece = 0;
+    m_SavedStates = NULL;

 }
 
 wxHtmlParser::~wxHtmlParser()
 {
 }
 
 wxHtmlParser::~wxHtmlParser()
 {

+    while (RestoreState()) {}
+    DestroyDOMTree();
+    

     delete m_HandlersStack;
     m_HandlersHash.Clear();
     m_HandlersList.DeleteContents(TRUE);
     delete m_HandlersStack;
     m_HandlersHash.Clear();
     m_HandlersList.DeleteContents(TRUE);


@@ -74,62 +108,193 @@ void wxHtmlParser::InitParser(const wxString& source)
 
 void wxHtmlParser::DoneParser()
 {
 
 void wxHtmlParser::DoneParser()
 {

-    delete m_Cache;
-    m_Cache = NULL;
+    DestroyDOMTree();

 }
 
 void wxHtmlParser::SetSource(const wxString& src)
 {
 }
 
 void wxHtmlParser::SetSource(const wxString& src)
 {

+    DestroyDOMTree();

     m_Source = src;
     m_Source = src;

-    delete m_Cache;
-    m_Cache = new wxHtmlTagsCache(m_Source);
+    CreateDOMTree();
+    m_CurTag = NULL;
+    m_CurTextPiece = 0;

 }
 
 }
 

-void wxHtmlParser::DoParsing(int begin_pos, int end_pos)
+void wxHtmlParser::CreateDOMTree()

 {
 {

-    if (end_pos <= begin_pos) return;
+    wxHtmlTagsCache cache(m_Source);
+    m_TextPieces = new wxHtmlTextPieces;
+    CreateDOMSubTree(NULL, 0, m_Source.Length(), &cache);
+    m_CurTextPiece = 0;
+}

 
 

-    char c;
-    char *temp = new char[end_pos - begin_pos + 1];
-    int i;
-    int templen;
+void wxHtmlParser::CreateDOMSubTree(wxHtmlTag *cur,
+                                    int begin_pos, int end_pos,
+                                    wxHtmlTagsCache *cache)
+{
+    if (end_pos <= begin_pos) return;

 
 

-    templen = 0;
-    i = begin_pos;
+    wxChar c;
+    int i = begin_pos;
+    int textBeginning = begin_pos;

 
 

-    while (i < end_pos) 
+    while (i < end_pos)

     {
     {

-        c = m_Source[(unsigned int) i];
+        c = m_Source.GetChar(i);

 
 

-        // continue building word:
-        if (c != '<') 
-           {
-            temp[templen++] = c;
-            i++;
-        }
-
-        else if (c == '<')  
-           {
-            wxHtmlTag tag(m_Source, i, end_pos, m_Cache, m_entitiesParser);
+        if (c == wxT('<'))
+        {
+            // add text to m_TextPieces:
+            if (i - textBeginning > 0)
+                m_TextPieces->Add(
+                    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('-'))
+            {
+                // 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;
+                }
+            }

 
 

-            if (templen) 
+            // add another tag to the tree:
+            else if (i < end_pos-1 && m_Source.GetChar(i+1) != wxT('/'))

                {
                {

-                temp[templen] = 0;
-                AddText(temp);
-                templen = 0;
+                wxHtmlTag *chd;
+                if (cur)
+                    chd = new wxHtmlTag(cur, m_Source,
+                                        i, end_pos, cache, m_entitiesParser);
+                else
+                {
+                    chd = new wxHtmlTag(NULL, m_Source,
+                                        i, end_pos, cache, m_entitiesParser);
+                    if (!m_Tags)
+                    {
+                        // if this is the first tag to be created make the root
+                        // m_Tags point to it:
+                        m_Tags = chd;
+                    }
+                    else
+                    {
+                        // if there is already a root tag add this tag as
+                        // the last sibling:
+                        chd->m_Prev = m_Tags->GetLastSibling();
+                        chd->m_Prev->m_Next = chd;
+                    }
+                }
+
+                if (chd->HasEnding())
+                {
+                    CreateDOMSubTree(chd,
+                                     chd->GetBeginPos(), chd->GetEndPos1(),
+                                     cache);
+                    i = chd->GetEndPos2();
+                }
+                else
+                    i = chd->GetBeginPos();
+                textBeginning = i;
+            }
+
+            // ... or skip ending tag:
+            else
+            {
+                while (i < end_pos && m_Source.GetChar(i) != wxT('>')) i++;
+                textBeginning = i+1;

             }
             }

-            AddTag(tag);
-            if (tag.HasEnding()) i = tag.GetEndPos2();
-            else i = tag.GetBeginPos();

         }
         }

+        else i++;

     }
 
     }
 

-    if (templen) 
-    { // last word of block :-(
-        temp[templen] = 0;
-        AddText(temp);
+    // add remaining text to m_TextPieces:
+    if (end_pos - textBeginning > 0)
+        m_TextPieces->Add(
+            wxHtmlTextPiece(textBeginning, end_pos - textBeginning));
+}
+
+void wxHtmlParser::DestroyDOMTree()
+{
+    wxHtmlTag *t1, *t2;
+    t1 = m_Tags;
+    while (t1)
+    {
+        t2 = t1->GetNextSibling();
+        delete t1;
+        t1 = t2;
+    }
+    m_Tags = m_CurTag = NULL;
+
+    delete m_TextPieces;
+    m_TextPieces = NULL;
+}
+
+void wxHtmlParser::DoParsing()
+{
+    m_CurTag = m_Tags;
+    m_CurTextPiece = 0;
+    DoParsing(0, m_Source.Length());
+}
+
+void wxHtmlParser::DoParsing(int begin_pos, int end_pos)
+{
+    if (end_pos <= begin_pos) return;
+
+    wxHtmlTextPieces& pieces = *m_TextPieces;
+    size_t piecesCnt = pieces.GetCount();
+
+    while (begin_pos < end_pos)
+    {
+        while (m_CurTag && m_CurTag->GetBeginPos() < begin_pos)
+            m_CurTag = m_CurTag->GetNextTag();
+        while (m_CurTextPiece < piecesCnt &&
+               pieces[m_CurTextPiece].m_pos < begin_pos)
+            m_CurTextPiece++;
+
+        if (m_CurTextPiece < piecesCnt &&
+            (!m_CurTag ||
+             pieces[m_CurTextPiece].m_pos < m_CurTag->GetBeginPos()))
+        {
+            // Add text:
+            AddText(GetEntitiesParser()->Parse(
+                       m_Source.Mid(pieces[m_CurTextPiece].m_pos,
+                                    pieces[m_CurTextPiece].m_lng)));
+            begin_pos = pieces[m_CurTextPiece].m_pos +
+                        pieces[m_CurTextPiece].m_lng;
+            m_CurTextPiece++;
+        }
+        else if (m_CurTag)
+        {
+            // Add tag:
+            if (m_CurTag)
+            {
+                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);
+        }
+        else break;

     }
     }

-    delete[] temp;

 }
 
 void wxHtmlParser::AddTag(const wxHtmlTag& tag)
 }
 
 void wxHtmlParser::AddTag(const wxHtmlTag& tag)


@@ -140,7 +305,7 @@ void wxHtmlParser::AddTag(const wxHtmlTag& tag)
     h = (wxHtmlTagHandler*) m_HandlersHash.Get(tag.GetName());
     if (h)
         inner = h->HandleTag(tag);
     h = (wxHtmlTagHandler*) m_HandlersHash.Get(tag.GetName());
     if (h)
         inner = h->HandleTag(tag);

-    if (!inner) 
+    if (!inner)

     {
         if (tag.HasEnding())
             DoParsing(tag.GetBeginPos(), tag.GetEndPos1());
     {
         if (tag.HasEnding())
             DoParsing(tag.GetBeginPos(), tag.GetEndPos1());


@@ -150,10 +315,10 @@ void wxHtmlParser::AddTag(const wxHtmlTag& tag)
 void wxHtmlParser::AddTagHandler(wxHtmlTagHandler *handler)
 {
     wxString s(handler->GetSupportedTags());
 void wxHtmlParser::AddTagHandler(wxHtmlTagHandler *handler)
 {
     wxString s(handler->GetSupportedTags());

-    wxStringTokenizer tokenizer(s, ", ");
+    wxStringTokenizer tokenizer(s, wxT(", "));

 
     while (tokenizer.HasMoreTokens())
 
     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);
 
     if (m_HandlersList.IndexOf(handler) == wxNOT_FOUND)
         m_HandlersList.Append(handler);


@@ -163,10 +328,10 @@ void wxHtmlParser::AddTagHandler(wxHtmlTagHandler *handler)
 
 void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
 {
 
 void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
 {

-    wxStringTokenizer tokenizer(tags, ", ");
+    wxStringTokenizer tokenizer(tags, wxT(", "));

     wxString key;
 
     wxString key;
 

-    if (m_HandlersStack == NULL) 
+    if (m_HandlersStack == NULL)

     {
         m_HandlersStack = new wxList;
         m_HandlersStack->DeleteContents(TRUE);
     {
         m_HandlersStack = new wxList;
         m_HandlersStack->DeleteContents(TRUE);


@@ -174,9 +339,9 @@ void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
 
     m_HandlersStack->Insert(new wxHashTable(m_HandlersHash));
 
 
     m_HandlersStack->Insert(new wxHashTable(m_HandlersHash));
 

-    while (tokenizer.HasMoreTokens()) 
+    while (tokenizer.HasMoreTokens())

     {
     {

-        key = tokenizer.NextToken();
+        key = tokenizer.GetNextToken();

         m_HandlersHash.Delete(key);
         m_HandlersHash.Put(key, handler);
     }
         m_HandlersHash.Delete(key);
         m_HandlersHash.Put(key, handler);
     }


@@ -185,9 +350,9 @@ void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
 void wxHtmlParser::PopTagHandler()
 {
     wxNode *first;
 void wxHtmlParser::PopTagHandler()
 {
     wxNode *first;

-    
-    if (m_HandlersStack == NULL || 
-        (first = m_HandlersStack->GetFirst()) == NULL) 
+
+    if (m_HandlersStack == NULL ||
+        (first = m_HandlersStack->GetFirst()) == NULL)

     {
         wxLogWarning(_("Warning: attempt to remove HTML tag handler from empty stack."));
         return;
     {
         wxLogWarning(_("Warning: attempt to remove HTML tag handler from empty stack."));
         return;


@@ -196,6 +361,47 @@ void wxHtmlParser::PopTagHandler()
     m_HandlersStack->DeleteNode(first);
 }
 
     m_HandlersStack->DeleteNode(first);
 }
 

+void wxHtmlParser::SetSourceAndSaveState(const wxString& src)
+{
+    wxHtmlParserState *s = new wxHtmlParserState;
+
+    s->m_curTag = m_CurTag;
+    s->m_tags = m_Tags;
+    s->m_textPieces = m_TextPieces;
+    s->m_curTextPiece = m_CurTextPiece;
+    s->m_source = m_Source;
+
+    s->m_nextState = m_SavedStates;
+    m_SavedStates = s;
+
+    m_CurTag = NULL;
+    m_Tags = NULL;
+    m_TextPieces = NULL;
+    m_CurTextPiece = 0;
+    m_Source = wxEmptyString;
+
+    SetSource(src);
+}
+
+bool wxHtmlParser::RestoreState()
+{
+    if (!m_SavedStates) return FALSE;
+
+    DestroyDOMTree();
+
+    wxHtmlParserState *s = m_SavedStates;
+    m_SavedStates = s->m_nextState;
+
+    m_CurTag = s->m_curTag;
+    m_Tags = s->m_tags;
+    m_TextPieces = s->m_textPieces;
+    m_CurTextPiece = s->m_curTextPiece;
+    m_Source = s->m_source;
+
+    delete s;
+    return TRUE;
+}
+

 //-----------------------------------------------------------------------------
 // wxHtmlTagHandler
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 // wxHtmlTagHandler
 //-----------------------------------------------------------------------------


@@ -218,7 +424,9 @@ wxHtmlEntitiesParser::wxHtmlEntitiesParser()
 
 wxHtmlEntitiesParser::~wxHtmlEntitiesParser()
 {
 
 wxHtmlEntitiesParser::~wxHtmlEntitiesParser()
 {

+#if wxUSE_WCHAR_T && !wxUSE_UNICODE

     delete m_conv;
     delete m_conv;

+#endif

 }
 
 void wxHtmlEntitiesParser::SetEncoding(wxFontEncoding encoding)
 }
 
 void wxHtmlEntitiesParser::SetEncoding(wxFontEncoding encoding)


@@ -230,6 +438,8 @@ void wxHtmlEntitiesParser::SetEncoding(wxFontEncoding encoding)
     m_encoding = encoding;
     if (m_encoding != wxFONTENCODING_SYSTEM)
         m_conv = new wxCSConv(wxFontMapper::GetEncodingName(m_encoding));
     m_encoding = encoding;
     if (m_encoding != wxFONTENCODING_SYSTEM)
         m_conv = new wxCSConv(wxFontMapper::GetEncodingName(m_encoding));

+#else
+    (void) encoding;

 #endif
 }
 
 #endif
 }
 


@@ -239,6 +449,8 @@ wxString wxHtmlEntitiesParser::Parse(const wxString& input)
     const wxChar *in_str = input.c_str();
     wxString output;
     
     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('&'))
     for (c = in_str, last = in_str; *c != wxT('\0'); c++)
     {
         if (*c == wxT('&'))


@@ -246,16 +458,26 @@ wxString wxHtmlEntitiesParser::Parse(const wxString& input)
             if (c - last > 0)
                 output.append(last, c - last);
             if (++c == wxT('\0')) break;
             if (c - last > 0)
                 output.append(last, c - last);
             if (++c == wxT('\0')) break;

+        

             wxString entity;
             const wxChar *ent_s = c;
             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')) ||
                    *c == wxT('_') || *c == wxT('#'); c++) {}
             entity.append(ent_s, c - ent_s);
             for (; (*c >= wxT('a') && *c <= wxT('z')) ||
                    (*c >= wxT('A') && *c <= wxT('Z')) ||
                    (*c >= wxT('0') && *c <= wxT('9')) ||
                    *c == wxT('_') || *c == wxT('#'); c++) {}
             entity.append(ent_s, c - ent_s);

-            if (*c == wxT(';')) c++;
-            output << GetEntityChar(entity);
-            last = c;
+            if (*c != wxT(';')) c--;
+            last = c+1;
+            entity_char = GetEntityChar(entity);
+            if (entity_char)
+                output << entity_char;
+            else
+            {
+                output.append(ent_s-1, c-ent_s+2);
+                wxLogDebug(wxT("Unrecognized HTML entity: '%s'"), entity.c_str());
+            }

         }
     }
     if (*last != wxT('\0'))
         }
     }
     if (*last != wxT('\0'))


@@ -269,7 +491,7 @@ struct wxHtmlEntityInfo
     unsigned code;
 };
 
     unsigned code;
 };
 

-static int compar_entity(const void *key, const void *item)
+static int LINKAGEMODE compar_entity(const void *key, const void *item)

 {
     return wxStrcmp((wxChar*)key, ((wxHtmlEntityInfo*)item)->name);
 }
 {
     return wxStrcmp((wxChar*)key, ((wxHtmlEntityInfo*)item)->name);
 }


@@ -284,7 +506,7 @@ wxChar wxHtmlEntitiesParser::GetCharForCode(unsigned code)
     wbuf[0] = (wchar_t)code;
     wbuf[1] = 0;
     wxMBConv *conv = m_conv ? m_conv : &wxConvLocal;
     wbuf[0] = (wchar_t)code;
     wbuf[1] = 0;
     wxMBConv *conv = m_conv ? m_conv : &wxConvLocal;

-    if (conv->WC2MB(buf, wbuf, 1) == (size_t)-1)
+    if (conv->WC2MB(buf, wbuf, 2) == (size_t)-1)

         return '?';
     return buf[0];
 #else
         return '?';
     return buf[0];
 #else


@@ -295,12 +517,12 @@ wxChar wxHtmlEntitiesParser::GetCharForCode(unsigned code)
 wxChar wxHtmlEntitiesParser::GetEntityChar(const wxString& entity)
 {
     unsigned code = 0;
 wxChar wxHtmlEntitiesParser::GetEntityChar(const wxString& entity)
 {
     unsigned code = 0;

-    
+

     if (entity[0] == wxT('#'))
     {
         const wxChar *ent_s = entity.c_str();
         const wxChar *format;
     if (entity[0] == wxT('#'))
     {
         const wxChar *ent_s = entity.c_str();
         const wxChar *format;

-        
+

         if (ent_s[1] == wxT('x') || ent_s[1] == wxT('X'))
         {
             format = wxT("%x");
         if (ent_s[1] == wxT('x') || ent_s[1] == wxT('X'))
         {
             format = wxT("%x");


@@ -570,22 +792,22 @@ wxChar wxHtmlEntitiesParser::GetEntityChar(const wxString& entity)
             { wxT("zwnj"),8204 },
             {NULL, 0}};
         static size_t substitutions_cnt = 0;
             { wxT("zwnj"),8204 },
             {NULL, 0}};
         static size_t substitutions_cnt = 0;

-        
+

         if (substitutions_cnt == 0)
             while (substitutions[substitutions_cnt].code != 0)
                 substitutions_cnt++;
 
         wxHtmlEntityInfo *info;
         if (substitutions_cnt == 0)
             while (substitutions[substitutions_cnt].code != 0)
                 substitutions_cnt++;
 
         wxHtmlEntityInfo *info;

-        info = (wxHtmlEntityInfo*) bsearch(entity.c_str(), substitutions, 
+        info = (wxHtmlEntityInfo*) bsearch(entity.c_str(), substitutions,

                                            substitutions_cnt,
                                            sizeof(wxHtmlEntityInfo),
                                            compar_entity);
         if (info)
             code = info->code;
     }
                                            substitutions_cnt,
                                            sizeof(wxHtmlEntityInfo),
                                            compar_entity);
         if (info)
             code = info->code;
     }

-    
+

     if (code == 0)
     if (code == 0)

-        return wxT('?');
+        return 0;

     else
         return GetCharForCode(code);
 }
     else
         return GetCharForCode(code);
 }