ParserX.cs

        #endregion

        #region Helpers

        /// <summary>
        /// Gets the current rule casted to the given type.
        /// </summary>
        T CurrentRuleAs<T>()
            where T : CSSRule
        {
            if (open.Count > 0)
                return open.Peek() as T;

            return default(T);
        }

        /// <summary>
        /// Switches the current state to the given one.
        /// </summary>
        /// <param name="newState">The state to switch to.</param>
        void SwitchTo(CssState newState)
        {
            switch (newState)
            {
                case CssState.InSelector:
                    tokenizer.IgnoreComments = true;
                    tokenizer.IgnoreWhitespace = false;
                    selector.Reset();
                    selector.IgnoreErrors = skipExceptions;
                    break;

                case CssState.InHexValue:
                case CssState.InUnknown:
                case CssState.InCondition:
                case CssState.InSingleValue:
                case CssState.InMediaValue:
                    tokenizer.IgnoreComments = true;
                    tokenizer.IgnoreWhitespace = false;
                    break;

                default:
                    tokenizer.IgnoreComments = true;
                    tokenizer.IgnoreWhitespace = true;
                    break;
            }

            state = newState;
        }

        /// <summary>
        /// The kernel that is pulling the tokens into the parser.
        /// </summary>
        void Kernel()
        {
            var tokens = tokenizer.Tokens;

            foreach (var token in tokens)
            {
                if (General(token) == false)
                    RaiseErrorOccurred(ErrorCode.InputUnexpected);
            }

            if (property != null)
                General(CssSpecialCharacter.Semicolon);

            selector.ToPool();
        }

        /// <summary>
        /// Examines the token by using the current state.
        /// </summary>
        /// <param name="token">The current token.</param>
        /// <returns>The status.</returns>
        Boolean General(CssToken token)
        {
            switch (state)
            {
                case CssState.Data:
                    return Data(token);
                case CssState.InSelector:
                    return InSelector(token);
                case CssState.InDeclaration:
                    return InDeclaration(token);
                case CssState.AfterProperty:
                    return AfterProperty(token);
                case CssState.BeforeValue:
                    return BeforeValue(token);
                case CssState.InValuePool:
                    return InValuePool(token);
                case CssState.InValueList:
                    return InValueList(token);
                case CssState.InSingleValue:
                    return InSingleValue(token);
                case CssState.ValueImportant:
                    return ValueImportant(token);
                case CssState.AfterValue:
                    return AfterValue(token);
                case CssState.InMediaList:
                    return InMediaList(token);
                case CssState.InMediaValue:
                    return InMediaValue(token);
                case CssState.BeforeImport:
                    return BeforeImport(token);
                case CssState.AfterInstruction:
                    return AfterInstruction(token);
                case CssState.BeforeCharset:
                    return BeforeCharset(token);
                case CssState.BeforeNamespacePrefix:
                    return BeforePrefix(token);
                case CssState.AfterNamespacePrefix:
                    return BeforeNamespace(token);
                case CssState.InCondition:
                    return InCondition(token);
                case CssState.InUnknown:
                    return InUnknown(token);
                case CssState.InKeyframeText:
                    return InKeyframeText(token);
                case CssState.BeforeDocumentFunction:
                    return BeforeDocumentFunction(token);
                case CssState.InDocumentFunction:
                    return InDocumentFunction(token);
                case CssState.AfterDocumentFunction:
                    return AfterDocumentFunction(token);
                case CssState.BetweenDocumentFunctions:
                    return BetweenDocumentFunctions(token);
                case CssState.BeforeKeyframesName:
                    return BeforeKeyframesName(token);
                case CssState.BeforeKeyframesData:
                    return BeforeKeyframesData(token);
                case CssState.KeyframesData:
                    return KeyframesData(token);
                case CssState.InHexValue:
                    return InHexValue(token);
                case CssState.InFunction:
                    return InValueFunction(token);
                default:
                    return false;
            }
        }

        #endregion

        #region Public static methods

        /// <summary>
        /// Takes a string and transforms it into a selector object.
        /// </summary>
        /// <param name="selector">The string to parse.</param>
        /// <returns>The Selector object.</returns>
        public static Selector ParseSelector(String selector)
        {
            var tokenizer = new CssTokenizer(new SourceManager(selector));
            var tokens = tokenizer.Tokens;
            var selctor = Pool.NewSelectorConstructor();

            foreach (var token in tokens)
                selctor.Apply(token);

            var result = selctor.Result;
            selctor.ToPool();
            return result;
        }

        /// <summary>
        /// Takes a string and transforms it into a CSS stylesheet.
        /// </summary>
        /// <param name="stylesheet">The string to parse.</param>
        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
        /// <returns>The CSSStyleSheet object.</returns>
        public static CSSStyleSheet ParseStyleSheet(String stylesheet, Boolean quirksMode = false)
        {
            var parser = new CssParser(stylesheet);
            parser.IsQuirksMode = quirksMode;
            return parser.Result;
        }

        /// <summary>
        /// Takes a string and transforms it into a CSS rule.
        /// </summary>
        /// <param name="rule">The string to parse.</param>
        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
        /// <returns>The CSSRule object.</returns>
        public static CSSRule ParseRule(String rule, Boolean quirksMode = false)
        {
            var parser = new CssParser(rule);
            parser.skipExceptions = false;
            parser.IsQuirksMode = quirksMode;
            parser.Parse();

            if (parser.sheet.CssRules.Length > 0)
                return parser.sheet.CssRules[0];

            return null;
        }

        /// <summary>
        /// Takes a string and transforms it into CSS declarations.
        /// </summary>
        /// <param name="declarations">The string to parse.</param>
        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
        /// <returns>The CSSStyleDeclaration object.</returns>
        public static CSSStyleDeclaration ParseDeclarations(String declarations, Boolean quirksMode = false)
        {
            var decl = new CSSStyleDeclaration();
            AppendDeclarations(decl, declarations, quirksMode);
            return decl;
        }

        /// <summary>
        /// Takes a string and transforms it into a CSS declaration (CSS property).
        /// </summary>
        /// <param name="declarations">The string to parse.</param>
        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
        /// <returns>The CSSProperty object.</returns>
        public static CSSProperty ParseDeclaration(String declarations, Boolean quirksMode = false)
        {
            var parser = new CssParser(declarations);
            parser.state = CssState.InDeclaration;
            parser.IsQuirksMode = quirksMode;
            parser.skipExceptions = false;
            parser.Parse();
            return parser.property;
        }

        /// <summary>
        /// Takes a string and transforms it into a CSS value.
        /// </summary>
        /// <param name="source">The string to parse.</param>
        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
        /// <returns>The CSSValue object.</returns>
        public static CSSValue ParseValue(String source, Boolean quirksMode = false)
        {
            var parser = new CssParser(source);
            var property = new CSSProperty(String.Empty);
            parser.property = property;
            parser.IsQuirksMode = quirksMode;
            parser.skipExceptions = false;
            parser.state = CssState.BeforeValue;
            parser.Parse();
            return property.Value;
        }

        #endregion

        #region Internal static methods

        /// <summary>
        /// Takes a string and transforms it into a list of CSS values.
        /// </summary>
        /// <param name="source">The string to parse.</param>
        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
        /// <returns>The CSSValueList object.</returns>
        internal static CSSValueList ParseValueList(String source, Boolean quirksMode = false)
        {
            var parser = new CssParser(source);
            var list = new CSSValueList();
            var property = new CSSProperty(String.Empty);
            property.Value = list;
            parser.property = property;
            parser.IsQuirksMode = quirksMode;
            parser.skipExceptions = false;
            parser.state = CssState.InValueList;
            parser.Parse();
            return list;
        }

        /// <summary>
        /// Takes a comma separated string and transforms it into a list of CSS values.
        /// </summary>
        /// <param name="source">The string to parse.</param>
        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
        /// <returns>The CSSValueList object.</returns>
        internal static CSSValuePool ParseMultipleValues(String source, Boolean quirksMode = false)
        {
            var parser = new CssParser(source);
            var pool = new CSSValuePool();
            var property = new CSSProperty(String.Empty);
            property.Value = pool;
            parser.property = property;
            parser.IsQuirksMode = quirksMode;
            parser.skipExceptions = false;
            parser.state = CssState.InValuePool;
            parser.Parse();
            return pool;
        }

        /// <summary>
        /// Takes a string and transforms it into a CSS keyframe rule.
        /// </summary>
        /// <param name="rule">The string to parse.</param>
        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
        /// <returns>The CSSKeyframeRule object.</returns>
        internal static CSSKeyframeRule ParseKeyframeRule(String rule, Boolean quirksMode = false)
        {
            var parser = new CssParser(rule);
            var keyframe = new CSSKeyframeRule();
            parser.AddRule(keyframe);
            parser.IsQuirksMode = quirksMode;
            parser.skipExceptions = false;
            parser.state = CssState.InKeyframeText;
            parser.Parse();
            return keyframe;
        }

        /// <summary>
        /// Takes a string and appends all rules to the given list of properties.
        /// </summary>
        /// <param name="list">The list of css properties to append to.</param>
        /// <param name="declarations">The string to parse.</param>
        /// <param name="quirksMode">Optional: The status of the quirks mode flag (usually not set).</param>
        internal static void AppendDeclarations(CSSStyleDeclaration list, String declarations, Boolean quirksMode = false)
        {
            var parser = new CssParser(declarations);
            parser.IsQuirksMode = quirksMode;
            parser.skipExceptions = false;

            if (list.ParentRule != null)
                parser.AddRule(list.ParentRule);
            else
                parser.AddRule(new CSSStyleRule(list));

            parser.state = CssState.InDeclaration;
            parser.Parse();
        }

        #endregion

        #region State Enumeration

        /// <summary>
        /// The enumeration with possible state values.
        /// </summary>
        enum CssState
        {
            Data,
            InSelector,
            InDeclaration,
            AfterProperty,
            BeforeValue,
            InValuePool,
            InValueList,
            InSingleValue,
            InMediaList,
            InMediaValue,
            BeforeImport,
            BeforeCharset,
            BeforeNamespacePrefix,
            AfterNamespacePrefix,
            AfterInstruction,
            InCondition,
            BeforeKeyframesName,
            BeforeKeyframesData,
            KeyframesData,
            InKeyframeText,
            BeforeDocumentFunction,
            InDocumentFunction,
            AfterDocumentFunction,
            BetweenDocumentFunctions,
            InUnknown,
            ValueImportant,
            AfterValue,
            InHexValue,
            InFunction
        }

        /// <summary>
        /// A buffer for functions.
        /// </summary>
        class FunctionBuffer
        {
            #region Members

            String name;
            List<CSSValue> arguments;
            CSSValue value;

            #endregion

            #region ctor

            internal FunctionBuffer(String name)
            {
                this.arguments = new List<CSSValue>();
                this.name = name;
            }

            #endregion

            #region Properties

            public List<CSSValue> Arguments
            {
                get { return arguments; }
            }

            public CSSValue Value
            {
                get { return value; }
                set { this.value = value; }
            }

            #endregion

            #region Methods

            public void Include()
            {
                if (value != null)
                    arguments.Add(value);

                value = null;
            }

            public CSSValue Done()
            {
                Include();
                return CSSFunction.Create(name, arguments);
            }

            #endregion
        }

        #endregion
    }
}