Contrib.Html.HtmlParse Class Reference

Yet another small HTML parser. More...

Inheritance diagram for Contrib.Html.HtmlParse:

List of all members.

Public Member Functions
	HtmlParse (HtmlLex src)
void	Parse ()
	Starts the parser, reads from the source, and starts events.
Protected Member Functions
virtual bool	OnAttribute (string attributeName, string value, IDictionary attributes)
	This will be called on defining an attribute of an element.
virtual void	OnClosingElement (string currentElement, string tag)
	This will be called whenever the stack decreases.
virtual void	OnDefaultEvent (string token)
	This will be called whenever this is not a part of more specific events.
virtual void	OnEndElementTag (string currentElement, string tagString, IDictionary attributes)
	Overload this to react on the start of an element.
virtual void	OnRemark (string remark)
	This is called whenever the parser has read a remark.
virtual void	OnStartElementTag (string currentElement)
	This will be called before any other domain on starting a new element tag.
Properties
int	Depth [get]
	This is the depth of the internal stack representing the nested structure of tags.
StackEntry	this [int depth] [get]
	This will access the internal stack element according to the given depth.
Classes
class	StackEntry
	This class represents an entry in the element stack. More...

---

Detailed Description

Yet another small HTML parser.

This class uses HtmlLex to scan for tokens in an HTML text stream. It calls some virtual methods like OnEnterElement() on certain events in parsing the text. Additionally, specializations can store a stack of state information that grows with parsing into nested tags and decreases with leaving nested tags either parsing the corresponding end tag or an end tag of a tag deeper in the stack.

This procedure is rather optimized for robustness and not for compatibility of standards. In fact, nearly anything defined by W3C is ignored here. The only tested purpose is the adoption of doxygen output to the wx.NET help viewer.

Definition at line 28 of file HtmlParse.cs.

---

Constructor & Destructor Documentation

Contrib.Html.HtmlParse.HtmlParse

(

HtmlLex

src

)

Definition at line 53 of file HtmlParse.cs.

        {
            this._src = src;
            this._stack = new ArrayList();
        }

---

Member Function Documentation

virtual bool Contrib.Html.HtmlParse.OnAttribute	(	string	attributeName,
		string	value,
		IDictionary	attributes
	)			[protected, virtual]

This will be called on defining an attribute of an element.

this[0] will always be the current element. OnElement() has not yet been called. The value will be stripped of quotes if necessary.

Parameters:

	attributeName	is the name of the attribute
	value	is the value (without quotes) or empty attributeName is an attribute without values.
	attributes	maps the names of the parsed attributes to their values. You may extend this to inline new attributes that have not been parsed but that shall be processed by OnEndElementTag().

Returns:

with true this method tells the parser to add the received attribute to the list of attributes to ba passed to OnEndElementTag().

Reimplemented in wx.ZipRC.DoxygenHtbConverter.

Definition at line 132 of file HtmlParse.cs.

        {
            return true;
        }

virtual void Contrib.Html.HtmlParse.OnClosingElement	(	string	currentElement,
		string	tag
	)			[protected, virtual]

This will be called whenever the stack decreases.

this[0] is always the currentElement.

Reimplemented in wx.ZipRC.DoxygenHtbConverter.

Definition at line 140 of file HtmlParse.cs.

        {
        }

virtual void Contrib.Html.HtmlParse.OnDefaultEvent

(

string

token

)

[protected, virtual]

This will be called whenever this is not a part of more specific events.

Reimplemented in wx.ZipRC.DoxygenHtbConverter.

Definition at line 146 of file HtmlParse.cs.

        {
        }

virtual void Contrib.Html.HtmlParse.OnEndElementTag	(	string	currentElement,
		string	tagString,
		IDictionary	attributes
	)			[protected, virtual]

Overload this to react on the start of an element.

Parameters:

	currentElement	is the element's name in lower case letters (e.g. "ul").
	currentElementString	is the full string describing the current element like for instance ' . this[0] will always be this element.
	currentElement	is the current element's name like "ul"
	tagString	is the full tag string including attributes introduced by OnAttribute().
	attributes	maps the names of the parsed attributes to their values.

Reimplemented in wx.ZipRC.DoxygenHtbConverter.

Definition at line 117 of file HtmlParse.cs.

        {
        }

virtual void Contrib.Html.HtmlParse.OnRemark

(

string

remark

)

[protected, virtual]

This is called whenever the parser has read a remark.

Parameters:

remark

is the remark text without surrounding tags.

Definition at line 153 of file HtmlParse.cs.

        {
        }

virtual void Contrib.Html.HtmlParse.OnStartElementTag

(

string

currentElement

)

[protected, virtual]

This will be called before any other domain on starting a new element tag.

Reimplemented in wx.ZipRC.DoxygenHtbConverter.

Definition at line 105 of file HtmlParse.cs.

        {
        }

void Contrib.Html.HtmlParse.Parse

(

)

Starts the parser, reads from the source, and starts events.

Definition at line 159 of file HtmlParse.cs.

References Contrib.Html.HtmlParse.StackEntry.Element.

Referenced by wx.ZipRC.ZipResourceCompiler.Main().

        {
            IDictionary attributes=null;
            string attributeName=null;
            bool readingAttributeValue=false;
            StringBuilder fullElementString = null;
            for (string token = this._src.NextToken();
                token != null;
                token = this._src.NextToken())
            {
                if (token.StartsWith("<!--"))
                {
                    // processing remarks
                    token = token.Substring(4, token.Length - 7);
                    token = token.Trim();
                    this.OnRemark(token);
                    token = this._src.NextToken();
                    if (token == null) break;
                }
                if (token.TrimStart().StartsWith("</"))
                {
                    token = token.Trim();
                    // end tag. decrease stack.
                    string element = token.Substring(2).ToLower();
                    token+=this._src.NextToken().Trim();
                    // ignore end tags without start. doxygen seems to add some 
                    // end tags without start. So, first search for a start.
                    bool foundTag = false;
                    foreach (StackEntry entry in this._stack)
                    {
                        if (entry.Element == element)
                        {
                            foundTag = true;
                            break;
                        }
                    }
                    if (foundTag)
                    {
                        // If we found a possible start, remove stack elements until
                        // start reached.
                        while (this._stack.Count > 0)
                        {
                            StackEntry current = (StackEntry)this._stack[0];
                            if (current.Element == element)
                            {
                                this.OnClosingElement(current.Element, token);
                                this._stack.RemoveAt(0);
                                break;
                            }
                            else
                                this._stack.RemoveAt(0);
                        }
                    }
                }
                else if (token.TrimStart().StartsWith("<"))
                {
                    // start tag. stack grows.
                    token = token.Trim();
                    string element = token.Substring(1).ToLower();
                    if (this.Depth > 0 && this[0].Element == element)
                    {
                        // the new element is equal to the old element.
                        // act as if the old element has been closed explicitely.
                        this.OnClosingElement(this[0].Element, string.Format("</{0}>", this[0].Element));
                        this._stack.RemoveAt(0);
                    }
                    this._stack.Insert(0, new StackEntry(element));
                    if (this.Depth > 1)
                        this[0].State = (ICloneable)this[1].State.Clone(); // State inheritance
                    this.OnStartElementTag(element);
                    attributes = new Hashtable(); // Start reading attributes
                    fullElementString = new StringBuilder();
                    fullElementString.AppendFormat("{0} ", token);
                }
                else if (token.Trim() == ">")
                {
                    token = token.Trim();
                    // closing the element definition. Only interesting if reading attributes.
                    if (attributes != null && fullElementString != null)
                    {
                        this.OnEndElementTag(this[0].Element, fullElementString.ToString()+token, attributes);
                    }
                    fullElementString = null;
                    attributes = null;
                    attributeName = null;
                }
                else if (attributes!=null && attributeName != null && readingAttributeValue)
                {
                    token = token.Trim();
                    // the token is an attribute value.
                    string attributeValue = token;
                    if (attributeValue.StartsWith("\"") && attributeValue.EndsWith("\"") && attributeValue.Length > 1)
                        attributeValue = attributeValue.Substring(1, attributeValue.Length - 2);
                    IDictionary newAttributes = new Hashtable();
                    bool addThis=this.OnAttribute(attributeName, attributeValue, newAttributes);
                    foreach (DictionaryEntry entry in newAttributes)
                    {
                        attributes.Add(entry.Key, entry.Value);
                        if (entry.Value==null || entry.Value.ToString().Length > 0)
                            fullElementString.AppendFormat("{0}=\"{1}\" ", entry.Key, entry.Value);
                        else
                            fullElementString.AppendFormat("{0} ", entry.Key);
                    }
                    if (addThis)
                    {
                        fullElementString.AppendFormat("{0}=\"{1}\" ", attributeName, attributeValue);
                    }
                    readingAttributeValue = false;
                    attributeName = null;
                }
                else if (attributes != null && attributeName == null)
                {
                    // the token is an attribute name
                    token = token.Trim();
                    attributeName = token;
                }
                else if (attributes != null)
                {
                    // this branch expects an equal sign.
                    token = token.Trim();
                    if (token == "=")
                    {
                        readingAttributeValue = true;
                    }
                    else
                    {
                        IDictionary newAttributes=new Hashtable();
                        bool addThis=this.OnAttribute(attributeName, "", newAttributes);
                        foreach (DictionaryEntry entry in newAttributes)
                        {
                            attributes.Add(entry.Key, entry.Value);
                            if (entry.Value == null || entry.Value.ToString().Length > 0)
                                fullElementString.AppendFormat("{0}=\"{1}\" ", entry.Key, entry.Value);
                            else
                                fullElementString.AppendFormat("{0} ", entry.Key);
                        }
                        if (addThis)
                        {
                            fullElementString.AppendFormat("{0} ", attributeName);
                        }
                        readingAttributeValue = false;
                        attributeName = null;
                    }
                }
                else
                {
                    this.OnDefaultEvent(token);
                }
            }
        }

---

Property Documentation

int Contrib.Html.HtmlParse.Depth [get, protected]

This is the depth of the internal stack representing the nested structure of tags.

Definition at line 61 of file HtmlParse.cs.

StackEntry Contrib.Html.HtmlParse.this[int depth]

(

)

[get, protected]

This will access the internal stack element according to the given depth.

this[0] returns the entry on the current element. this[1] will return the entry on the element containing the current element or null of there is not containing element. All elements without explicit end tag are considered to contain everything that their predecessor contains. So,

         <p>
         A paragraph.
         <p>
         Another paragraph.
         

will be parsed like

         <p>
         A paragraph.
         <p>
         Another paragraph.
         </p>
         </p>
         

rather than

         <p>
         A paragraph.
         </p>
         <p>
         Another paragraph.
         </p>
         

Definition at line 94 of file HtmlParse.cs.

---