[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()
{
#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;
    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	{
5438a566	222	#if wxUSE_WCHAR_T && !wxUSE_UNICODE
daa616fc	223	delete m_conv;
5438a566	224	#endif
daa616fc	225	}
5526e819	226
daa616fc VS	227	void wxHtmlEntitiesParser::SetEncoding(wxFontEncoding encoding)
	228	{
	229	#if wxUSE_WCHAR_T && !wxUSE_UNICODE
	230	if (encoding == m_encoding) return;
	231	delete m_conv;
	232	m_conv = NULL;
	233	m_encoding = encoding;
	234	if (m_encoding != wxFONTENCODING_SYSTEM)
	235	m_conv = new wxCSConv(wxFontMapper::GetEncodingName(m_encoding));
	236	#endif
	237	}
	238
	239	wxString wxHtmlEntitiesParser::Parse(const wxString& input)
	240	{
	241	const wxChar c, last;
	242	const wxChar *in_str = input.c_str();
	243	wxString output;
04dbb646	244
daa616fc VS	245	for (c = in_str, last = in_str; *c != wxT('\0'); c++)
	246	{
	247	if (*c == wxT('&'))
	248	{
	249	if (c - last > 0)
	250	output.append(last, c - last);
	251	if (++c == wxT('\0')) break;
	252	wxString entity;
	253	const wxChar *ent_s = c;
	254	for (; (c >= wxT('a') && c <= wxT('z')) \|\|
	255	(c >= wxT('A') && c <= wxT('Z')) \|\|
	256	(c >= wxT('0') && c <= wxT('9')) \|\|
	257	c == wxT('_') \|\| c == wxT('#'); c++) {}
	258	entity.append(ent_s, c - ent_s);
	259	if (*c == wxT(';')) c++;
	260	output << GetEntityChar(entity);
	261	last = c;
	262	}
	263	}
	264	if (*last != wxT('\0'))
	265	output.append(last);
	266	return output;
	267	}
	268
	269	struct wxHtmlEntityInfo
	270	{
	271	const wxChar *name;
	272	unsigned code;
	273	};
	274
53776059	275	static int LINKAGEMODE compar_entity(const void key, const void item)
daa616fc VS	276	{
	277	return wxStrcmp((wxChar)key, ((wxHtmlEntityInfo)item)->name);
	278	}
	279
	280	wxChar wxHtmlEntitiesParser::GetCharForCode(unsigned code)
	281	{
	282	#if wxUSE_UNICODE
	283	return (wxChar)code;
	284	#elif wxUSE_WCHAR_T
	285	char buf[2];
	286	wchar_t wbuf[2];
	287	wbuf[0] = (wchar_t)code;
	288	wbuf[1] = 0;
	289	wxMBConv *conv = m_conv ? m_conv : &wxConvLocal;
	290	if (conv->WC2MB(buf, wbuf, 1) == (size_t)-1)
	291	return '?';
	292	return buf[0];
	293	#else
	294	return (code < 256) ? (wxChar)code : '?';
	295	#endif
	296	}
	297
	298	wxChar wxHtmlEntitiesParser::GetEntityChar(const wxString& entity)
	299	{
	300	unsigned code = 0;
04dbb646	301
daa616fc VS	302	if (entity[0] == wxT('#'))
	303	{
	304	const wxChar *ent_s = entity.c_str();
	305	const wxChar *format;
04dbb646	306
daa616fc VS	307	if (ent_s[1] == wxT('x') \|\| ent_s[1] == wxT('X'))
	308	{
	309	format = wxT("%x");
	310	ent_s++;
	311	}
	312	else
	313	format = wxT("%u");
	314	ent_s++;
	315
	316	if (wxSscanf(ent_s, format, &code) != 1)
	317	code = 0;
	318	}
	319	else
	320	{
	321	static wxHtmlEntityInfo substitutions[] = {
	322	{ wxT("AElig"),198 },
	323	{ wxT("Aacute"),193 },
	324	{ wxT("Acirc"),194 },
	325	{ wxT("Agrave"),192 },
	326	{ wxT("Alpha"),913 },
	327	{ wxT("Aring"),197 },
	328	{ wxT("Atilde"),195 },
	329	{ wxT("Auml"),196 },
	330	{ wxT("Beta"),914 },
	331	{ wxT("Ccedil"),199 },
	332	{ wxT("Chi"),935 },
	333	{ wxT("Dagger"),8225 },
	334	{ wxT("Delta"),916 },
	335	{ wxT("ETH"),208 },
	336	{ wxT("Eacute"),201 },
	337	{ wxT("Ecirc"),202 },
	338	{ wxT("Egrave"),200 },
	339	{ wxT("Epsilon"),917 },
	340	{ wxT("Eta"),919 },
	341	{ wxT("Euml"),203 },
	342	{ wxT("Gamma"),915 },
	343	{ wxT("Iacute"),205 },
	344	{ wxT("Icirc"),206 },
	345	{ wxT("Igrave"),204 },
	346	{ wxT("Iota"),921 },
	347	{ wxT("Iuml"),207 },
	348	{ wxT("Kappa"),922 },
	349	{ wxT("Lambda"),923 },
	350	{ wxT("Mu"),924 },
	351	{ wxT("Ntilde"),209 },
	352	{ wxT("Nu"),925 },
	353	{ wxT("OElig"),338 },
	354	{ wxT("Oacute"),211 },
	355	{ wxT("Ocirc"),212 },
	356	{ wxT("Ograve"),210 },
	357	{ wxT("Omega"),937 },
	358	{ wxT("Omicron"),927 },
	359	{ wxT("Oslash"),216 },
	360	{ wxT("Otilde"),213 },
	361	{ wxT("Ouml"),214 },
	362	{ wxT("Phi"),934 },
	363	{ wxT("Pi"),928 },
	364	{ wxT("Prime"),8243 },
	365	{ wxT("Psi"),936 },
	366	{ wxT("Rho"),929 },
	367	{ wxT("Scaron"),352 },
	368	{ wxT("Sigma"),931 },
	369	{ wxT("THORN"),222 },
	370	{ wxT("Tau"),932 },
371	{ wxT("Theta"),920 },
372	{ wxT("Uacute"),218 },
373	{ wxT("Ucirc"),219 },
374	{ wxT("Ugrave"),217 },
375	{ wxT("Upsilon"),933 },
376	{ wxT("Uuml"),220 },
377	{ wxT("Xi"),926 },
378	{ wxT("Yacute"),221 },
379	{ wxT("Yuml"),376 },
380	{ wxT("Zeta"),918 },
381	{ wxT("aacute"),225 },
382	{ wxT("acirc"),226 },
383	{ wxT("acute"),180 },
384	{ wxT("aelig"),230 },
385	{ wxT("agrave"),224 },
386	{ wxT("alefsym"),8501 },
387	{ wxT("alpha"),945 },
388	{ wxT("amp"),38 },
389	{ wxT("and"),8743 },
390	{ wxT("ang"),8736 },
391	{ wxT("aring"),229 },
392	{ wxT("asymp"),8776 },
393	{ wxT("atilde"),227 },
394	{ wxT("auml"),228 },
395	{ wxT("bdquo"),8222 },
396	{ wxT("beta"),946 },
397	{ wxT("brvbar"),166 },
398	{ wxT("bull"),8226 },
399	{ wxT("cap"),8745 },
400	{ wxT("ccedil"),231 },
401	{ wxT("cedil"),184 },
402	{ wxT("cent"),162 },
403	{ wxT("chi"),967 },
404	{ wxT("circ"),710 },
405	{ wxT("clubs"),9827 },
406	{ wxT("cong"),8773 },
407	{ wxT("copy"),169 },
408	{ wxT("crarr"),8629 },
409	{ wxT("cup"),8746 },
410	{ wxT("curren"),164 },
411	{ wxT("dArr"),8659 },
412	{ wxT("dagger"),8224 },
413	{ wxT("darr"),8595 },
414	{ wxT("deg"),176 },
415	{ wxT("delta"),948 },
416	{ wxT("diams"),9830 },
417	{ wxT("divide"),247 },
418	{ wxT("eacute"),233 },
419	{ wxT("ecirc"),234 },
420	{ wxT("egrave"),232 },
421	{ wxT("empty"),8709 },
422	{ wxT("emsp"),8195 },
423	{ wxT("ensp"),8194 },
424	{ wxT("epsilon"),949 },
425	{ wxT("equiv"),8801 },
426	{ wxT("eta"),951 },
427	{ wxT("eth"),240 },
428	{ wxT("euml"),235 },
429	{ wxT("euro"),8364 },
430	{ wxT("exist"),8707 },
431	{ wxT("fnof"),402 },
432	{ wxT("forall"),8704 },
433	{ wxT("frac12"),189 },
434	{ wxT("frac14"),188 },
435	{ wxT("frac34"),190 },
436	{ wxT("frasl"),8260 },
437	{ wxT("gamma"),947 },
438	{ wxT("ge"),8805 },
439	{ wxT("gt"),62 },
440	{ wxT("hArr"),8660 },
441	{ wxT("harr"),8596 },
442	{ wxT("hearts"),9829 },
443	{ wxT("hellip"),8230 },
444	{ wxT("iacute"),237 },
445	{ wxT("icirc"),238 },
446	{ wxT("iexcl"),161 },
447	{ wxT("igrave"),236 },
448	{ wxT("image"),8465 },
449	{ wxT("infin"),8734 },
450	{ wxT("int"),8747 },
451	{ wxT("iota"),953 },
452	{ wxT("iquest"),191 },
453	{ wxT("isin"),8712 },
454	{ wxT("iuml"),239 },
455	{ wxT("kappa"),954 },
456	{ wxT("lArr"),8656 },
457	{ wxT("lambda"),955 },
458	{ wxT("lang"),9001 },
459	{ wxT("laquo"),171 },
460	{ wxT("larr"),8592 },
461	{ wxT("lceil"),8968 },
462	{ wxT("ldquo"),8220 },
463	{ wxT("le"),8804 },
464	{ wxT("lfloor"),8970 },
465	{ wxT("lowast"),8727 },
466	{ wxT("loz"),9674 },
467	{ wxT("lrm"),8206 },
468	{ wxT("lsaquo"),8249 },
469	{ wxT("lsquo"),8216 },
470	{ wxT("lt"),60 },
471	{ wxT("macr"),175 },
472	{ wxT("mdash"),8212 },
473	{ wxT("micro"),181 },
474	{ wxT("middot"),183 },
475	{ wxT("minus"),8722 },
476	{ wxT("mu"),956 },
477	{ wxT("nabla"),8711 },
478	{ wxT("nbsp"),160 },
479	{ wxT("ndash"),8211 },
480	{ wxT("ne"),8800 },
481	{ wxT("ni"),8715 },
482	{ wxT("not"),172 },
483	{ wxT("notin"),8713 },
484	{ wxT("nsub"),8836 },
485	{ wxT("ntilde"),241 },
486	{ wxT("nu"),957 },
487	{ wxT("oacute"),243 },
488	{ wxT("ocirc"),244 },
489	{ wxT("oelig"),339 },
490	{ wxT("ograve"),242 },
491	{ wxT("oline"),8254 },
492	{ wxT("omega"),969 },
493	{ wxT("omicron"),959 },
494	{ wxT("oplus"),8853 },
495	{ wxT("or"),8744 },
496	{ wxT("ordf"),170 },
497	{ wxT("ordm"),186 },
498	{ wxT("oslash"),248 },
499	{ wxT("otilde"),245 },
500	{ wxT("otimes"),8855 },
501	{ wxT("ouml"),246 },
502	{ wxT("para"),182 },
503	{ wxT("part"),8706 },
504	{ wxT("permil"),8240 },
505	{ wxT("perp"),8869 },
506	{ wxT("phi"),966 },
507	{ wxT("pi"),960 },
508	{ wxT("piv"),982 },
509	{ wxT("plusmn"),177 },
510	{ wxT("pound"),163 },
511	{ wxT("prime"),8242 },
512	{ wxT("prod"),8719 },
513	{ wxT("prop"),8733 },
514	{ wxT("psi"),968 },
515	{ wxT("quot"),34 },
516	{ wxT("rArr"),8658 },
517	{ wxT("radic"),8730 },
518	{ wxT("rang"),9002 },
519	{ wxT("raquo"),187 },
520	{ wxT("rarr"),8594 },
521	{ wxT("rceil"),8969 },
522	{ wxT("rdquo"),8221 },
523	{ wxT("real"),8476 },
524	{ wxT("reg"),174 },
525	{ wxT("rfloor"),8971 },
526	{ wxT("rho"),961 },
527	{ wxT("rlm"),8207 },
528	{ wxT("rsaquo"),8250 },
529	{ wxT("rsquo"),8217 },
530	{ wxT("sbquo"),8218 },
531	{ wxT("scaron"),353 },
532	{ wxT("sdot"),8901 },
533	{ wxT("sect"),167 },
534	{ wxT("shy"),173 },
535	{ wxT("sigma"),963 },
536	{ wxT("sigmaf"),962 },
537	{ wxT("sim"),8764 },
538	{ wxT("spades"),9824 },
539	{ wxT("sub"),8834 },
540	{ wxT("sube"),8838 },
541	{ wxT("sum"),8721 },
542	{ wxT("sup"),8835 },
543	{ wxT("sup1"),185 },
544	{ wxT("sup2"),178 },
545	{ wxT("sup3"),179 },
546	{ wxT("supe"),8839 },
547	{ wxT("szlig"),223 },
548	{ wxT("tau"),964 },
549	{ wxT("there4"),8756 },
550	{ wxT("theta"),952 },
551	{ wxT("thetasym"),977 },
552	{ wxT("thinsp"),8201 },
553	{ wxT("thorn"),254 },
554	{ wxT("tilde"),732 },
555	{ wxT("times"),215 },
556	{ wxT("trade"),8482 },
557	{ wxT("uArr"),8657 },
558	{ wxT("uacute"),250 },
559	{ wxT("uarr"),8593 },
560	{ wxT("ucirc"),251 },
561	{ wxT("ugrave"),249 },
562	{ wxT("uml"),168 },
563	{ wxT("upsih"),978 },
564	{ wxT("upsilon"),965 },
565	{ wxT("uuml"),252 },
566	{ wxT("weierp"),8472 },
567	{ wxT("xi"),958 },
568	{ wxT("yacute"),253 },
569	{ wxT("yen"),165 },
570	{ wxT("yuml"),255 },
571	{ wxT("zeta"),950 },
572	{ wxT("zwj"),8205 },
573	{ wxT("zwnj"),8204 },
574	{NULL, 0}};
575	static size_t substitutions_cnt = 0;
04dbb646	576
daa616fc VS	577	if (substitutions_cnt == 0)
	578	while (substitutions[substitutions_cnt].code != 0)
	579	substitutions_cnt++;
	580
	581	wxHtmlEntityInfo *info;
04dbb646	582	info = (wxHtmlEntityInfo*) bsearch(entity.c_str(), substitutions,
daa616fc VS	583	substitutions_cnt,
	584	sizeof(wxHtmlEntityInfo),
	585	compar_entity);
	586	if (info)
	587	code = info->code;
	588	}
04dbb646	589
daa616fc VS	590	if (code == 0)
	591	return wxT('?');
	592	else
	593	return GetCharForCode(code);
	594	}
	595
	596	#endif