[wxWidgets.git] / tests / benchmarks / htmlparser / htmltag.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/html/htmltag.cpp
// Purpose:     wx28HtmlTag class (represents single tag)
// Author:      Vaclav Slavik
// Copyright:   (c) 1999 Vaclav Slavik
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "htmltag.h"

#ifndef WXPRECOMP
    #include "wx/colour.h"
#endif

#include "htmlpars.h"
#include <stdio.h> // for vsscanf
#include <stdarg.h>


//-----------------------------------------------------------------------------
// wx28HtmlTagsCache
//-----------------------------------------------------------------------------

struct wx28HtmlCacheItem
{
    // this is "pos" value passed to wx28HtmlTag's constructor.
    // it is position of '<' character of the tag
    int Key;

    // end positions for the tag:
    // end1 is '<' of ending tag,
    // end2 is '>' or both are
    // -1 if there is no ending tag for this one...
    // or -2 if this is ending tag  </...>
    int End1, End2;

    // name of this tag
    wxChar *Name;
};


IMPLEMENT_CLASS(wx28HtmlTagsCache,wxObject)

#define CACHE_INCREMENT  64

bool wxIsCDATAElement(const wxChar *tag)
{
    return (wxStrcmp(tag, wxT("SCRIPT")) == 0) ||
           (wxStrcmp(tag, wxT("STYLE")) == 0);
}

wx28HtmlTagsCache::wx28HtmlTagsCache(const wxString& source)
{
    const wxChar *src = source.c_str();
    int lng = source.length();
    wxChar tagBuffer[256];

    m_Cache = NULL;
    m_CacheSize = 0;
    m_CachePos = 0;

    int pos = 0;
    while (pos < lng)
    {
        if (src[pos] == wxT('<'))   // tag found:
        {
            if (m_CacheSize % CACHE_INCREMENT == 0)
                m_Cache = (wx28HtmlCacheItem*) realloc(m_Cache, (m_CacheSize + CACHE_INCREMENT) * sizeof(wx28HtmlCacheItem));
            int tg = m_CacheSize++;
            int stpos = pos++;
            m_Cache[tg].Key = stpos;

            int i;
            for ( i = 0;
                  pos < lng && i < (int)WXSIZEOF(tagBuffer) - 1 &&
                  src[pos] != wxT('>') && !wxIsspace(src[pos]);
                  i++, pos++ )
            {
                tagBuffer[i] = (wxChar)wxToupper(src[pos]);
            }
            tagBuffer[i] = wxT('\0');

            m_Cache[tg].Name = new wxChar[i+1];
            memcpy(m_Cache[tg].Name, tagBuffer, (i+1)*sizeof(wxChar));

            while (pos < lng && src[pos] != wxT('>')) pos++;

            if (src[stpos+1] == wxT('/')) // ending tag:
            {
                m_Cache[tg].End1 = m_Cache[tg].End2 = -2;
                // find matching begin tag:
                for (i = tg; i >= 0; i--)
                    if ((m_Cache[i].End1 == -1) && (wxStrcmp(m_Cache[i].Name, tagBuffer+1) == 0))
                    {
                        m_Cache[i].End1 = stpos;
                        m_Cache[i].End2 = pos + 1;
                        break;
                    }
            }
            else
            {
                m_Cache[tg].End1 = m_Cache[tg].End2 = -1;

                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 the ending tag
                        while (pos + 1 < lng &&
                               (src[pos] != '<' || src[pos+1] != '/'))
                            ++pos;
                        if (src[pos] == '<')
                            ++pos;

                        // see if it matches
                        int match_pos = 0;
                        while (pos < lng && match_pos < tag_len && src[pos] != '>' && src[pos] != '<') {
                            // cast to wxChar needed to suppress warning in
                            // Unicode build
                            if ((wxChar)wxToupper(src[pos]) == tagBuffer[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 {
                                match_pos = 0;
                            }
                            ++pos;
                        }

                        // found a match
                        if (match_pos == tag_len)
                        {
                            pos = pos - tag_len - 3;
                            foundCloseTag = true;
                            break;
                        }
                        else // keep looking for the closing tag
                        {
                            ++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;
                    }
                }
            }
        }

        pos++;
    }

    // ok, we're done, now we'll free .Name members of cache - we don't need it anymore:
    for (int i = 0; i < m_CacheSize; i++)
    {
        delete[] m_Cache[i].Name;
        m_Cache[i].Name = NULL;
    }
}

void wx28HtmlTagsCache::QueryTag(int at, int* end1, int* end2)
{
    if (m_Cache == NULL) return;
    if (m_Cache[m_CachePos].Key != at)
    {
        int delta = (at < m_Cache[m_CachePos].Key) ? -1 : 1;
        do
        {
            if ( m_CachePos < 0 || m_CachePos == m_CacheSize )
            {
                // something is very wrong with HTML, give up by returning an
                // impossibly large value which is going to be ignored by the
                // caller
                *end1 =
                *end2 = INT_MAX;
                return;
            }

            m_CachePos += delta;
        }
        while (m_Cache[m_CachePos].Key != at);
    }
    *end1 = m_Cache[m_CachePos].End1;
    *end2 = m_Cache[m_CachePos].End2;
}


//-----------------------------------------------------------------------------
// wx28HtmlTag
//-----------------------------------------------------------------------------

IMPLEMENT_CLASS(wx28HtmlTag,wxObject)

wx28HtmlTag::wx28HtmlTag(wx28HtmlTag *parent,
                     const wxString& source, int pos, int end_pos,
                     wx28HtmlTagsCache *cache,
                     wx28HtmlEntitiesParser *entParser) : wxObject()
{
    /* Setup DOM relations */

    m_Next = NULL;
    m_FirstChild = m_LastChild = NULL;
    m_Parent = parent;
    if (parent)
    {
        m_Prev = m_Parent->m_LastChild;
        if (m_Prev == NULL)
            m_Parent->m_FirstChild = this;
        else
            m_Prev->m_Next = this;
        m_Parent->m_LastChild = this;
    }
    else
        m_Prev = NULL;

    /* Find parameters and their values: */

    int i;
    wxChar c;

    // fill-in name, params and begin pos:
    i = pos+1;

    // find tag's name and convert it to uppercase:
    while ((i < end_pos) &&
           ((c = source[i++]) != wxT(' ') && c != wxT('\r') &&
             c != wxT('\n') && c != wxT('\t') &&
             c != wxT('>')))
    {
        if ((c >= wxT('a')) && (c <= wxT('z')))
            c -= (wxT('a') - wxT('A'));
        m_Name << c;
    }

    // if the tag has parameters, read them and "normalize" them,
    // i.e. convert to uppercase, replace whitespaces by spaces and
    // remove whitespaces around '=':
    if (source[i-1] != wxT('>'))
    {
        #define IS_WHITE(c) (c == wxT(' ') || c == wxT('\r') || \
                             c == wxT('\n') || c == wxT('\t'))
        wxString pname, pvalue;
        wxChar quote;
        enum
        {
            ST_BEFORE_NAME = 1,
            ST_NAME,
            ST_BEFORE_EQ,
            ST_BEFORE_VALUE,
            ST_VALUE
        } state;

        quote = 0;
        state = ST_BEFORE_NAME;
        while (i < end_pos)
        {
            c = source[i++];

            if (c == wxT('>') && !(state == ST_VALUE && quote != 0))
            {
                if (state == ST_BEFORE_EQ || state == ST_NAME)
                {
                    m_ParamNames.Add(pname);
                    m_ParamValues.Add(wxEmptyString);
                }
                else if (state == ST_VALUE && quote == 0)
                {
                    m_ParamNames.Add(pname);
                    if (entParser)
                        m_ParamValues.Add(entParser->Parse(pvalue));
                    else
                        m_ParamValues.Add(pvalue);
                }
                break;
            }
            switch (state)
            {
                case ST_BEFORE_NAME:
                    if (!IS_WHITE(c))
                    {
                        pname = c;
                        state = ST_NAME;
                    }
                    break;
                case ST_NAME:
                    if (IS_WHITE(c))
                        state = ST_BEFORE_EQ;
                    else if (c == wxT('='))
                        state = ST_BEFORE_VALUE;
                    else
                        pname << c;
                    break;
                case ST_BEFORE_EQ:
                    if (c == wxT('='))
                        state = ST_BEFORE_VALUE;
                    else if (!IS_WHITE(c))
                    {
                        m_ParamNames.Add(pname);
                        m_ParamValues.Add(wxEmptyString);
                        pname = c;
                        state = ST_NAME;
                    }
                    break;
                case ST_BEFORE_VALUE:
                    if (!IS_WHITE(c))
                    {
                        if (c == wxT('"') || c == wxT('\''))
                            quote = c, pvalue = wxEmptyString;
                        else
                            quote = 0, pvalue = c;
                        state = ST_VALUE;
                    }
                    break;
                case ST_VALUE:
                    if ((quote != 0 && c == quote) ||
                        (quote == 0 && IS_WHITE(c)))
                    {
                        m_ParamNames.Add(pname);
                        if (quote == 0)
                        {
                            // VS: backward compatibility, no real reason,
                            //     but wxHTML code relies on this... :(
                            pvalue.MakeUpper();
                        }
                        if (entParser)
                            m_ParamValues.Add(entParser->Parse(pvalue));
                        else
                            m_ParamValues.Add(pvalue);
                        state = ST_BEFORE_NAME;
                    }
                    else
                        pvalue << c;
                    break;
            }
        }

        #undef IS_WHITE
    }
    m_Begin = i;

    cache->QueryTag(pos, &m_End1, &m_End2);
    if (m_End1 > end_pos) m_End1 = end_pos;
    if (m_End2 > end_pos) m_End2 = end_pos;
}

wx28HtmlTag::~wx28HtmlTag()
{
    wx28HtmlTag *t1, *t2;
    t1 = m_FirstChild;
    while (t1)
    {
        t2 = t1->GetNextSibling();
        delete t1;
        t1 = t2;
    }
}

bool wx28HtmlTag::HasParam(const wxString& par) const
{
    return (m_ParamNames.Index(par, false) != wxNOT_FOUND);
}

wxString wx28HtmlTag::GetParam(const wxString& par, bool with_commas) const
{
    int index = m_ParamNames.Index(par, false);
    if (index == wxNOT_FOUND)
        return wxEmptyString;
    if (with_commas)
    {
        // VS: backward compatibility, seems to be never used by wxHTML...
        wxString s;
        s << wxT('"') << m_ParamValues[index] << wxT('"');
        return s;
    }
    else
        return m_ParamValues[index];
}

int wx28HtmlTag::ScanParam(const wxString& par,
                         const wxChar *format,
                         void *param) const
{
    wxString parval = GetParam(par);
    return wxSscanf(parval, format, param);
}

bool wx28HtmlTag::GetParamAsColour(const wxString& par, wxColour *clr) const
{
    wxCHECK_MSG( clr, false, wxT("invalid colour argument") );

    wxString str = GetParam(par);

    // handle colours defined in HTML 4.0 first:
    if (str.length() > 1 && str[0] != wxT('#'))
    {
        #define HTML_COLOUR(name, r, g, b)              \
            if (str.IsSameAs(wxT(name), false))         \
                { clr->Set(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("white",   0xFF,0xFF,0xFF)
        HTML_COLOUR("maroon",  0x80,0x00,0x00)
        HTML_COLOUR("red",     0xFF,0x00,0x00)
        HTML_COLOUR("purple",  0x80,0x00,0x80)
        HTML_COLOUR("fuchsia", 0xFF,0x00,0xFF)
        HTML_COLOUR("green",   0x00,0x80,0x00)
        HTML_COLOUR("lime",    0x00,0xFF,0x00)
        HTML_COLOUR("olive",   0x80,0x80,0x00)
        HTML_COLOUR("yellow",  0xFF,0xFF,0x00)
        HTML_COLOUR("navy",    0x00,0x00,0x80)
        HTML_COLOUR("blue",    0x00,0x00,0xFF)
        HTML_COLOUR("teal",    0x00,0x80,0x80)
        HTML_COLOUR("aqua",    0x00,0xFF,0xFF)
        #undef HTML_COLOUR
    }

    // then try to parse #rrggbb representations or set from other well
    // known names (note that this doesn't strictly conform to HTML spec,
    // but it doesn't do real harm -- but it *must* be done after the standard
    // colors are handled above):
    if (clr->Set(str))
        return true;

    return false;
}

bool wx28HtmlTag::GetParamAsInt(const wxString& par, int *clr) const
{
    if ( !HasParam(par) )
        return false;

    long i;
    if ( !GetParam(par).ToLong(&i) )
        return false;

    *clr = (int)i;
    return true;
}

wxString wx28HtmlTag::GetAllParams() const
{
    // VS: this function is for backward compatibility only,
    //     never used by wxHTML
    wxString s;
    size_t cnt = m_ParamNames.GetCount();
    for (size_t i = 0; i < cnt; i++)
    {
        s << m_ParamNames[i];
        s << wxT('=');
        if (m_ParamValues[i].Find(wxT('"')) != wxNOT_FOUND)
            s << wxT('\'') << m_ParamValues[i] << wxT('\'');
        else
            s << wxT('"') << m_ParamValues[i] << wxT('"');
    }
    return s;
}

wx28HtmlTag *wx28HtmlTag::GetFirstSibling() const
{
    if (m_Parent)
        return m_Parent->m_FirstChild;
    else
    {
        wx28HtmlTag *cur = (wx28HtmlTag*)this;
        while (cur->m_Prev)
            cur = cur->m_Prev;
        return cur;
    }
}

wx28HtmlTag *wx28HtmlTag::GetLastSibling() const
{
    if (m_Parent)
        return m_Parent->m_LastChild;
    else
    {
        wx28HtmlTag *cur = (wx28HtmlTag*)this;
        while (cur->m_Next)
            cur = cur->m_Next;
        return cur;
    }
}

wx28HtmlTag *wx28HtmlTag::GetNextTag() const
{
    if (m_FirstChild) return m_FirstChild;
    if (m_Next) return m_Next;
    wx28HtmlTag *cur = m_Parent;
    if (!cur) return NULL;
    while (cur->m_Parent && !cur->m_Next)
        cur = cur->m_Parent;
    return cur->m_Next;
}
Commit	Line	Data
c21faa0a VS	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/html/htmltag.cpp
	3	// Purpose: wx28HtmlTag class (represents single tag)
	4	// Author: Vaclav Slavik
c21faa0a VS	5	// Copyright: (c) 1999 Vaclav Slavik
	6	// Licence: wxWindows licence
	7	/////////////////////////////////////////////////////////////////////////////
	8
	9	#include "wx/wxprec.h"
	10
	11	#ifdef __BORLANDC__
	12	#pragma hdrstop
	13	#endif
	14
	15	#include "htmltag.h"
	16
	17	#ifndef WXPRECOMP
	18	#include "wx/colour.h"
	19	#endif
	20
	21	#include "htmlpars.h"
	22	#include <stdio.h> // for vsscanf
	23	#include <stdarg.h>
	24
	25
	26	//-----------------------------------------------------------------------------
	27	// wx28HtmlTagsCache
	28	//-----------------------------------------------------------------------------
	29
	30	struct wx28HtmlCacheItem
	31	{
	32	// this is "pos" value passed to wx28HtmlTag's constructor.
	33	// it is position of '<' character of the tag
	34	int Key;
	35
	36	// end positions for the tag:
	37	// end1 is '<' of ending tag,
	38	// end2 is '>' or both are
	39	// -1 if there is no ending tag for this one...
	40	// or -2 if this is ending tag </...>
	41	int End1, End2;
	42
	43	// name of this tag
	44	wxChar *Name;
	45	};
	46
	47
	48	IMPLEMENT_CLASS(wx28HtmlTagsCache,wxObject)
	49
	50	#define CACHE_INCREMENT 64
	51
	52	bool wxIsCDATAElement(const wxChar *tag)
	53	{
9a83f860 VZ	54	return (wxStrcmp(tag, wxT("SCRIPT")) == 0) \|\|
9a83f860 VZ	55	(wxStrcmp(tag, wxT("STYLE")) == 0);
c21faa0a VS	56	}
	57
	58	wx28HtmlTagsCache::wx28HtmlTagsCache(const wxString& source)
	59	{
	60	const wxChar *src = source.c_str();
	61	int lng = source.length();
	62	wxChar tagBuffer[256];
	63
	64	m_Cache = NULL;
	65	m_CacheSize = 0;
	66	m_CachePos = 0;
	67
	68	int pos = 0;
	69	while (pos < lng)
	70	{
	71	if (src[pos] == wxT('<')) // tag found:
	72	{
	73	if (m_CacheSize % CACHE_INCREMENT == 0)
	74	m_Cache = (wx28HtmlCacheItem) realloc(m_Cache, (m_CacheSize + CACHE_INCREMENT) sizeof(wx28HtmlCacheItem));
	75	int tg = m_CacheSize++;
	76	int stpos = pos++;
	77	m_Cache[tg].Key = stpos;
	78
	79	int i;
	80	for ( i = 0;
	81	pos < lng && i < (int)WXSIZEOF(tagBuffer) - 1 &&
	82	src[pos] != wxT('>') && !wxIsspace(src[pos]);
	83	i++, pos++ )
	84	{
	85	tagBuffer[i] = (wxChar)wxToupper(src[pos]);
	86	}
9a83f860	87	tagBuffer[i] = wxT('\0');
c21faa0a VS	88
	89	m_Cache[tg].Name = new wxChar[i+1];
	90	memcpy(m_Cache[tg].Name, tagBuffer, (i+1)*sizeof(wxChar));
	91
	92	while (pos < lng && src[pos] != wxT('>')) pos++;
	93
	94	if (src[stpos+1] == wxT('/')) // ending tag:
	95	{
	96	m_Cache[tg].End1 = m_Cache[tg].End2 = -2;
	97	// find matching begin tag:
	98	for (i = tg; i >= 0; i--)
	99	if ((m_Cache[i].End1 == -1) && (wxStrcmp(m_Cache[i].Name, tagBuffer+1) == 0))
	100	{
	101	m_Cache[i].End1 = stpos;
	102	m_Cache[i].End2 = pos + 1;
	103	break;
	104	}
	105	}
	106	else
	107	{
	108	m_Cache[tg].End1 = m_Cache[tg].End2 = -1;
	109
	110	if (wxIsCDATAElement(tagBuffer))
	111	{
	112	// store the orig pos in case we are missing the closing
	113	// tag (see below)
	114	wxInt32 old_pos = pos;
	115	bool foundCloseTag = false;
	116
	117	// find next matching tag
	118	int tag_len = wxStrlen(tagBuffer);
	119	while (pos < lng)
	120	{
	121	// find the ending tag
	122	while (pos + 1 < lng &&
	123	(src[pos] != '<' \|\| src[pos+1] != '/'))
	124	++pos;
	125	if (src[pos] == '<')
	126	++pos;
	127
	128	// see if it matches
	129	int match_pos = 0;
	130	while (pos < lng && match_pos < tag_len && src[pos] != '>' && src[pos] != '<') {
	131	// cast to wxChar needed to suppress warning in
	132	// Unicode build
	133	if ((wxChar)wxToupper(src[pos]) == tagBuffer[match_pos]) {
	134	++match_pos;
	135	}
	136	else if (src[pos] == wxT(' ') \|\| src[pos] == wxT('\n') \|\|
	137	src[pos] == wxT('\r') \|\| src[pos] == wxT('\t')) {
	138	// need to skip over these
	139	}
	140	else {
	141	match_pos = 0;
	142	}
	143	++pos;
	144	}
	145
	146	// found a match
	147	if (match_pos == tag_len)
	148	{
	149	pos = pos - tag_len - 3;
	150	foundCloseTag = true;
	151	break;
152	}
153	else // keep looking for the closing tag
154	{
155	++pos;
156	}
157	}
158	if (!foundCloseTag)
159	{
160	// we didn't find closing tag; this means the markup
161	// is incorrect and the best thing we can do is to
162	// ignore the unclosed tag and continue parsing as if
163	// it didn't exist:
164	pos = old_pos;
165	}
166	}
167	}
168	}
169
170	pos++;
171	}
172
173	// ok, we're done, now we'll free .Name members of cache - we don't need it anymore:
174	for (int i = 0; i < m_CacheSize; i++)
175	{
176	delete[] m_Cache[i].Name;
177	m_Cache[i].Name = NULL;
178	}
179	}
180
181	void wx28HtmlTagsCache::QueryTag(int at, int* end1, int* end2)
182	{
183	if (m_Cache == NULL) return;
184	if (m_Cache[m_CachePos].Key != at)
185	{
186	int delta = (at < m_Cache[m_CachePos].Key) ? -1 : 1;
187	do
188	{
189	if ( m_CachePos < 0 \|\| m_CachePos == m_CacheSize )
190	{
191	// something is very wrong with HTML, give up by returning an
192	// impossibly large value which is going to be ignored by the
193	// caller
194	*end1 =
195	*end2 = INT_MAX;
196	return;
197	}
198
199	m_CachePos += delta;
200	}
201	while (m_Cache[m_CachePos].Key != at);
202	}
203	*end1 = m_Cache[m_CachePos].End1;
204	*end2 = m_Cache[m_CachePos].End2;
205	}
206
207
208
209
210	//-----------------------------------------------------------------------------
211	// wx28HtmlTag
212	//-----------------------------------------------------------------------------
213
214	IMPLEMENT_CLASS(wx28HtmlTag,wxObject)
215
216	wx28HtmlTag::wx28HtmlTag(wx28HtmlTag *parent,
217	const wxString& source, int pos, int end_pos,
218	wx28HtmlTagsCache *cache,
219	wx28HtmlEntitiesParser *entParser) : wxObject()
220	{
221	/* Setup DOM relations */
222
223	m_Next = NULL;
224	m_FirstChild = m_LastChild = NULL;
225	m_Parent = parent;
226	if (parent)
227	{
228	m_Prev = m_Parent->m_LastChild;
229	if (m_Prev == NULL)
230	m_Parent->m_FirstChild = this;
231	else
232	m_Prev->m_Next = this;
233	m_Parent->m_LastChild = this;
234	}
235	else
236	m_Prev = NULL;
237
238	/* Find parameters and their values: */
239
240	int i;
241	wxChar c;
242
243	// fill-in name, params and begin pos:
244	i = pos+1;
245
246	// find tag's name and convert it to uppercase:
247	while ((i < end_pos) &&
248	((c = source[i++]) != wxT(' ') && c != wxT('\r') &&
249	c != wxT('\n') && c != wxT('\t') &&
250	c != wxT('>')))
251	{
252	if ((c >= wxT('a')) && (c <= wxT('z')))
253	c -= (wxT('a') - wxT('A'));
254	m_Name << c;
255	}
256
257	// if the tag has parameters, read them and "normalize" them,
258	// i.e. convert to uppercase, replace whitespaces by spaces and
259	// remove whitespaces around '=':
260	if (source[i-1] != wxT('>'))
261	{
262	#define IS_WHITE(c) (c == wxT(' ') \|\| c == wxT('\r') \|\| \
263	c == wxT('\n') \|\| c == wxT('\t'))
264	wxString pname, pvalue;
265	wxChar quote;
266	enum
267	{
268	ST_BEFORE_NAME = 1,
269	ST_NAME,
270	ST_BEFORE_EQ,
271	ST_BEFORE_VALUE,
272	ST_VALUE
273	} state;
274
275	quote = 0;
276	state = ST_BEFORE_NAME;
277	while (i < end_pos)
278	{
279	c = source[i++];
280
281	if (c == wxT('>') && !(state == ST_VALUE && quote != 0))
282	{
283	if (state == ST_BEFORE_EQ \|\| state == ST_NAME)
284	{
285	m_ParamNames.Add(pname);
286	m_ParamValues.Add(wxEmptyString);
287	}
288	else if (state == ST_VALUE && quote == 0)
289	{
290	m_ParamNames.Add(pname);
291	if (entParser)
292	m_ParamValues.Add(entParser->Parse(pvalue));
293	else
294	m_ParamValues.Add(pvalue);
295	}
296	break;
297	}
298	switch (state)
299	{
300	case ST_BEFORE_NAME:
301	if (!IS_WHITE(c))
302	{
303	pname = c;
304	state = ST_NAME;
305	}
306	break;
307	case ST_NAME:
308	if (IS_WHITE(c))
309	state = ST_BEFORE_EQ;
310	else if (c == wxT('='))
311	state = ST_BEFORE_VALUE;
312	else
313	pname << c;
314	break;
315	case ST_BEFORE_EQ:
316	if (c == wxT('='))
317	state = ST_BEFORE_VALUE;
318	else if (!IS_WHITE(c))
319	{
320	m_ParamNames.Add(pname);
321	m_ParamValues.Add(wxEmptyString);
322	pname = c;
323	state = ST_NAME;
324	}
325	break;
326	case ST_BEFORE_VALUE:
327	if (!IS_WHITE(c))
328	{
329	if (c == wxT('"') \|\| c == wxT('\''))
330	quote = c, pvalue = wxEmptyString;
331	else
332	quote = 0, pvalue = c;
333	state = ST_VALUE;
334	}
335	break;
336	case ST_VALUE:
337	if ((quote != 0 && c == quote) \|\|
338	(quote == 0 && IS_WHITE(c)))
339	{
340	m_ParamNames.Add(pname);
341	if (quote == 0)
342	{
343	// VS: backward compatibility, no real reason,
344	// but wxHTML code relies on this... :(
345	pvalue.MakeUpper();
346	}
347	if (entParser)
348	m_ParamValues.Add(entParser->Parse(pvalue));
349	else
350	m_ParamValues.Add(pvalue);
351	state = ST_BEFORE_NAME;
352	}
353	else
354	pvalue << c;
355	break;
356	}
357	}
358
359	#undef IS_WHITE
360	}
361	m_Begin = i;
362
363	cache->QueryTag(pos, &m_End1, &m_End2);
364	if (m_End1 > end_pos) m_End1 = end_pos;
365	if (m_End2 > end_pos) m_End2 = end_pos;
366	}
367
368	wx28HtmlTag::~wx28HtmlTag()
369	{
370	wx28HtmlTag t1, t2;
371	t1 = m_FirstChild;
372	while (t1)
373	{
374	t2 = t1->GetNextSibling();
375	delete t1;
376	t1 = t2;
377	}
378	}
379
380	bool wx28HtmlTag::HasParam(const wxString& par) const
381	{
382	return (m_ParamNames.Index(par, false) != wxNOT_FOUND);
383	}
384
385	wxString wx28HtmlTag::GetParam(const wxString& par, bool with_commas) const
386	{
387	int index = m_ParamNames.Index(par, false);
388	if (index == wxNOT_FOUND)
389	return wxEmptyString;
390	if (with_commas)
391	{
392	// VS: backward compatibility, seems to be never used by wxHTML...
393	wxString s;
394	s << wxT('"') << m_ParamValues[index] << wxT('"');
395	return s;
396	}
397	else
398	return m_ParamValues[index];
399	}
400
401	int wx28HtmlTag::ScanParam(const wxString& par,
402	const wxChar *format,
403	void *param) const
404	{
405	wxString parval = GetParam(par);
406	return wxSscanf(parval, format, param);
407	}
408
409	bool wx28HtmlTag::GetParamAsColour(const wxString& par, wxColour *clr) const
410	{
9a83f860	411	wxCHECK_MSG( clr, false, wxT("invalid colour argument") );
c21faa0a VS	412
	413	wxString str = GetParam(par);
	414
	415	// handle colours defined in HTML 4.0 first:
9a83f860	416	if (str.length() > 1 && str[0] != wxT('#'))
c21faa0a VS	417	{
	418	#define HTML_COLOUR(name, r, g, b) \
	419	if (str.IsSameAs(wxT(name), false)) \
	420	{ clr->Set(r, g, b); return true; }
	421	HTML_COLOUR("black", 0x00,0x00,0x00)
	422	HTML_COLOUR("silver", 0xC0,0xC0,0xC0)
	423	HTML_COLOUR("gray", 0x80,0x80,0x80)
	424	HTML_COLOUR("white", 0xFF,0xFF,0xFF)
	425	HTML_COLOUR("maroon", 0x80,0x00,0x00)
	426	HTML_COLOUR("red", 0xFF,0x00,0x00)
	427	HTML_COLOUR("purple", 0x80,0x00,0x80)
	428	HTML_COLOUR("fuchsia", 0xFF,0x00,0xFF)
	429	HTML_COLOUR("green", 0x00,0x80,0x00)
	430	HTML_COLOUR("lime", 0x00,0xFF,0x00)
	431	HTML_COLOUR("olive", 0x80,0x80,0x00)
	432	HTML_COLOUR("yellow", 0xFF,0xFF,0x00)
	433	HTML_COLOUR("navy", 0x00,0x00,0x80)
	434	HTML_COLOUR("blue", 0x00,0x00,0xFF)
	435	HTML_COLOUR("teal", 0x00,0x80,0x80)
	436	HTML_COLOUR("aqua", 0x00,0xFF,0xFF)
	437	#undef HTML_COLOUR
	438	}
	439
	440	// then try to parse #rrggbb representations or set from other well
	441	// known names (note that this doesn't strictly conform to HTML spec,
	442	// but it doesn't do real harm -- but it must be done after the standard
	443	// colors are handled above):
	444	if (clr->Set(str))
	445	return true;
	446
	447	return false;
	448	}
	449
	450	bool wx28HtmlTag::GetParamAsInt(const wxString& par, int *clr) const
	451	{
	452	if ( !HasParam(par) )
	453	return false;
	454
	455	long i;
	456	if ( !GetParam(par).ToLong(&i) )
	457	return false;
	458
	459	*clr = (int)i;
	460	return true;
	461	}
	462
	463	wxString wx28HtmlTag::GetAllParams() const
	464	{
	465	// VS: this function is for backward compatibility only,
	466	// never used by wxHTML
	467	wxString s;
	468	size_t cnt = m_ParamNames.GetCount();
	469	for (size_t i = 0; i < cnt; i++)
	470	{
	471	s << m_ParamNames[i];
	472	s << wxT('=');
	473	if (m_ParamValues[i].Find(wxT('"')) != wxNOT_FOUND)
	474	s << wxT('\'') << m_ParamValues[i] << wxT('\'');
	475	else
	476	s << wxT('"') << m_ParamValues[i] << wxT('"');
	477	}
	478	return s;
	479	}
	480
481	wx28HtmlTag *wx28HtmlTag::GetFirstSibling() const
482	{
483	if (m_Parent)
484	return m_Parent->m_FirstChild;
485	else
486	{
487	wx28HtmlTag cur = (wx28HtmlTag)this;
488	while (cur->m_Prev)
489	cur = cur->m_Prev;
490	return cur;
491	}
492	}
493
494	wx28HtmlTag *wx28HtmlTag::GetLastSibling() const
495	{
496	if (m_Parent)
497	return m_Parent->m_LastChild;
498	else
499	{
500	wx28HtmlTag cur = (wx28HtmlTag)this;
501	while (cur->m_Next)
502	cur = cur->m_Next;
503	return cur;
504	}
505	}
506
507	wx28HtmlTag *wx28HtmlTag::GetNextTag() const
508	{
509	if (m_FirstChild) return m_FirstChild;
510	if (m_Next) return m_Next;
511	wx28HtmlTag *cur = m_Parent;
512	if (!cur) return NULL;
513	while (cur->m_Parent && !cur->m_Next)
514	cur = cur->m_Parent;
515	return cur->m_Next;
516	}