LiteralTextParser.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / MIT / System / Web / UI / MobileControls / LiteralTextParser.cs / 1305376 / LiteralTextParser.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

using System; 
using System.Collections; 
using System.Collections.Specialized;
using System.Globalization; 
using System.Text;
using System.Web;

namespace System.Web.UI.MobileControls 
{
    /* 
     * LiteralTextParser class. 
     *
     * The LiteralTextParser class parses a string of literal text, 
     * containing certain recognizable tags, and creates a set of controls
     * from them. Any unrecognized tags are ignored.
     *
     * This is an abstract base class. RuntimeLiteralTextParser and 
     * CompileTimeLiteralTextParser inherit from this class.
     * 
     * Copyright (c) 2000 Microsoft Corporation 
     */
 
    [Obsolete("The System.Web.Mobile.dll assembly has been deprecated and should no longer be used. For information about how to develop ASP.NET mobile applications, see http://go.microsoft.com/fwlink/?LinkId=157231.")]
    internal abstract class LiteralTextParser
    {
        // The parsing methods (Parse, ParseTag, ParseTagAttributes, ParseText) 
        // build up LiteralElement objects, which can either be text or tags.
        // ProcessElementInternal is then called. It combines some other data 
        // and calls ProcessElement, a method which is overridable by inherited 
        // classes.
 
        // Literal Element type - includes recognized tags.

        protected enum LiteralElementType
        { 
            Unrecognized,
            Text, 
            Bold, 
            Italic,
            Break, 
            Paragraph,
            Anchor,
        }
 
        // Available formatting options for literal elements. This enum can
        // be combined with the | operator. 
 
        protected enum LiteralFormat
        { 
            None = 0,
            Bold = 1,
            Italic = 2,
        } 

        // Literal Element. 
 
        protected class LiteralElement
        { 
            public LiteralElementType Type;
            public IDictionary Attributes;
            public String Text;
            public LiteralFormat Format = LiteralFormat.None; 
            public bool BreakAfter = false;
            public bool ForceBreakTag = false; 
 
            public LiteralElement(String text)
            { 
                Type = LiteralElementType.Text;
                Attributes = null;
                Text = text;
            } 

            public LiteralElement(LiteralElementType type, IDictionary attributes) 
            { 
                Type = type;
                Attributes = attributes; 
                Text = String.Empty;
            }

            public bool IsText 
            {
                get 
                { 
                    return Type == LiteralElementType.Text;
                } 
            }

            public bool IsEmptyText
            { 
                get
                { 
                    return IsText && !LiteralTextParser.IsValidText(Text); 
                }
            } 

            public String GetAttribute(String attributeName)
            {
                Object o = (Attributes != null) ? Attributes[attributeName] : null; 
                return (o != null) ? (String)o : String.Empty;
            } 
        } 

        // Methods overriden by inherited classes. 

        protected abstract void ProcessElement(LiteralElement element);
        protected abstract void ProcessTagInnerText(String text);
 
        private bool           _isBreakingReset   = true;
        private LiteralElement _lastQueuedElement = null; 
        private LiteralElement _currentTag        = null; 
        private bool           _beginNewParagraph = true;
        private FormatStack    _formatStack       = new FormatStack(); 
        private bool           _elementsProcessed = false;

        // Static constructor that builds a lookup table of recognized tags.
 
        private static IDictionary _recognizedTags = new Hashtable();
        static LiteralTextParser() 
        { 
            // PERF: Add both lowercase and uppercase.
 
            _recognizedTags.Add("b", LiteralElementType.Bold);
            _recognizedTags.Add("B", LiteralElementType.Bold);

            _recognizedTags.Add("i", LiteralElementType.Italic); 
            _recognizedTags.Add("I", LiteralElementType.Italic);
 
            _recognizedTags.Add("br", LiteralElementType.Break); 
            _recognizedTags.Add("BR", LiteralElementType.Break);
 
            _recognizedTags.Add("p", LiteralElementType.Paragraph);
            _recognizedTags.Add("P", LiteralElementType.Paragraph);

            _recognizedTags.Add("a", LiteralElementType.Anchor); 
            _recognizedTags.Add("A", LiteralElementType.Anchor);
        } 
 
        // Convert a tag name to a type.
 
        private static LiteralElementType TagNameToType(String tagName)
        {
            Object o = _recognizedTags[tagName];
            if (o == null) 
            {
                o = _recognizedTags[tagName.ToLower(CultureInfo.InvariantCulture)]; 
            } 
            return (o != null) ? (LiteralElementType)o : LiteralElementType.Unrecognized;
        } 

        // Returns true if any valid controls could be generated from the given text.

        internal /*public*/ static bool IsValidText(String validText) 
        {
            // 
 
            if (validText.Length == 0)
            { 
                return false;
            }

            foreach (char c in validText) 
            {
                if (!Char.IsWhiteSpace(c) && 
                        c != '\t' && 
                        c != '\r' &&
                        c != '\n') 
                {
                    return true;
                }
            } 

            return false; 
        } 

        // Main parse routine. Called with a block of text to parse. 

        internal /*public*/ void Parse(String literalText)
        {
            int length = literalText.Length; 
            int currentPosition = 0;
 
            while (currentPosition < length) 
            {
                // Find start of next tag. 

                int nextTag = literalText.IndexOf('<', currentPosition);
                if (nextTag == -1)
                { 
                    ParseText(literalText.Substring(currentPosition));
                    break; 
                } 

                if (nextTag > currentPosition) 
                {
                    ParseText(literalText.Substring(currentPosition, nextTag - currentPosition));
                }
 
                // Find end of tag.
 
                char quoteChar = '\0'; 
                int endOfTag;
                for (endOfTag = nextTag + 1; endOfTag < length; endOfTag++) 
                {
                    char c = literalText[endOfTag];
                    if (quoteChar == '\0')
                    { 
                        if (c == '\'' || c == '\"')
                        { 
                            quoteChar = c; 
                        }
                        else if (c == '>') 
                        {
                            break;
                        }
                    } 
                    else
                    { 
                        if (c == quoteChar) 
                        {
                            quoteChar = '\0'; 
                        }
                    }
                }
 
                if (endOfTag == length)
                { 
                    // 
                    break;
                } 

                ParseTag(literalText, nextTag + 1, endOfTag);
                currentPosition = endOfTag + 1;
            } 

            Flush(); 
        } 

        internal /*public*/ void ResetBreaking() 
        {
            _isBreakingReset = true;
            ElementsProcessed = false;
        } 

        internal /*public*/ void ResetNewParagraph() 
        { 
            _beginNewParagraph = false;
        } 

        internal /*public*/ void UnResetBreaking()
        {
            _isBreakingReset = false; 
        }
 
        protected bool ElementsProcessed 
        {
            get 
            {
                return _elementsProcessed;
            }
 
            set
            { 
                _elementsProcessed = value; 
            }
        } 

        protected void OnAfterDataBoundLiteral()
        {
            ElementsProcessed = true; 
            UnResetBreaking();
        } 
 
        // Parse a single tag.
 
        private void ParseTag(String literalText, int tagStart, int tagFinish)
        {
            bool isClosingTag = (literalText[tagStart] == '/');
            if (isClosingTag) 
            {
                tagStart++; 
            } 

            // Empty tag? 

            if (tagStart == tagFinish)
            {
                return; 
            }
 
            // Look for end of tag name. 

            int tagNameFinish = tagStart; 
            while (tagNameFinish < tagFinish &&
                   !Char.IsWhiteSpace(literalText[tagNameFinish]) && literalText[tagNameFinish] != '/')
            {
                tagNameFinish++; 
            }
 
            // Extract tag name, and compare to recognized tags. 

            String tagName = literalText.Substring(tagStart, tagNameFinish - tagStart); 
            LiteralElementType tagType = TagNameToType(tagName);
            if (tagType == LiteralElementType.Unrecognized)
            {
                return; 
            }
 
            // Are we already in a complex tag? 

            if (_currentTag != null) 
            {
                // Ignore any inner tags, except the closing tag.

                if (_currentTag.Type == tagType && isClosingTag) 
                {
                    ProcessElementInternal(_currentTag); 
                    _currentTag = null; 
                }
                else 
                {
                    //
                }
                return; 
            }
 
            switch (tagType) 
            {
                case LiteralElementType.Paragraph: 

                    // Do not create two breaks for 
 pairs.

                    if (!_isBreakingReset) 
                    {
                        _isBreakingReset = true; 
                        goto case LiteralElementType.Break; 
                    }
 
                    break;

                case LiteralElementType.Break:
 
                    // If a break is already pending, insert an empty one.
 
                    if (_beginNewParagraph) 
                    {
                        ParseText(String.Empty); 
                    }
                    if (_lastQueuedElement != null &&
                        _lastQueuedElement.Text.Length == 0)
                    { 
                        _lastQueuedElement.ForceBreakTag = true;
                    } 
                    _beginNewParagraph = true; 
                    break;
 
                case LiteralElementType.Bold:

                    if (isClosingTag)
                    { 
                        _formatStack.Pop(FormatStack.Bold);
                    } 
                    else 
                    {
                        _formatStack.Push(FormatStack.Bold); 
                    }
                    break;

                case LiteralElementType.Italic: 

                    if (isClosingTag) 
                    { 
                        _formatStack.Pop(FormatStack.Italic);
                    } 
                    else
                    {
                        _formatStack.Push(FormatStack.Italic);
                    } 
                    break;
 
                default: 
                {
                    if (!isClosingTag) 
                    {
                        IDictionary attribs = ParseTagAttributes(literalText, tagNameFinish, tagFinish, tagName);
                        _currentTag = new LiteralElement(tagType, attribs);
                    } 
                    break;
                } 
            } 

            if (_isBreakingReset && tagType != LiteralElementType.Paragraph) 
            {
                _isBreakingReset = false;
            }
        } 

        protected bool IsInTag 
        { 
            get
            { 
                return _currentTag != null;
            }
        }
 
        protected LiteralFormat CurrentFormat
        { 
            get 
            {
                return _formatStack.CurrentFormat; 
            }
        }

        // Parse attributes of a tag. 

        private enum AttributeParseState 
        { 
            StartingAttributeName,
            ReadingAttributeName, 
            ReadingEqualSign,
            StartingAttributeValue,
            ReadingAttributeValue,
            Error, 
        }
 
        private IDictionary ParseTagAttributes(String literalText, int attrStart, int attrFinish, String tagName) 
        {
            if (attrFinish > attrStart && literalText[attrFinish - 1] == '/') 
            {
                attrFinish--;
            }
 
            IDictionary dictionary = null;
            int attrPos = attrStart; 
            bool skipWhiteSpaces = true; 
            int attrNameStart = 0;
            int attrNameFinish = 0; 
            int attrValueStart = 0;
            char quoteChar = '\0';
            AttributeParseState state = AttributeParseState.StartingAttributeName;
 
            while (attrPos <= attrFinish && state != AttributeParseState.Error)
            { 
                char c = attrPos == attrFinish ? '\0' : literalText[attrPos]; 

                if (skipWhiteSpaces) 
                {
                    if (Char.IsWhiteSpace(c))
                    {
                        attrPos++; 
                        continue;
                    } 
                    else 
                    {
                        skipWhiteSpaces = false; 
                    }
                }

                switch (state) 
                {
                    case AttributeParseState.StartingAttributeName: 
                        if (c == '\0') 
                        {
                            attrPos = attrFinish + 1; 
                        }
                        else
                        {
                            attrNameStart = attrPos; 
                            state = AttributeParseState.ReadingAttributeName;
                        } 
                        break; 

                    case AttributeParseState.ReadingAttributeName: 
                        if (c == '=' || Char.IsWhiteSpace(c))
                        {
                            attrNameFinish = attrPos;
                            skipWhiteSpaces = true; 
                            state = AttributeParseState.ReadingEqualSign;
                        } 
                        else if (c == '\0') 
                        {
                            state = AttributeParseState.Error; 
                        }
                        else
                        {
                            attrPos++; 
                        }
                        break; 
 
                    case AttributeParseState.ReadingEqualSign:
                        if (c == '=') 
                        {
                            skipWhiteSpaces = true;
                            state = AttributeParseState.StartingAttributeValue;
                            attrPos++; 
                        }
                        else 
                        { 
                            state = AttributeParseState.Error;
                        } 
                        break;

                    case AttributeParseState.StartingAttributeValue:
                        attrValueStart = attrPos; 
                        if (c == '\0')
                        { 
                            state = AttributeParseState.Error; 
                            break;
                        } 
                        else if (c == '\"' || c == '\'')
                        {
                            quoteChar = c;
                            attrValueStart++; 
                            attrPos++;
                        } 
                        else 
                        {
                            quoteChar = '\0'; 
                        }
                        state = AttributeParseState.ReadingAttributeValue;
                        break;
 
                    case AttributeParseState.ReadingAttributeValue:
                        if (c == quoteChar || 
                            ((Char.IsWhiteSpace(c) || c == '\0') && quoteChar == '\0')) 
                        {
                            if (attrNameFinish == attrNameStart) 
                            {
                                state = AttributeParseState.Error;
                                break;
                            } 

                            if (dictionary == null) 
                            { 
                                dictionary = new HybridDictionary(true);
                            } 

                            dictionary.Add(
                                literalText.Substring(attrNameStart, attrNameFinish - attrNameStart),
                                literalText.Substring(attrValueStart, attrPos - attrValueStart)); 

                            skipWhiteSpaces = true; 
                            state = AttributeParseState.StartingAttributeName; 
                            if (c == quoteChar)
                            { 
                                attrPos++;
                            }
                        }
                        else 
                        {
                            attrPos++; 
                        } 
                        break;
                } 
            }

            if (state == AttributeParseState.Error)
            { 
                throw new Exception(SR.GetString(SR.LiteralTextParser_InvalidTagFormat));
            } 
 
            return dictionary;
        } 

        // Parse a plain text literal.

        private void ParseText(String text) 
        {
            if (_currentTag != null) 
            { 
                // Add to inner text of tag.
                _currentTag.Text += text; 
            }
            else
            {
                if (_isBreakingReset && IsValidText(text)) 
                {
                    _isBreakingReset = false; 
                } 
                ProcessElementInternal(new LiteralElement(text));
            } 
        }

        private void ProcessElementInternal(LiteralElement element)
        { 
            // This method needs to fill in an element with formatting and
            // breaking information, and calls ProcessElement. However, 
            // each element needs to know whether there will be a break 
            // AFTER the element, so elements are processed lazily, keeping
            // the last one in a single-element queue. 

            LiteralFormat currentFormat = _formatStack.CurrentFormat;

            if (_lastQueuedElement != null) 
            {
                // If both the last and current element are text elements, and 
                // the formatting hasn't changed, then just combine the two into 
                // a single element.
 
                if (_lastQueuedElement.IsText && element.IsText &&
                        (_lastQueuedElement.Format == currentFormat) &&
                        !_beginNewParagraph)
                { 
                    _lastQueuedElement.Text += element.Text;
                    return; 
                } 
                else if (_lastQueuedElement.IsEmptyText &&
                         !_beginNewParagraph && 
                         IgnoreWhiteSpaceElement(_lastQueuedElement))
                {
                    // Empty text element with no breaks - so just ignore.
                } 
                else
                { 
                    _lastQueuedElement.BreakAfter = _beginNewParagraph; 
                    ProcessElement(_lastQueuedElement);
                    ElementsProcessed = true; 
                }
            }

            _lastQueuedElement = element; 
            _lastQueuedElement.Format = currentFormat;
            _beginNewParagraph = false; 
        } 

        private void Flush() 
        {
            if (_currentTag != null)
            {
                // In the middle of a tag. There may be multiple inner text elements inside 
                // a tag, e.g.
                //      some text <%# a databinding %> some more text 
                // and we're being flushed just at the start of the databinding. 

                if (!_currentTag.IsEmptyText) 
                {
                    ProcessTagInnerText(_currentTag.Text);
                }
                _currentTag.Text = String.Empty; 
                return;
            } 
 
            if (_lastQueuedElement == null)
            { 
                return;
            }

            // Ignore orphaned whitespace. 

            if (!_lastQueuedElement.ForceBreakTag && _lastQueuedElement.IsEmptyText) 
            { 
                if (!ElementsProcessed)
                { 
                    return;
                }
                if (_lastQueuedElement.Text.Length == 0 || _lastQueuedElement.Text[0] != ' ')
                { 
                    return;
                } 
 
                _lastQueuedElement.Text = " ";
            } 

            _lastQueuedElement.BreakAfter = _beginNewParagraph;
            ProcessElement(_lastQueuedElement);
            _lastQueuedElement = null; 
        }
 
        protected virtual bool IgnoreWhiteSpaceElement(LiteralElement element) 
        {
            return true; 
        }

        /*
         * FormatStack private class 
         *
         * This class maintains a simple stack of formatting directives. As tags and 
         * closing tags are processed, they are pushed on and popped off this stack. 
         * The CurrentFormat property returns the current state.
         */ 

        private class FormatStack
        {
            internal const char Bold = 'b'; 
            internal const char Italic = 'i';
 
            private StringBuilder _stringBuilder = new StringBuilder(16); 

            public void Push(char option) 
            {
                _stringBuilder.Append(option);
            }
 
            public void Pop(char option)
            { 
                // Only pop a matching directive - non-matching directives are ignored! 

                int length = _stringBuilder.Length; 
                if (length > 0 && _stringBuilder[length - 1] == option)
                {
                    _stringBuilder.Remove(length - 1, 1);
                } 
            }
 
            public LiteralFormat CurrentFormat 
            {
                get 
                {
                    LiteralFormat format = LiteralFormat.None;
                    for (int i = _stringBuilder.Length - 1; i >= 0; i--)
                    { 
                        switch (_stringBuilder[i])
                        { 
                            case Bold: 
                                format |= LiteralFormat.Bold;
                                break; 
                            case Italic:
                                format |= LiteralFormat.Italic;
                                break;
                        } 
                    }
                    return format; 
                } 
            }
        } 

    }

} 


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK