#ifdef __GNUG__
-#pragma implementation
+#pragma implementation "htmlpars.h"
#endif
#include "wx/wxprec.h"
#include "wx/defs.h"
#if wxUSE_HTML && wxUSE_STREAMS
-#ifdef __BORDLANDC__
+#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WXPRECOMP
-#include "wx/wx.h"
+ #include "wx/log.h"
+ #include "wx/intl.h"
#endif
#include "wx/tokenzr.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
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_Tags = NULL;
+ m_CurTag = NULL;
+ m_TextPieces = NULL;
+ m_CurTextPiece = 0;
+ m_SavedStates = NULL;
}
wxHtmlParser::~wxHtmlParser()
{
+ while (RestoreState()) {}
+ DestroyDOMTree();
+
delete m_HandlersStack;
m_HandlersHash.Clear();
m_HandlersList.DeleteContents(TRUE);
wxObject* wxHtmlParser::Parse(const wxString& source)
{
- wxObject *result;
-
InitParser(source);
DoParsing();
- result = GetProduct();
+ wxObject *result = GetProduct();
DoneParser();
return result;
}
void wxHtmlParser::InitParser(const wxString& source)
{
SetSource(source);
+ m_stopParsing = FALSE;
}
void wxHtmlParser::DoneParser()
{
- delete m_Cache;
- m_Cache = NULL;
+ DestroyDOMTree();
}
void wxHtmlParser::SetSource(const wxString& src)
{
+ DestroyDOMTree();
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];
-
- // continue building word:
- if (c != '<')
- {
- temp[templen++] = c;
- i++;
- }
+ c = m_Source.GetChar(i);
- else if (c == '<')
- {
- wxHtmlTag tag(m_Source, i, end_pos, m_Cache);
+ 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);
+ if (m_stopParsing)
+ return;
+ }
+ else break;
}
- delete[] temp;
}
void wxHtmlParser::AddTag(const wxHtmlTag& tag)
h = (wxHtmlTagHandler*) m_HandlersHash.Get(tag.GetName());
if (h)
+ {
inner = h->HandleTag(tag);
- if (!inner)
+ if (m_stopParsing)
+ return;
+ }
+ if (!inner)
{
if (tag.HasEnding())
DoParsing(tag.GetBeginPos(), tag.GetEndPos1());
void wxHtmlParser::AddTagHandler(wxHtmlTagHandler *handler)
{
wxString s(handler->GetSupportedTags());
- wxStringTokenizer tokenizer(s, ", ");
+ 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);
void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
{
- wxStringTokenizer tokenizer(tags, ", ");
+ wxStringTokenizer tokenizer(tags, wxT(", "));
wxString key;
- if (m_HandlersStack == NULL)
+ if (m_HandlersStack == NULL)
{
m_HandlersStack = new wxList;
m_HandlersStack->DeleteContents(TRUE);
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);
}
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;
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
//-----------------------------------------------------------------------------
wxHtmlEntitiesParser::~wxHtmlEntitiesParser()
{
+#if wxUSE_WCHAR_T && !wxUSE_UNICODE
delete m_conv;
+#endif
}
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;
#endif
}
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;
+
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);
- 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'))
unsigned code;
};
-static int compar_entity(const void *key, const void *item)
+extern "C" int LINKAGEMODE wxHtmlEntityCompare(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;
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 (code < 256) ? (wxChar)code : '?';
#endif
}
+#endif
wxChar wxHtmlEntitiesParser::GetEntityChar(const wxString& entity)
{
unsigned code = 0;
-
+
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");
{ 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;
- info = (wxHtmlEntityInfo*) bsearch(entity.c_str(), substitutions,
+ info = (wxHtmlEntityInfo*) bsearch(entity.c_str(), substitutions,
substitutions_cnt,
sizeof(wxHtmlEntityInfo),
- compar_entity);
+ wxHtmlEntityCompare);
if (info)
code = info->code;
}
-
+
if (code == 0)
- return wxT('?');
+ return 0;
else
return GetCharForCode(code);
}
+wxFSFile *wxHtmlParser::OpenURL(wxHtmlURLType WXUNUSED(type),
+ const wxString& url) const
+{
+ return GetFS()->OpenFile(url);
+}
+
+
+//-----------------------------------------------------------------------------
+// wxHtmlParser::ExtractCharsetInformation
+//-----------------------------------------------------------------------------
+
+class wxMetaTagParser : public wxHtmlParser
+{
+public:
+ wxObject* GetProduct() { return NULL; }
+protected:
+ virtual void AddText(const wxChar* WXUNUSED(txt)) {}
+};
+
+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;
+};
+
+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")) == _T("Content-Type") &&
+ tag.HasParam(_T("CONTENT")))
+ {
+ wxString content = tag.GetParam(_T("CONTENT"));
+ 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;
+ parser.AddTagHandler(new wxMetaTagHandler(&charset));
+ parser.Parse(markup);
+ return charset;
+}
+
+
#endif
projects / wxWidgets.git / blobdiff