applied part of patch 1169925: fix errors with multibyte <-> wx conversions

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

diff --git a/src/html/htmltag.cpp b/src/html/htmltag.cpp
index 0b0b894f5b4accf3ca3be22b54df026013c2fe97..5c0a0442a55df08910553efc5e8153bf99eb56e1 100644 (file)
--- a/src/html/htmltag.cpp
+++ b/src/html/htmltag.cpp
@@ -4,11 +4,11 @@
 // Author:      Vaclav Slavik
 // RCS-ID:      $Id$
 // Copyright:   (c) 1999 Vaclav Slavik
 // Author:      Vaclav Slavik
 // RCS-ID:      $Id$
 // Copyright:   (c) 1999 Vaclav Slavik

-// Licence:     wxWindows Licence
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 
 /////////////////////////////////////////////////////////////////////////////
 
 

-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)

 #pragma implementation "htmltag.h"
 #endif
 
 #pragma implementation "htmltag.h"
 #endif
 


@@ -66,7 +66,6 @@ bool wxIsCDATAElement(const wxChar *tag)
 wxHtmlTagsCache::wxHtmlTagsCache(const wxString& source)
 {
     const wxChar *src = source.c_str();
 wxHtmlTagsCache::wxHtmlTagsCache(const wxString& source)
 {
     const wxChar *src = source.c_str();

-    int tg, stpos;

     int lng = source.Length();
     wxChar tagBuffer[256];
 
     int lng = source.Length();
     wxChar tagBuffer[256];
 


@@ -81,8 +80,9 @@ wxHtmlTagsCache::wxHtmlTagsCache(const wxString& source)
         {
             if (m_CacheSize % CACHE_INCREMENT == 0)
                 m_Cache = (wxHtmlCacheItem*) realloc(m_Cache, (m_CacheSize + CACHE_INCREMENT) * sizeof(wxHtmlCacheItem));
         {
             if (m_CacheSize % CACHE_INCREMENT == 0)
                 m_Cache = (wxHtmlCacheItem*) realloc(m_Cache, (m_CacheSize + CACHE_INCREMENT) * sizeof(wxHtmlCacheItem));

-            tg = m_CacheSize++;
-            m_Cache[tg].Key = stpos = pos++;
+            int tg = m_CacheSize++;
+            int stpos = pos++;
+            m_Cache[tg].Key = stpos;

 
             int i;
             for ( i = 0;
 
             int i;
             for ( i = 0;


@@ -90,7 +90,7 @@ wxHtmlTagsCache::wxHtmlTagsCache(const wxString& source)
                   src[pos] != wxT('>') && !wxIsspace(src[pos]);
                   i++, pos++ )
             {
                   src[pos] != wxT('>') && !wxIsspace(src[pos]);
                   i++, pos++ )
             {

-                tagBuffer[i] = wxToupper(src[pos]);
+                tagBuffer[i] = (wxChar)wxToupper(src[pos]);

             }
             tagBuffer[i] = _T('\0');
 
             }
             tagBuffer[i] = _T('\0');
 


@@ -114,9 +114,14 @@ wxHtmlTagsCache::wxHtmlTagsCache(const wxString& source)
             else
             {
                 m_Cache[tg].End1 = m_Cache[tg].End2 = -1;
             else
             {
                 m_Cache[tg].End1 = m_Cache[tg].End2 = -1;

-
+                

                 if (wxIsCDATAElement(tagBuffer))
                 {
                 if (wxIsCDATAElement(tagBuffer))
                 {

+                    // store the orig pos in case we are missing the closing
+                    // tag (see below)
+                    wxInt32 old_pos = pos; 
+                    bool foundCloseTag = false;
+                    

                     // find next matching tag
                     int tag_len = wxStrlen(tagBuffer);
                     while (pos < lng)
                     // find next matching tag
                     int tag_len = wxStrlen(tagBuffer);
                     while (pos < lng)


@@ -127,13 +132,15 @@ wxHtmlTagsCache::wxHtmlTagsCache(const wxString& source)
                             ++pos;
                         if (src[pos] == '<')
                             ++pos;
                             ++pos;
                         if (src[pos] == '<')
                             ++pos;

-                        
+

                         // see if it matches
                         int match_pos = 0;
                         while (pos < lng && match_pos < tag_len && src[pos] != '>' && src[pos] != '<') {
                         // see if it matches
                         int match_pos = 0;
                         while (pos < lng && match_pos < tag_len && src[pos] != '>' && src[pos] != '<') {

-                            if (wxToupper(src[pos]) == tagBuffer[match_pos]) {
+                            // cast to wxChar needed to suppress warning in
+                            // Unicode build
+                            if ((wxChar)wxToupper(src[pos]) == tagBuffer[match_pos]) {

                                 ++match_pos;
                                 ++match_pos;

-                            }  
+                            }

                             else if (src[pos] == wxT(' ') || src[pos] == wxT('\n') ||
                                 src[pos] == wxT('\r') || src[pos] == wxT('\t')) {
                                 // need to skip over these
                             else if (src[pos] == wxT(' ') || src[pos] == wxT('\n') ||
                                 src[pos] == wxT('\r') || src[pos] == wxT('\t')) {
                                 // need to skip over these


@@ -145,15 +152,25 @@ wxHtmlTagsCache::wxHtmlTagsCache(const wxString& source)
                         }
 
                         // found a match
                         }
 
                         // found a match

-                        if (match_pos == tag_len) {
+                        if (match_pos == tag_len) 
+                        {

                             pos = pos - tag_len - 3;
                             pos = pos - tag_len - 3;

-                            stpos = pos;
+                            foundCloseTag = true;

                             break;
                         }
                             break;
                         }

-                        else {
+                        else // keep looking for the closing tag
+                        {

                             ++pos;
                         }
                     }
                             ++pos;
                         }
                     }

+                    if (!foundCloseTag)
+                    {
+                        // we didn't find closing tag; this means the markup
+                        // is incorrect and the best thing we can do is to
+                        // ignore the unclosed tag and continue parsing as if
+                        // it didn't exist:
+                        pos = old_pos;
+                    }

                 }
             }
         }
                 }
             }
         }


@@ -360,12 +377,12 @@ wxHtmlTag::~wxHtmlTag()
 
 bool wxHtmlTag::HasParam(const wxString& par) const
 {
 
 bool wxHtmlTag::HasParam(const wxString& par) const
 {

-    return (m_ParamNames.Index(par, FALSE) != wxNOT_FOUND);
+    return (m_ParamNames.Index(par, false) != wxNOT_FOUND);

 }
 
 wxString wxHtmlTag::GetParam(const wxString& par, bool with_commas) const
 {
 }
 
 wxString wxHtmlTag::GetParam(const wxString& par, bool with_commas) const
 {

-    int index = m_ParamNames.Index(par, FALSE);
+    int index = m_ParamNames.Index(par, false);

     if (index == wxNOT_FOUND)
         return wxEmptyString;
     if (with_commas)
     if (index == wxNOT_FOUND)
         return wxEmptyString;
     if (with_commas)


@@ -391,23 +408,23 @@ bool wxHtmlTag::GetParamAsColour(const wxString& par, wxColour *clr) const
 {
     wxString str = GetParam(par);
 
 {
     wxString str = GetParam(par);
 

-    if (str.IsEmpty()) return FALSE;
+    if (str.empty()) return false;

     if (str.GetChar(0) == wxT('#'))
     {
         unsigned long tmp;
         if (ScanParam(par, wxT("#%lX"), &tmp) != 1)
     if (str.GetChar(0) == wxT('#'))
     {
         unsigned long tmp;
         if (ScanParam(par, wxT("#%lX"), &tmp) != 1)

-            return FALSE;
+            return false;

         *clr = wxColour((unsigned char)((tmp & 0xFF0000) >> 16),
         *clr = wxColour((unsigned char)((tmp & 0xFF0000) >> 16),

-                                           (unsigned char)((tmp & 0x00FF00) >> 8),
-                                           (unsigned char)(tmp & 0x0000FF));
-        return TRUE;
+                        (unsigned char)((tmp & 0x00FF00) >> 8),
+                        (unsigned char)(tmp & 0x0000FF));
+        return true;

     }
     else
     {
         // Handle colours defined in HTML 4.0:
         #define HTML_COLOUR(name,r,g,b)                 \
     }
     else
     {
         // Handle colours defined in HTML 4.0:
         #define HTML_COLOUR(name,r,g,b)                 \

-            if (str.IsSameAs(wxT(name), FALSE))         \
-                { *clr = wxColour(r,g,b); return TRUE; }
+            if (str.IsSameAs(wxT(name), false))         \
+                { *clr = wxColour(r,g,b); return true; }

         HTML_COLOUR("black",   0x00,0x00,0x00)
         HTML_COLOUR("silver",  0xC0,0xC0,0xC0)
         HTML_COLOUR("gray",    0x80,0x80,0x80)
         HTML_COLOUR("black",   0x00,0x00,0x00)
         HTML_COLOUR("silver",  0xC0,0xC0,0xC0)
         HTML_COLOUR("gray",    0x80,0x80,0x80)


@@ -427,12 +444,12 @@ bool wxHtmlTag::GetParamAsColour(const wxString& par, wxColour *clr) const
         #undef HTML_COLOUR
     }
 
         #undef HTML_COLOUR
     }
 

-    return FALSE;
+    return false;

 }
 
 bool wxHtmlTag::GetParamAsInt(const wxString& par, int *clr) const
 {
 }
 
 bool wxHtmlTag::GetParamAsInt(const wxString& par, int *clr) const
 {

-    if (!HasParam(par)) return FALSE;
+    if (!HasParam(par)) return false;

     long i;
     bool succ = GetParam(par).ToLong(&i);
     *clr = (int)i;
     long i;
     bool succ = GetParam(par).ToLong(&i);
     *clr = (int)i;


@@ -494,4 +511,13 @@ wxHtmlTag *wxHtmlTag::GetNextTag() const
     return cur->m_Next;
 }
 
     return cur->m_Next;
 }
 

+#if WXWIN_COMPATIBILITY_2_2
+
+bool wxHtmlTag::IsEnding() const
+{
+    return false;
+}
+
+#endif // WXWIN_COMPATIBILITY_2_2
+

 #endif
 #endif