src/common/markupparser.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/common/markupparser.cpp
// Purpose:     Implementation of wxMarkupParser.
// Author:      Vadim Zeitlin
// Created:     2011-02-16
// RCS-ID:      $Id$
// Copyright:   (c) 2011 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// for compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_MARKUP

#ifndef WX_PRECOMP
    #include "wx/log.h"
#endif

#include "wx/private/markupparser.h"

#include "wx/stack.h"

namespace
{

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// Array containing the predefined XML 1.0 entities.
const struct XMLEntity
{
    const char *name;
    int len;            // == strlen(name)
    char value;
} xmlEntities[] =
{
    { "lt",     2,  '<' },
    { "gt",     2,  '>' },
    { "amp",    3,  '&' },
    { "apos",   4,  '\''},
    { "quot",   4,  '"' },
};

// ----------------------------------------------------------------------------
// helper functions
// ----------------------------------------------------------------------------

wxString
ExtractUntil(char ch, wxString::const_iterator& it, wxString::const_iterator end)
{
    wxString str;
    for ( ; it != end; ++it )
    {
        if ( *it == ch )
            return str;

        str += *it;
    }

    // Return empty string to indicate that we didn't find ch at all.
    return wxString();
}

} // anonymous namespace

// ============================================================================
// wxMarkupParser implementation
// ============================================================================

wxString
wxMarkupParser::ParseAttrs(wxString attrs, TagAndAttrs& tagAndAttrs)
{
    if ( tagAndAttrs.name.CmpNoCase("span") != 0 && !attrs.empty() )
    {
        return wxString::Format("tag \"%s\" can't have attributes",
                                tagAndAttrs.name);
    }

    // TODO: Parse more attributes described at
    //       http://library.gnome.org/devel/pango/stable/PangoMarkupFormat.html
    //       and at least ignore them gracefully instead of giving errors (but
    //       quite a few of them could be supported as well, notable font_desc).

    wxMarkupSpanAttributes& spanAttrs = tagAndAttrs.attrs;

    while ( !attrs.empty() )
    {
        wxString rest;
        const wxString attr = attrs.BeforeFirst(' ', &rest);
        attrs = rest;

        // The "original" versions are used for error messages only.
        wxString valueOrig;
        const wxString nameOrig = attr.BeforeFirst('=', &valueOrig);

        const wxString name = nameOrig.Lower();
        wxString value = valueOrig.Lower();

        // All attributes values must be quoted.
        if ( value.length() < 2 ||
                (value[0] != value.Last()) ||
                    (value[0] != '"' && value[0] != '\'') )
        {
            return wxString::Format("bad quoting for value of \"%s\"",
                                    nameOrig);
        }

        value.assign(value, 1, value.length() - 2);

        if ( name == "foreground" || name == "fgcolor" || name == "color" )
        {
            spanAttrs.m_fgCol = value;
        }
        else if ( name == "background" || name == "bgcolor" )
        {
            spanAttrs.m_bgCol = value;
        }
        else if ( name == "font_family" || name == "face" )
        {
            spanAttrs.m_fontFace = value;
        }
        else if ( name == "font_weight" || name == "weight" )
        {
            unsigned long weight;

            if ( value == "ultralight" || value == "light" || value == "normal" )
                spanAttrs.m_isBold = wxMarkupSpanAttributes::No;
            else if ( value == "bold" || value == "ultrabold" || value == "heavy" )
                spanAttrs.m_isBold = wxMarkupSpanAttributes::Yes;
            else if ( value.ToULong(&weight) )
                spanAttrs.m_isBold = weight >= 600 ? wxMarkupSpanAttributes::Yes
                                                   : wxMarkupSpanAttributes::No;
            else
                return wxString::Format("invalid font weight \"%s\"", valueOrig);
        }
        else if ( name == "font_style" || name == "style" )
        {
            if ( value == "normal" )
                spanAttrs.m_isItalic = wxMarkupSpanAttributes::No;
            else if ( value == "oblique" || value == "italic" )
                spanAttrs.m_isItalic = wxMarkupSpanAttributes::Yes;
            else
                return wxString::Format("invalid font style \"%s\"", valueOrig);
        }
        else if ( name == "size" )
        {
            unsigned long size;
            if ( value.ToULong(&size) )
            {
                spanAttrs.m_sizeKind = wxMarkupSpanAttributes::Size_PointParts;
                spanAttrs.m_fontSize = size;
            }
            else if ( value == "smaller" || value == "larger" )
            {
                spanAttrs.m_sizeKind = wxMarkupSpanAttributes::Size_Relative;
                spanAttrs.m_fontSize = value == "smaller" ? -1 : +1;
            }
            else // Must be a CSS-like size specification
            {
                int cssSize = 1;
                wxString rest;
                if ( value.StartsWith("xx-", &rest) )
                    cssSize = 3;
                else if ( value.StartsWith("x-", &rest) )
                    cssSize = 2;
                else if ( value == "medium" )
                    cssSize = 0;
                else
                    rest = value;

                if ( cssSize != 0 )
                {
                    if ( rest == "small" )
                        cssSize = -cssSize;
                    else if ( rest != "large" )
                        return wxString::Format("invalid font size \"%s\"",
                                                valueOrig);
                }

                spanAttrs.m_sizeKind = wxMarkupSpanAttributes::Size_Symbolic;
                spanAttrs.m_fontSize = cssSize;
            }
        }
    }

    return wxString();
}

bool wxMarkupParser::OutputTag(const TagAndAttrs& tagAndAttrs, bool start)
{
    if ( tagAndAttrs.name.CmpNoCase("span") == 0 )
    {
        if ( start )
            m_output.OnSpanStart(tagAndAttrs.attrs);
        else
            m_output.OnSpanEnd(tagAndAttrs.attrs);

        return true;
    }
    else // non-span tag
    {
        static const struct TagHandler
        {
            const char *name;
            void (wxMarkupParserOutput::*startFunc)();
            void (wxMarkupParserOutput::*endFunc)();
        } tagHandlers[] =
        {
            { "b", &wxMarkupParserOutput::OnBoldStart,
                   &wxMarkupParserOutput::OnBoldEnd },
            { "i", &wxMarkupParserOutput::OnItalicStart,
                   &wxMarkupParserOutput::OnItalicEnd },
            { "u", &wxMarkupParserOutput::OnUnderlinedStart,
                   &wxMarkupParserOutput::OnUnderlinedEnd },
            { "s", &wxMarkupParserOutput::OnStrikethroughStart,
                   &wxMarkupParserOutput::OnStrikethroughEnd },
            { "big", &wxMarkupParserOutput::OnBigStart,
                     &wxMarkupParserOutput::OnBigEnd },
            { "small", &wxMarkupParserOutput::OnSmallStart,
                       &wxMarkupParserOutput::OnSmallEnd },
            { "tt", &wxMarkupParserOutput::OnTeletypeStart,
                    &wxMarkupParserOutput::OnTeletypeEnd },
        };

        for ( unsigned n = 0; n < WXSIZEOF(tagHandlers); n++ )
        {
            const TagHandler& h = tagHandlers[n];

            if ( tagAndAttrs.name.CmpNoCase(h.name) == 0 )
            {
                if ( start )
                    (m_output.*(h.startFunc))();
                else
                    (m_output.*(h.endFunc))();

                return true;
            }
        }
    }

    // Unknown tag name.
    return false;
}

bool wxMarkupParser::Parse(const wxString& text)
{
    // The stack containing the names and corresponding attributes (which are
    // actually only used for <span> tags) of all of the currently opened tag
    // or none if we're not inside any tag.
    wxStack<TagAndAttrs> tags;

    // Current run of text.
    wxString current;

    const wxString::const_iterator end = text.end();
    for ( wxString::const_iterator it = text.begin(); it != end; ++it )
    {
        switch ( (*it).GetValue() )
        {
            case '<':
                {
                    // Flush the text preceding the tag, if any.
                    if ( !current.empty() )
                    {
                        m_output.OnText(current);
                        current.clear();
                    }

                    // This variable is used only in the debugging messages
                    // and doesn't need to be defined if they're not compiled
                    // at all (it actually would result in unused variable
                    // messages in this case).
#if wxUSE_LOG_DEBUG || !defined(HAVE_VARIADIC_MACROS)
                    // Remember the tag starting position for the error
                    // messages.
                    const size_t pos = it - text.begin();
#endif
                    bool start = true;
                    if ( ++it != end && *it == '/' )
                    {
                        start = false;
                        ++it;
                    }

                    const wxString tag = ExtractUntil('>', it, end);
                    if ( tag.empty() )
                    {
                        wxLogDebug("%s at %lu.",
                                   it == end ? "Unclosed tag starting"
                                             : "Empty tag",
                                   pos);
                        return false;
                    }

                    if ( start )
                    {
                        wxString attrs;
                        const wxString name = tag.BeforeFirst(' ', &attrs);

                        TagAndAttrs tagAndAttrs(name);
                        const wxString err = ParseAttrs(attrs, tagAndAttrs);
                        if ( !err.empty() )
                        {
                            wxLogDebug("Bad attributes for \"%s\" "
                                       "at %lu: %s.",
                                       name, pos, err);
                            return false;
                        }

                        tags.push(tagAndAttrs);
                    }
                    else // end tag
                    {
                        if ( tags.empty() || tags.top().name != tag )
                        {
                            wxLogDebug("Unmatched closing tag \"%s\" at %lu.",
                                       tag, pos);
                            return false;
                        }
                    }

                    if ( !OutputTag(tags.top(), start) )
                    {
                        wxLogDebug("Unknown tag at %lu.", pos);
                        return false;
                    }

                    if ( !start )
                        tags.pop();
                }
                break;

            case '>':
                wxLogDebug("'>' should be escaped as \"&gt\"; at %lu.",
                           it - text.begin());
                break;

            case '&':
                // Processing is somewhat complicated: we need to recognize at
                // least the "&lt;" entity to allow escaping left square
                // brackets in the markup and, in fact, we recognize all of the
                // standard XML entities for consistency with Pango markup
                // parsing.
                //
                // However we also allow '&' to appear unescaped, i.e. directly
                // and not as "&amp;" when it is used to introduce the mnemonic
                // for the label. In this case we simply leave it alone.
                //
                // Notice that this logic makes it impossible to have a label
                // with "lt;" inside it and using "l" as mnemonic but hopefully
                // this shouldn't be a problem in practice.
                {
                    const size_t pos = it - text.begin() + 1;

                    unsigned n;
                    for ( n = 0; n < WXSIZEOF(xmlEntities); n++ )
                    {
                        const XMLEntity& xmlEnt = xmlEntities[n];
                        if ( text.compare(pos, xmlEnt.len, xmlEnt.name) == 0
                                && text[pos + xmlEnt.len] == ';' )
                        {
                            // Escape the ampersands if needed to protect them
                            // from being interpreted as mnemonics indicators.
                            if ( xmlEnt.value == '&' )
                                current += "&&";
                            else
                                current += xmlEnt.value;

                            it += xmlEnt.len + 1; // +1 for '&' itself

                            break;
                        }
                    }

                    if ( n < WXSIZEOF(xmlEntities) )
                        break;
                    //else: fall through, '&' is not special
                }

            default:
                current += *it;
        }
    }

    if ( !tags.empty() )
    {
        wxLogDebug("Missing closing tag for \"%s\"", tags.top().name);
        return false;
    }

    if ( !current.empty() )
        m_output.OnText(current);

    return true;
}

/* static */
wxString wxMarkupParser::Quote(const wxString& text)
{
    wxString quoted;
    quoted.reserve(text.length());

    for ( wxString::const_iterator it = text.begin(); it != text.end(); ++it )
    {
        unsigned n;
        for ( n = 0; n < WXSIZEOF(xmlEntities); n++ )
        {
            const XMLEntity& xmlEnt = xmlEntities[n];
            if ( *it == xmlEnt.value )
            {
                quoted << '&' << xmlEnt.name << ';';
                break;
            }
        }

        if ( n == WXSIZEOF(xmlEntities) )
            quoted += *it;
    }

    return quoted;
}

/* static */
wxString wxMarkupParser::Strip(const wxString& text)
{
    class StripOutput : public wxMarkupParserOutput
    {
    public:
        StripOutput() { }

        const wxString& GetText() const { return m_text; }

        virtual void OnText(const wxString& text) { m_text += text; }

        virtual void OnBoldStart() { }
        virtual void OnBoldEnd() { }

        virtual void OnItalicStart() { }
        virtual void OnItalicEnd() { }

        virtual void OnUnderlinedStart() { }
        virtual void OnUnderlinedEnd() { }

        virtual void OnStrikethroughStart() { }
        virtual void OnStrikethroughEnd() { }

        virtual void OnBigStart() { }
        virtual void OnBigEnd() { }

        virtual void OnSmallStart() { }
        virtual void OnSmallEnd() { }

        virtual void OnTeletypeStart() { }
        virtual void OnTeletypeEnd() { }

        virtual void OnSpanStart(const wxMarkupSpanAttributes& WXUNUSED(a)) { }
        virtual void OnSpanEnd(const wxMarkupSpanAttributes& WXUNUSED(a)) { }

    private:
        wxString m_text;
    };

    StripOutput output;
    wxMarkupParser parser(output);
    if ( !parser.Parse(text) )
        return wxString();

    return output.GetText();
}

#endif // wxUSE_MARKUP
Commit	Line	Data
	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/markupparser.cpp
	3	// Purpose: Implementation of wxMarkupParser.
	4	// Author: Vadim Zeitlin
	5	// Created: 2011-02-16
	6	// RCS-ID: $Id$
	7	// Copyright: (c) 2011 Vadim Zeitlin <vadim@wxwidgets.org>
	8	// Licence: wxWindows licence
	9	///////////////////////////////////////////////////////////////////////////////
	10
	11	// ============================================================================
	12	// declarations
	13	// ============================================================================
	14
	15	// ----------------------------------------------------------------------------
	16	// headers
	17	// ----------------------------------------------------------------------------
	18
	19	// for compilers that support precompilation, includes "wx.h".
	20	#include "wx/wxprec.h"
	21
	22	#ifdef __BORLANDC__
	23	#pragma hdrstop
	24	#endif
	25
	26	#if wxUSE_MARKUP
	27
	28	#ifndef WX_PRECOMP
	29	#include "wx/log.h"
	30	#endif
	31
	32	#include "wx/private/markupparser.h"
	33
	34	#include "wx/stack.h"
	35
	36	namespace
	37	{
	38
	39	// ----------------------------------------------------------------------------
	40	// constants
	41	// ----------------------------------------------------------------------------
	42
	43	// Array containing the predefined XML 1.0 entities.
	44	const struct XMLEntity
	45	{
	46	const char *name;
	47	int len; // == strlen(name)
	48	char value;
	49	} xmlEntities[] =
	50	{
	51	{ "lt", 2, '<' },
	52	{ "gt", 2, '>' },
	53	{ "amp", 3, '&' },
	54	{ "apos", 4, '\''},
	55	{ "quot", 4, '"' },
	56	};
	57
	58	// ----------------------------------------------------------------------------
	59	// helper functions
	60	// ----------------------------------------------------------------------------
	61
	62	wxString
	63	ExtractUntil(char ch, wxString::const_iterator& it, wxString::const_iterator end)
	64	{
	65	wxString str;
	66	for ( ; it != end; ++it )
	67	{
	68	if ( *it == ch )
	69	return str;
	70
	71	str += *it;
	72	}
	73
	74	// Return empty string to indicate that we didn't find ch at all.
	75	return wxString();
	76	}
	77
	78	} // anonymous namespace
	79
	80	// ============================================================================
	81	// wxMarkupParser implementation
	82	// ============================================================================
	83
	84	wxString
	85	wxMarkupParser::ParseAttrs(wxString attrs, TagAndAttrs& tagAndAttrs)
	86	{
	87	if ( tagAndAttrs.name.CmpNoCase("span") != 0 && !attrs.empty() )
	88	{
	89	return wxString::Format("tag \"%s\" can't have attributes",
	90	tagAndAttrs.name);
	91	}
	92
	93	// TODO: Parse more attributes described at
	94	// http://library.gnome.org/devel/pango/stable/PangoMarkupFormat.html
	95	// and at least ignore them gracefully instead of giving errors (but
	96	// quite a few of them could be supported as well, notable font_desc).
	97
	98	wxMarkupSpanAttributes& spanAttrs = tagAndAttrs.attrs;
	99
	100	while ( !attrs.empty() )
	101	{
	102	wxString rest;
	103	const wxString attr = attrs.BeforeFirst(' ', &rest);
	104	attrs = rest;
	105
	106	// The "original" versions are used for error messages only.
	107	wxString valueOrig;
	108	const wxString nameOrig = attr.BeforeFirst('=', &valueOrig);
	109
	110	const wxString name = nameOrig.Lower();
	111	wxString value = valueOrig.Lower();
	112
	113	// All attributes values must be quoted.
	114	if ( value.length() < 2 \|\|
	115	(value[0] != value.Last()) \|\|
	116	(value[0] != '"' && value[0] != '\'') )
	117	{
	118	return wxString::Format("bad quoting for value of \"%s\"",
	119	nameOrig);
	120	}
	121
	122	value.assign(value, 1, value.length() - 2);
	123
	124	if ( name == "foreground" \|\| name == "fgcolor" \|\| name == "color" )
	125	{
	126	spanAttrs.m_fgCol = value;
	127	}
	128	else if ( name == "background" \|\| name == "bgcolor" )
	129	{
	130	spanAttrs.m_bgCol = value;
	131	}
	132	else if ( name == "font_family" \|\| name == "face" )
	133	{
	134	spanAttrs.m_fontFace = value;
	135	}
	136	else if ( name == "font_weight" \|\| name == "weight" )
	137	{
	138	unsigned long weight;
	139
	140	if ( value == "ultralight" \|\| value == "light" \|\| value == "normal" )
	141	spanAttrs.m_isBold = wxMarkupSpanAttributes::No;
	142	else if ( value == "bold" \|\| value == "ultrabold" \|\| value == "heavy" )
	143	spanAttrs.m_isBold = wxMarkupSpanAttributes::Yes;
	144	else if ( value.ToULong(&weight) )
	145	spanAttrs.m_isBold = weight >= 600 ? wxMarkupSpanAttributes::Yes
	146	: wxMarkupSpanAttributes::No;
	147	else
	148	return wxString::Format("invalid font weight \"%s\"", valueOrig);
	149	}
	150	else if ( name == "font_style" \|\| name == "style" )
	151	{
	152	if ( value == "normal" )
	153	spanAttrs.m_isItalic = wxMarkupSpanAttributes::No;
	154	else if ( value == "oblique" \|\| value == "italic" )
	155	spanAttrs.m_isItalic = wxMarkupSpanAttributes::Yes;
	156	else
	157	return wxString::Format("invalid font style \"%s\"", valueOrig);
	158	}
	159	else if ( name == "size" )
	160	{
	161	unsigned long size;
	162	if ( value.ToULong(&size) )
	163	{
	164	spanAttrs.m_sizeKind = wxMarkupSpanAttributes::Size_PointParts;
	165	spanAttrs.m_fontSize = size;
	166	}
	167	else if ( value == "smaller" \|\| value == "larger" )
	168	{
	169	spanAttrs.m_sizeKind = wxMarkupSpanAttributes::Size_Relative;
	170	spanAttrs.m_fontSize = value == "smaller" ? -1 : +1;
	171	}
	172	else // Must be a CSS-like size specification
	173	{
	174	int cssSize = 1;
	175	wxString rest;
	176	if ( value.StartsWith("xx-", &rest) )
	177	cssSize = 3;
	178	else if ( value.StartsWith("x-", &rest) )
	179	cssSize = 2;
	180	else if ( value == "medium" )
	181	cssSize = 0;
	182	else
	183	rest = value;
	184
	185	if ( cssSize != 0 )
	186	{
	187	if ( rest == "small" )
	188	cssSize = -cssSize;
	189	else if ( rest != "large" )
	190	return wxString::Format("invalid font size \"%s\"",
	191	valueOrig);
	192	}
	193
	194	spanAttrs.m_sizeKind = wxMarkupSpanAttributes::Size_Symbolic;
	195	spanAttrs.m_fontSize = cssSize;
	196	}
	197	}
	198	}
	199
	200	return wxString();
	201	}
	202
	203	bool wxMarkupParser::OutputTag(const TagAndAttrs& tagAndAttrs, bool start)
	204	{
	205	if ( tagAndAttrs.name.CmpNoCase("span") == 0 )
	206	{
	207	if ( start )
	208	m_output.OnSpanStart(tagAndAttrs.attrs);
	209	else
	210	m_output.OnSpanEnd(tagAndAttrs.attrs);
	211
	212	return true;
	213	}
	214	else // non-span tag
	215	{
	216	static const struct TagHandler
	217	{
	218	const char *name;
	219	void (wxMarkupParserOutput::*startFunc)();
	220	void (wxMarkupParserOutput::*endFunc)();
	221	} tagHandlers[] =
	222	{
	223	{ "b", &wxMarkupParserOutput::OnBoldStart,
	224	&wxMarkupParserOutput::OnBoldEnd },
	225	{ "i", &wxMarkupParserOutput::OnItalicStart,
	226	&wxMarkupParserOutput::OnItalicEnd },
	227	{ "u", &wxMarkupParserOutput::OnUnderlinedStart,
	228	&wxMarkupParserOutput::OnUnderlinedEnd },
	229	{ "s", &wxMarkupParserOutput::OnStrikethroughStart,
	230	&wxMarkupParserOutput::OnStrikethroughEnd },
	231	{ "big", &wxMarkupParserOutput::OnBigStart,
	232	&wxMarkupParserOutput::OnBigEnd },
	233	{ "small", &wxMarkupParserOutput::OnSmallStart,
	234	&wxMarkupParserOutput::OnSmallEnd },
	235	{ "tt", &wxMarkupParserOutput::OnTeletypeStart,
	236	&wxMarkupParserOutput::OnTeletypeEnd },
	237	};
	238
	239	for ( unsigned n = 0; n < WXSIZEOF(tagHandlers); n++ )
	240	{
	241	const TagHandler& h = tagHandlers[n];
	242
	243	if ( tagAndAttrs.name.CmpNoCase(h.name) == 0 )
	244	{
	245	if ( start )
	246	(m_output.*(h.startFunc))();
	247	else
	248	(m_output.*(h.endFunc))();
	249
	250	return true;
	251	}
	252	}
	253	}
	254
	255	// Unknown tag name.
	256	return false;
	257	}
	258
	259	bool wxMarkupParser::Parse(const wxString& text)
	260	{
	261	// The stack containing the names and corresponding attributes (which are
	262	// actually only used for <span> tags) of all of the currently opened tag
	263	// or none if we're not inside any tag.
	264	wxStack<TagAndAttrs> tags;
	265
	266	// Current run of text.
	267	wxString current;
	268
	269	const wxString::const_iterator end = text.end();
	270	for ( wxString::const_iterator it = text.begin(); it != end; ++it )
	271	{
	272	switch ( (*it).GetValue() )
	273	{
	274	case '<':
	275	{
	276	// Flush the text preceding the tag, if any.
	277	if ( !current.empty() )
	278	{
	279	m_output.OnText(current);
	280	current.clear();
	281	}
	282
	283	// This variable is used only in the debugging messages
	284	// and doesn't need to be defined if they're not compiled
	285	// at all (it actually would result in unused variable
	286	// messages in this case).
	287	#if wxUSE_LOG_DEBUG \|\| !defined(HAVE_VARIADIC_MACROS)
	288	// Remember the tag starting position for the error
	289	// messages.
	290	const size_t pos = it - text.begin();
	291	#endif
	292	bool start = true;
	293	if ( ++it != end && *it == '/' )
	294	{
	295	start = false;
	296	++it;
	297	}
	298
	299	const wxString tag = ExtractUntil('>', it, end);
	300	if ( tag.empty() )
	301	{
	302	wxLogDebug("%s at %lu.",
	303	it == end ? "Unclosed tag starting"
	304	: "Empty tag",
	305	pos);
	306	return false;
	307	}
	308
	309	if ( start )
	310	{
	311	wxString attrs;
	312	const wxString name = tag.BeforeFirst(' ', &attrs);
	313
	314	TagAndAttrs tagAndAttrs(name);
	315	const wxString err = ParseAttrs(attrs, tagAndAttrs);
	316	if ( !err.empty() )
	317	{
	318	wxLogDebug("Bad attributes for \"%s\" "
	319	"at %lu: %s.",
	320	name, pos, err);
	321	return false;
	322	}
	323
	324	tags.push(tagAndAttrs);
	325	}
	326	else // end tag
	327	{
	328	if ( tags.empty() \|\| tags.top().name != tag )
	329	{
	330	wxLogDebug("Unmatched closing tag \"%s\" at %lu.",
	331	tag, pos);
	332	return false;
	333	}
	334	}
	335
	336	if ( !OutputTag(tags.top(), start) )
	337	{
	338	wxLogDebug("Unknown tag at %lu.", pos);
	339	return false;
	340	}
	341
	342	if ( !start )
	343	tags.pop();
	344	}
	345	break;
	346
	347	case '>':
	348	wxLogDebug("'>' should be escaped as \"&gt\"; at %lu.",
	349	it - text.begin());
	350	break;
	351
	352	case '&':
	353	// Processing is somewhat complicated: we need to recognize at
	354	// least the "<" entity to allow escaping left square
	355	// brackets in the markup and, in fact, we recognize all of the
	356	// standard XML entities for consistency with Pango markup
	357	// parsing.
	358	//
	359	// However we also allow '&' to appear unescaped, i.e. directly
	360	// and not as "&" when it is used to introduce the mnemonic
	361	// for the label. In this case we simply leave it alone.
	362	//
	363	// Notice that this logic makes it impossible to have a label
	364	// with "lt;" inside it and using "l" as mnemonic but hopefully
	365	// this shouldn't be a problem in practice.
	366	{
	367	const size_t pos = it - text.begin() + 1;
	368
	369	unsigned n;
	370	for ( n = 0; n < WXSIZEOF(xmlEntities); n++ )
	371	{
	372	const XMLEntity& xmlEnt = xmlEntities[n];
	373	if ( text.compare(pos, xmlEnt.len, xmlEnt.name) == 0
	374	&& text[pos + xmlEnt.len] == ';' )
	375	{
	376	// Escape the ampersands if needed to protect them
	377	// from being interpreted as mnemonics indicators.
	378	if ( xmlEnt.value == '&' )
	379	current += "&&";
	380	else
	381	current += xmlEnt.value;
	382
	383	it += xmlEnt.len + 1; // +1 for '&' itself
	384
	385	break;
	386	}
	387	}
	388
	389	if ( n < WXSIZEOF(xmlEntities) )
	390	break;
	391	//else: fall through, '&' is not special
	392	}
	393
	394	default:
	395	current += *it;
	396	}
	397	}
	398
	399	if ( !tags.empty() )
	400	{
	401	wxLogDebug("Missing closing tag for \"%s\"", tags.top().name);
	402	return false;
	403	}
	404
	405	if ( !current.empty() )
	406	m_output.OnText(current);
	407
	408	return true;
	409	}
	410
	411	/* static */
	412	wxString wxMarkupParser::Quote(const wxString& text)
	413	{
	414	wxString quoted;
	415	quoted.reserve(text.length());
	416
	417	for ( wxString::const_iterator it = text.begin(); it != text.end(); ++it )
	418	{
	419	unsigned n;
	420	for ( n = 0; n < WXSIZEOF(xmlEntities); n++ )
	421	{
	422	const XMLEntity& xmlEnt = xmlEntities[n];
	423	if ( *it == xmlEnt.value )
	424	{
	425	quoted << '&' << xmlEnt.name << ';';
	426	break;
	427	}
	428	}
	429
	430	if ( n == WXSIZEOF(xmlEntities) )
	431	quoted += *it;
	432	}
	433
	434	return quoted;
	435	}
	436
	437	/* static */
	438	wxString wxMarkupParser::Strip(const wxString& text)
	439	{
	440	class StripOutput : public wxMarkupParserOutput
	441	{
	442	public:
	443	StripOutput() { }
	444
	445	const wxString& GetText() const { return m_text; }
	446
	447	virtual void OnText(const wxString& text) { m_text += text; }
	448
	449	virtual void OnBoldStart() { }
	450	virtual void OnBoldEnd() { }
	451
	452	virtual void OnItalicStart() { }
	453	virtual void OnItalicEnd() { }
	454
	455	virtual void OnUnderlinedStart() { }
	456	virtual void OnUnderlinedEnd() { }
	457
	458	virtual void OnStrikethroughStart() { }
	459	virtual void OnStrikethroughEnd() { }
	460
	461	virtual void OnBigStart() { }
	462	virtual void OnBigEnd() { }
	463
	464	virtual void OnSmallStart() { }
	465	virtual void OnSmallEnd() { }
	466
	467	virtual void OnTeletypeStart() { }
	468	virtual void OnTeletypeEnd() { }
	469
	470	virtual void OnSpanStart(const wxMarkupSpanAttributes& WXUNUSED(a)) { }
	471	virtual void OnSpanEnd(const wxMarkupSpanAttributes& WXUNUSED(a)) { }
	472
	473	private:
	474	wxString m_text;
	475	};
	476
	477	StripOutput output;
	478	wxMarkupParser parser(output);
	479	if ( !parser.Parse(text) )
	480	return wxString();
	481
	482	return output.GetText();
	483	}
	484
	485	#endif // wxUSE_MARKUP