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

/////////////////////////////////////////////////////////////////////////////
// Name:        htmlpars.cpp
// Purpose:     wxHtmlParser class (generic parser)
// Author:      Vaclav Slavik
// RCS-ID:      $Id$
// Copyright:   (c) 1999 Vaclav Slavik
// Licence:     wxWindows Licence
/////////////////////////////////////////////////////////////////////////////


#ifdef __GNUG__
#pragma implementation
#endif

#include "wx/wxprec.h"

#include "wx/defs.h"
#if wxUSE_HTML && wxUSE_STREAMS

#ifdef __BORDLANDC__
#pragma hdrstop
#endif

#ifndef WXPRECOMP
    #include "wx/log.h"
    #include "wx/intl.h"
#endif

#include "wx/tokenzr.h"
#include "wx/wfstream.h"
#include "wx/url.h"
#include "wx/fontmap.h"
#include "wx/html/htmldefs.h"
#include "wx/html/htmlpars.h"


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

IMPLEMENT_ABSTRACT_CLASS(wxHtmlParser,wxObject)

wxHtmlParser::wxHtmlParser()
    : wxObject(), m_Cache(NULL), m_HandlersHash(wxKEY_STRING),
      m_FS(NULL), m_HandlersStack(NULL)
{
    m_entitiesParser = new wxHtmlEntitiesParser;
}

wxHtmlParser::~wxHtmlParser()
{
    delete m_HandlersStack;
    m_HandlersHash.Clear();
    m_HandlersList.DeleteContents(TRUE);
    m_HandlersList.Clear();
    delete m_entitiesParser;
}

wxObject* wxHtmlParser::Parse(const wxString& source)
{
    wxObject *result;

    InitParser(source);
    DoParsing();
    result = GetProduct();
    DoneParser();
    return result;
}

void wxHtmlParser::InitParser(const wxString& source)
{
    SetSource(source);
}

void wxHtmlParser::DoneParser()
{
    delete m_Cache;
    m_Cache = NULL;
}

void wxHtmlParser::SetSource(const wxString& src)
{
    m_Source = src;
    delete m_Cache;
    m_Cache = new wxHtmlTagsCache(m_Source);
}

void wxHtmlParser::DoParsing(int begin_pos, int end_pos)
{
    if (end_pos <= begin_pos) return;

    char c;
    char *temp = new char[end_pos - begin_pos + 1];
    int i;
    int templen;

    templen = 0;
    i = begin_pos;

    while (i < end_pos)
    {
        c = m_Source[(unsigned int) 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 (templen)
	        {
                temp[templen] = 0;
                AddText(temp);
                templen = 0;
            }
            AddTag(tag);
            if (tag.HasEnding()) i = tag.GetEndPos2();
            else i = tag.GetBeginPos();
        }
    }

    if (templen)
    { // last word of block :-(
        temp[templen] = 0;
        AddText(temp);
    }
    delete[] temp;
}

void wxHtmlParser::AddTag(const wxHtmlTag& tag)
{
    wxHtmlTagHandler *h;
    bool inner = FALSE;

    h = (wxHtmlTagHandler*) m_HandlersHash.Get(tag.GetName());
    if (h)
        inner = h->HandleTag(tag);
    if (!inner)
    {
        if (tag.HasEnding())
            DoParsing(tag.GetBeginPos(), tag.GetEndPos1());
    }
}

void wxHtmlParser::AddTagHandler(wxHtmlTagHandler *handler)
{
    wxString s(handler->GetSupportedTags());
    wxStringTokenizer tokenizer(s, ", ");

    while (tokenizer.HasMoreTokens())
        m_HandlersHash.Put(tokenizer.NextToken(), handler);

    if (m_HandlersList.IndexOf(handler) == wxNOT_FOUND)
        m_HandlersList.Append(handler);

    handler->SetParser(this);
}

void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
{
    wxStringTokenizer tokenizer(tags, ", ");
    wxString key;

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

    m_HandlersStack->Insert(new wxHashTable(m_HandlersHash));

    while (tokenizer.HasMoreTokens())
    {
        key = tokenizer.NextToken();
        m_HandlersHash.Delete(key);
        m_HandlersHash.Put(key, handler);
    }
}

void wxHtmlParser::PopTagHandler()
{
    wxNode *first;

    if (m_HandlersStack == NULL ||
        (first = m_HandlersStack->GetFirst()) == NULL)
    {
        wxLogWarning(_("Warning: attempt to remove HTML tag handler from empty stack."));
        return;
    }
    m_HandlersHash = *((wxHashTable*) first->GetData());
    m_HandlersStack->DeleteNode(first);
}

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

IMPLEMENT_ABSTRACT_CLASS(wxHtmlTagHandler,wxObject)


//-----------------------------------------------------------------------------
// wxHtmlEntitiesParser
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxHtmlEntitiesParser,wxObject)

wxHtmlEntitiesParser::wxHtmlEntitiesParser()
#if wxUSE_WCHAR_T && !wxUSE_UNICODE
    : m_conv(NULL), m_encoding(wxFONTENCODING_SYSTEM)
#endif
{
}

wxHtmlEntitiesParser::~wxHtmlEntitiesParser()
{
    delete m_conv;
}

void wxHtmlEntitiesParser::SetEncoding(wxFontEncoding encoding)
{
#if wxUSE_WCHAR_T && !wxUSE_UNICODE
    if (encoding == m_encoding) return;
    delete m_conv;
    m_conv = NULL;
    m_encoding = encoding;
    if (m_encoding != wxFONTENCODING_SYSTEM)
        m_conv = new wxCSConv(wxFontMapper::GetEncodingName(m_encoding));
#endif
}

wxString wxHtmlEntitiesParser::Parse(const wxString& input)
{
    const wxChar *c, *last;
    const wxChar *in_str = input.c_str();
    wxString output;

    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;
            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 (*last != wxT('\0'))
        output.append(last);
    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);
}

wxChar wxHtmlEntitiesParser::GetCharForCode(unsigned code)
{
#if wxUSE_UNICODE
    return (wxChar)code;
#elif 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)
        return '?';
    return buf[0];
#else
    return (code < 256) ? (wxChar)code : '?';
#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");
            ent_s++;
        }
        else
            format = wxT("%u");
        ent_s++;

        if (wxSscanf(ent_s, format, &code) != 1)
            code = 0;
    }
    else
    {
        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 },
            {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,
                                           substitutions_cnt,
                                           sizeof(wxHtmlEntityInfo),
                                           compar_entity);
        if (info)
            code = info->code;
    }

    if (code == 0)
        return wxT('?');
    else
        return GetCharForCode(code);
}

#endif
Commit	Line	Data
5526e819	1	/////////////////////////////////////////////////////////////////////////////
69941f05	2	// Name: htmlpars.cpp
5526e819 VS	3	// Purpose: wxHtmlParser class (generic parser)
5526e819 VS	4	// Author: Vaclav Slavik
69941f05	5	// RCS-ID: $Id$
5526e819 VS	6	// Copyright: (c) 1999 Vaclav Slavik
	7	// Licence: wxWindows Licence
	8	/////////////////////////////////////////////////////////////////////////////
	9
	10
	11	#ifdef __GNUG__
	12	#pragma implementation
	13	#endif
	14
3096bd2f	15	#include "wx/wxprec.h"
5526e819 VS	16
5526e819 VS	17	#include "wx/defs.h"
f6bcfd97	18	#if wxUSE_HTML && wxUSE_STREAMS
5526e819 VS	19
	20	#ifdef __BORDLANDC__
	21	#pragma hdrstop
	22	#endif
	23
	24	#ifndef WXPRECOMP
04dbb646 VZ	25	#include "wx/log.h"
04dbb646 VZ	26	#include "wx/intl.h"
5526e819 VS	27	#endif
5526e819 VS	28
69941f05 VS	29	#include "wx/tokenzr.h"
	30	#include "wx/wfstream.h"
	31	#include "wx/url.h"
daa616fc	32	#include "wx/fontmap.h"
69941f05 VS	33	#include "wx/html/htmldefs.h"
69941f05 VS	34	#include "wx/html/htmlpars.h"
5526e819 VS	35
	36
	37
	38	//-----------------------------------------------------------------------------
	39	// wxHtmlParser
	40	//-----------------------------------------------------------------------------
	41
	42	IMPLEMENT_ABSTRACT_CLASS(wxHtmlParser,wxObject)
	43
04dbb646 VZ	44	wxHtmlParser::wxHtmlParser()
04dbb646 VZ	45	: wxObject(), m_Cache(NULL), m_HandlersHash(wxKEY_STRING),
daa616fc VS	46	m_FS(NULL), m_HandlersStack(NULL)
	47	{
	48	m_entitiesParser = new wxHtmlEntitiesParser;
	49	}
	50
	51	wxHtmlParser::~wxHtmlParser()
	52	{
	53	delete m_HandlersStack;
	54	m_HandlersHash.Clear();
	55	m_HandlersList.DeleteContents(TRUE);
	56	m_HandlersList.Clear();
	57	delete m_entitiesParser;
	58	}
5526e819 VS	59
	60	wxObject* wxHtmlParser::Parse(const wxString& source)
	61	{
	62	wxObject *result;
	63
	64	InitParser(source);
	65	DoParsing();
	66	result = GetProduct();
	67	DoneParser();
	68	return result;
	69	}
	70
5526e819 VS	71	void wxHtmlParser::InitParser(const wxString& source)
5526e819 VS	72	{
1309ba6c	73	SetSource(source);
5526e819	74	}
1309ba6c	75
5526e819 VS	76	void wxHtmlParser::DoneParser()
	77	{
	78	delete m_Cache;
	79	m_Cache = NULL;
	80	}
	81
1309ba6c VS	82	void wxHtmlParser::SetSource(const wxString& src)
	83	{
	84	m_Source = src;
	85	delete m_Cache;
	86	m_Cache = new wxHtmlTagsCache(m_Source);
	87	}
5526e819 VS	88
	89	void wxHtmlParser::DoParsing(int begin_pos, int end_pos)
	90	{
99397a94 VS	91	if (end_pos <= begin_pos) return;
99397a94 VS	92
19bcc604 VS	93	char c;
19bcc604 VS	94	char *temp = new char[end_pos - begin_pos + 1];
5526e819 VS	95	int i;
	96	int templen;
	97
	98	templen = 0;
	99	i = begin_pos;
	100
04dbb646	101	while (i < end_pos)
4f9297b0	102	{
01dba85a	103	c = m_Source[(unsigned int) i];
5526e819 VS	104
5526e819 VS	105	// continue building word:
04dbb646	106	if (c != '<')
4f9297b0	107	{
5526e819	108	temp[templen++] = c;
5526e819 VS	109	i++;
	110	}
	111
04dbb646	112	else if (c == '<')
4f9297b0	113	{
367c84b9	114	wxHtmlTag tag(m_Source, i, end_pos, m_Cache, m_entitiesParser);
5526e819	115
04dbb646	116	if (templen)
4f9297b0	117	{
5526e819 VS	118	temp[templen] = 0;
	119	AddText(temp);
	120	templen = 0;
	121	}
	122	AddTag(tag);
	123	if (tag.HasEnding()) i = tag.GetEndPos2();
	124	else i = tag.GetBeginPos();
	125	}
	126	}
	127
04dbb646	128	if (templen)
4f9297b0	129	{ // last word of block :-(
5526e819 VS	130	temp[templen] = 0;
	131	AddText(temp);
	132	}
19bcc604	133	delete[] temp;
5526e819 VS	134	}
5526e819 VS	135
5526e819 VS	136	void wxHtmlParser::AddTag(const wxHtmlTag& tag)
	137	{
	138	wxHtmlTagHandler *h;
	139	bool inner = FALSE;
	140
	141	h = (wxHtmlTagHandler*) m_HandlersHash.Get(tag.GetName());
	142	if (h)
4f9297b0	143	inner = h->HandleTag(tag);
04dbb646	144	if (!inner)
4f9297b0	145	{
5526e819 VS	146	if (tag.HasEnding())
	147	DoParsing(tag.GetBeginPos(), tag.GetEndPos1());
	148	}
	149	}
	150
5526e819 VS	151	void wxHtmlParser::AddTagHandler(wxHtmlTagHandler *handler)
5526e819 VS	152	{
4f9297b0	153	wxString s(handler->GetSupportedTags());
5526e819 VS	154	wxStringTokenizer tokenizer(s, ", ");
5526e819 VS	155
5526e819	156	while (tokenizer.HasMoreTokens())
5526e819 VS	157	m_HandlersHash.Put(tokenizer.NextToken(), handler);
	158
	159	if (m_HandlersList.IndexOf(handler) == wxNOT_FOUND)
	160	m_HandlersList.Append(handler);
	161
4f9297b0	162	handler->SetParser(this);
5526e819 VS	163	}
5526e819 VS	164
a7a4d01b VS	165	void wxHtmlParser::PushTagHandler(wxHtmlTagHandler *handler, wxString tags)
	166	{
	167	wxStringTokenizer tokenizer(tags, ", ");
	168	wxString key;
	169
04dbb646	170	if (m_HandlersStack == NULL)
4f9297b0	171	{
a7a4d01b	172	m_HandlersStack = new wxList;
4f9297b0	173	m_HandlersStack->DeleteContents(TRUE);
a7a4d01b VS	174	}
a7a4d01b VS	175
4f9297b0	176	m_HandlersStack->Insert(new wxHashTable(m_HandlersHash));
a7a4d01b	177
04dbb646	178	while (tokenizer.HasMoreTokens())
4f9297b0	179	{
a7a4d01b VS	180	key = tokenizer.NextToken();
	181	m_HandlersHash.Delete(key);
	182	m_HandlersHash.Put(key, handler);
	183	}
	184	}
	185
a7a4d01b VS	186	void wxHtmlParser::PopTagHandler()
	187	{
	188	wxNode *first;
04dbb646 VZ	189
	190	if (m_HandlersStack == NULL \|\|
	191	(first = m_HandlersStack->GetFirst()) == NULL)
f3c82859 VS	192	{
	193	wxLogWarning(_("Warning: attempt to remove HTML tag handler from empty stack."));
	194	return;
	195	}
4f9297b0 VS	196	m_HandlersHash = ((wxHashTable) first->GetData());
4f9297b0 VS	197	m_HandlersStack->DeleteNode(first);
a7a4d01b VS	198	}
a7a4d01b VS	199
5526e819 VS	200	//-----------------------------------------------------------------------------
	201	// wxHtmlTagHandler
	202	//-----------------------------------------------------------------------------
	203
	204	IMPLEMENT_ABSTRACT_CLASS(wxHtmlTagHandler,wxObject)
daa616fc VS	205
	206
	207	//-----------------------------------------------------------------------------
	208	// wxHtmlEntitiesParser
	209	//-----------------------------------------------------------------------------
	210
	211	IMPLEMENT_DYNAMIC_CLASS(wxHtmlEntitiesParser,wxObject)
	212
	213	wxHtmlEntitiesParser::wxHtmlEntitiesParser()
	214	#if wxUSE_WCHAR_T && !wxUSE_UNICODE
	215	: m_conv(NULL), m_encoding(wxFONTENCODING_SYSTEM)
223d09f6	216	#endif
daa616fc VS	217	{
	218	}
	219
	220	wxHtmlEntitiesParser::~wxHtmlEntitiesParser()
	221	{
	222	delete m_conv;
	223	}
5526e819	224
daa616fc VS	225	void wxHtmlEntitiesParser::SetEncoding(wxFontEncoding encoding)
	226	{
	227	#if wxUSE_WCHAR_T && !wxUSE_UNICODE
	228	if (encoding == m_encoding) return;
	229	delete m_conv;
	230	m_conv = NULL;
	231	m_encoding = encoding;
	232	if (m_encoding != wxFONTENCODING_SYSTEM)
	233	m_conv = new wxCSConv(wxFontMapper::GetEncodingName(m_encoding));
	234	#endif
	235	}
	236
	237	wxString wxHtmlEntitiesParser::Parse(const wxString& input)
	238	{
	239	const wxChar c, last;
	240	const wxChar *in_str = input.c_str();
	241	wxString output;
04dbb646	242
daa616fc VS	243	for (c = in_str, last = in_str; *c != wxT('\0'); c++)
	244	{
	245	if (*c == wxT('&'))
	246	{
	247	if (c - last > 0)
	248	output.append(last, c - last);
	249	if (++c == wxT('\0')) break;
	250	wxString entity;
	251	const wxChar *ent_s = c;
	252	for (; (c >= wxT('a') && c <= wxT('z')) \|\|
	253	(c >= wxT('A') && c <= wxT('Z')) \|\|
	254	(c >= wxT('0') && c <= wxT('9')) \|\|
	255	c == wxT('_') \|\| c == wxT('#'); c++) {}
	256	entity.append(ent_s, c - ent_s);
	257	if (*c == wxT(';')) c++;
	258	output << GetEntityChar(entity);
	259	last = c;
	260	}
	261	}
	262	if (*last != wxT('\0'))
	263	output.append(last);
	264	return output;
	265	}
	266
	267	struct wxHtmlEntityInfo
	268	{
	269	const wxChar *name;
	270	unsigned code;
	271	};
	272
53776059	273	static int LINKAGEMODE compar_entity(const void key, const void item)
daa616fc VS	274	{
	275	return wxStrcmp((wxChar)key, ((wxHtmlEntityInfo)item)->name);
	276	}
	277
	278	wxChar wxHtmlEntitiesParser::GetCharForCode(unsigned code)
	279	{
	280	#if wxUSE_UNICODE
	281	return (wxChar)code;
	282	#elif wxUSE_WCHAR_T
	283	char buf[2];
	284	wchar_t wbuf[2];
	285	wbuf[0] = (wchar_t)code;
	286	wbuf[1] = 0;
	287	wxMBConv *conv = m_conv ? m_conv : &wxConvLocal;
	288	if (conv->WC2MB(buf, wbuf, 1) == (size_t)-1)
	289	return '?';
	290	return buf[0];
	291	#else
	292	return (code < 256) ? (wxChar)code : '?';
	293	#endif
	294	}
	295
	296	wxChar wxHtmlEntitiesParser::GetEntityChar(const wxString& entity)
	297	{
	298	unsigned code = 0;
04dbb646	299
daa616fc VS	300	if (entity[0] == wxT('#'))
	301	{
	302	const wxChar *ent_s = entity.c_str();
	303	const wxChar *format;
04dbb646	304
daa616fc VS	305	if (ent_s[1] == wxT('x') \|\| ent_s[1] == wxT('X'))
	306	{
	307	format = wxT("%x");
	308	ent_s++;
	309	}
	310	else
	311	format = wxT("%u");
	312	ent_s++;
	313
	314	if (wxSscanf(ent_s, format, &code) != 1)
	315	code = 0;
	316	}
	317	else
	318	{
	319	static wxHtmlEntityInfo substitutions[] = {
	320	{ wxT("AElig"),198 },
	321	{ wxT("Aacute"),193 },
	322	{ wxT("Acirc"),194 },
	323	{ wxT("Agrave"),192 },
	324	{ wxT("Alpha"),913 },
	325	{ wxT("Aring"),197 },
	326	{ wxT("Atilde"),195 },
	327	{ wxT("Auml"),196 },
	328	{ wxT("Beta"),914 },
	329	{ wxT("Ccedil"),199 },
	330	{ wxT("Chi"),935 },
	331	{ wxT("Dagger"),8225 },
	332	{ wxT("Delta"),916 },
	333	{ wxT("ETH"),208 },
	334	{ wxT("Eacute"),201 },
	335	{ wxT("Ecirc"),202 },
	336	{ wxT("Egrave"),200 },
	337	{ wxT("Epsilon"),917 },
	338	{ wxT("Eta"),919 },
	339	{ wxT("Euml"),203 },
	340	{ wxT("Gamma"),915 },
	341	{ wxT("Iacute"),205 },
	342	{ wxT("Icirc"),206 },
	343	{ wxT("Igrave"),204 },
	344	{ wxT("Iota"),921 },
	345	{ wxT("Iuml"),207 },
	346	{ wxT("Kappa"),922 },
	347	{ wxT("Lambda"),923 },
	348	{ wxT("Mu"),924 },
	349	{ wxT("Ntilde"),209 },
	350	{ wxT("Nu"),925 },
	351	{ wxT("OElig"),338 },
	352	{ wxT("Oacute"),211 },
	353	{ wxT("Ocirc"),212 },
	354	{ wxT("Ograve"),210 },
	355	{ wxT("Omega"),937 },
	356	{ wxT("Omicron"),927 },
	357	{ wxT("Oslash"),216 },
	358	{ wxT("Otilde"),213 },
	359	{ wxT("Ouml"),214 },
	360	{ wxT("Phi"),934 },
	361	{ wxT("Pi"),928 },
	362	{ wxT("Prime"),8243 },
	363	{ wxT("Psi"),936 },
	364	{ wxT("Rho"),929 },
	365	{ wxT("Scaron"),352 },
	366	{ wxT("Sigma"),931 },
	367	{ wxT("THORN"),222 },
	368	{ wxT("Tau"),932 },
369	{ wxT("Theta"),920 },
370	{ wxT("Uacute"),218 },
371	{ wxT("Ucirc"),219 },
372	{ wxT("Ugrave"),217 },
373	{ wxT("Upsilon"),933 },
374	{ wxT("Uuml"),220 },
375	{ wxT("Xi"),926 },
376	{ wxT("Yacute"),221 },
377	{ wxT("Yuml"),376 },
378	{ wxT("Zeta"),918 },
379	{ wxT("aacute"),225 },
380	{ wxT("acirc"),226 },
381	{ wxT("acute"),180 },
382	{ wxT("aelig"),230 },
383	{ wxT("agrave"),224 },
384	{ wxT("alefsym"),8501 },
385	{ wxT("alpha"),945 },
386	{ wxT("amp"),38 },
387	{ wxT("and"),8743 },
388	{ wxT("ang"),8736 },
389	{ wxT("aring"),229 },
390	{ wxT("asymp"),8776 },
391	{ wxT("atilde"),227 },
392	{ wxT("auml"),228 },
393	{ wxT("bdquo"),8222 },
394	{ wxT("beta"),946 },
395	{ wxT("brvbar"),166 },
396	{ wxT("bull"),8226 },
397	{ wxT("cap"),8745 },
398	{ wxT("ccedil"),231 },
399	{ wxT("cedil"),184 },
400	{ wxT("cent"),162 },
401	{ wxT("chi"),967 },
402	{ wxT("circ"),710 },
403	{ wxT("clubs"),9827 },
404	{ wxT("cong"),8773 },
405	{ wxT("copy"),169 },
406	{ wxT("crarr"),8629 },
407	{ wxT("cup"),8746 },
408	{ wxT("curren"),164 },
409	{ wxT("dArr"),8659 },
410	{ wxT("dagger"),8224 },
411	{ wxT("darr"),8595 },
412	{ wxT("deg"),176 },
413	{ wxT("delta"),948 },
414	{ wxT("diams"),9830 },
415	{ wxT("divide"),247 },
416	{ wxT("eacute"),233 },
417	{ wxT("ecirc"),234 },
418	{ wxT("egrave"),232 },
419	{ wxT("empty"),8709 },
420	{ wxT("emsp"),8195 },
421	{ wxT("ensp"),8194 },
422	{ wxT("epsilon"),949 },
423	{ wxT("equiv"),8801 },
424	{ wxT("eta"),951 },
425	{ wxT("eth"),240 },
426	{ wxT("euml"),235 },
427	{ wxT("euro"),8364 },
428	{ wxT("exist"),8707 },
429	{ wxT("fnof"),402 },
430	{ wxT("forall"),8704 },
431	{ wxT("frac12"),189 },
432	{ wxT("frac14"),188 },
433	{ wxT("frac34"),190 },
434	{ wxT("frasl"),8260 },
435	{ wxT("gamma"),947 },
436	{ wxT("ge"),8805 },
437	{ wxT("gt"),62 },
438	{ wxT("hArr"),8660 },
439	{ wxT("harr"),8596 },
440	{ wxT("hearts"),9829 },
441	{ wxT("hellip"),8230 },
442	{ wxT("iacute"),237 },
443	{ wxT("icirc"),238 },
444	{ wxT("iexcl"),161 },
445	{ wxT("igrave"),236 },
446	{ wxT("image"),8465 },
447	{ wxT("infin"),8734 },
448	{ wxT("int"),8747 },
449	{ wxT("iota"),953 },
450	{ wxT("iquest"),191 },
451	{ wxT("isin"),8712 },
452	{ wxT("iuml"),239 },
453	{ wxT("kappa"),954 },
454	{ wxT("lArr"),8656 },
455	{ wxT("lambda"),955 },
456	{ wxT("lang"),9001 },
457	{ wxT("laquo"),171 },
458	{ wxT("larr"),8592 },
459	{ wxT("lceil"),8968 },
460	{ wxT("ldquo"),8220 },
461	{ wxT("le"),8804 },
462	{ wxT("lfloor"),8970 },
463	{ wxT("lowast"),8727 },
464	{ wxT("loz"),9674 },
465	{ wxT("lrm"),8206 },
466	{ wxT("lsaquo"),8249 },
467	{ wxT("lsquo"),8216 },
468	{ wxT("lt"),60 },
469	{ wxT("macr"),175 },
470	{ wxT("mdash"),8212 },
471	{ wxT("micro"),181 },
472	{ wxT("middot"),183 },
473	{ wxT("minus"),8722 },
474	{ wxT("mu"),956 },
475	{ wxT("nabla"),8711 },
476	{ wxT("nbsp"),160 },
477	{ wxT("ndash"),8211 },
478	{ wxT("ne"),8800 },
479	{ wxT("ni"),8715 },
480	{ wxT("not"),172 },
481	{ wxT("notin"),8713 },
482	{ wxT("nsub"),8836 },
483	{ wxT("ntilde"),241 },
484	{ wxT("nu"),957 },
485	{ wxT("oacute"),243 },
486	{ wxT("ocirc"),244 },
487	{ wxT("oelig"),339 },
488	{ wxT("ograve"),242 },
489	{ wxT("oline"),8254 },
490	{ wxT("omega"),969 },
491	{ wxT("omicron"),959 },
492	{ wxT("oplus"),8853 },
493	{ wxT("or"),8744 },
494	{ wxT("ordf"),170 },
495	{ wxT("ordm"),186 },
496	{ wxT("oslash"),248 },
497	{ wxT("otilde"),245 },
498	{ wxT("otimes"),8855 },
499	{ wxT("ouml"),246 },
500	{ wxT("para"),182 },
501	{ wxT("part"),8706 },
502	{ wxT("permil"),8240 },
503	{ wxT("perp"),8869 },
504	{ wxT("phi"),966 },
505	{ wxT("pi"),960 },
506	{ wxT("piv"),982 },
507	{ wxT("plusmn"),177 },
508	{ wxT("pound"),163 },
509	{ wxT("prime"),8242 },
510	{ wxT("prod"),8719 },
511	{ wxT("prop"),8733 },
512	{ wxT("psi"),968 },
513	{ wxT("quot"),34 },
514	{ wxT("rArr"),8658 },
515	{ wxT("radic"),8730 },
516	{ wxT("rang"),9002 },
517	{ wxT("raquo"),187 },
518	{ wxT("rarr"),8594 },
519	{ wxT("rceil"),8969 },
520	{ wxT("rdquo"),8221 },
521	{ wxT("real"),8476 },
522	{ wxT("reg"),174 },
523	{ wxT("rfloor"),8971 },
524	{ wxT("rho"),961 },
525	{ wxT("rlm"),8207 },
526	{ wxT("rsaquo"),8250 },
527	{ wxT("rsquo"),8217 },
528	{ wxT("sbquo"),8218 },
529	{ wxT("scaron"),353 },
530	{ wxT("sdot"),8901 },
531	{ wxT("sect"),167 },
532	{ wxT("shy"),173 },
533	{ wxT("sigma"),963 },
534	{ wxT("sigmaf"),962 },
535	{ wxT("sim"),8764 },
536	{ wxT("spades"),9824 },
537	{ wxT("sub"),8834 },
538	{ wxT("sube"),8838 },
539	{ wxT("sum"),8721 },
540	{ wxT("sup"),8835 },
541	{ wxT("sup1"),185 },
542	{ wxT("sup2"),178 },
543	{ wxT("sup3"),179 },
544	{ wxT("supe"),8839 },
545	{ wxT("szlig"),223 },
546	{ wxT("tau"),964 },
547	{ wxT("there4"),8756 },
548	{ wxT("theta"),952 },
549	{ wxT("thetasym"),977 },
550	{ wxT("thinsp"),8201 },
551	{ wxT("thorn"),254 },
552	{ wxT("tilde"),732 },
553	{ wxT("times"),215 },
554	{ wxT("trade"),8482 },
555	{ wxT("uArr"),8657 },
556	{ wxT("uacute"),250 },
557	{ wxT("uarr"),8593 },
558	{ wxT("ucirc"),251 },
559	{ wxT("ugrave"),249 },
560	{ wxT("uml"),168 },
561	{ wxT("upsih"),978 },
562	{ wxT("upsilon"),965 },
563	{ wxT("uuml"),252 },
564	{ wxT("weierp"),8472 },
565	{ wxT("xi"),958 },
566	{ wxT("yacute"),253 },
567	{ wxT("yen"),165 },
568	{ wxT("yuml"),255 },
569	{ wxT("zeta"),950 },
570	{ wxT("zwj"),8205 },
571	{ wxT("zwnj"),8204 },
572	{NULL, 0}};
573	static size_t substitutions_cnt = 0;
04dbb646	574
daa616fc VS	575	if (substitutions_cnt == 0)
	576	while (substitutions[substitutions_cnt].code != 0)
	577	substitutions_cnt++;
	578
	579	wxHtmlEntityInfo *info;
04dbb646	580	info = (wxHtmlEntityInfo*) bsearch(entity.c_str(), substitutions,
daa616fc VS	581	substitutions_cnt,
	582	sizeof(wxHtmlEntityInfo),
	583	compar_entity);
	584	if (info)
	585	code = info->code;
	586	}
04dbb646	587
daa616fc VS	588	if (code == 0)
	589	return wxT('?');
	590	else
	591	return GetCharForCode(code);
	592	}
	593
	594	#endif