//------------------------------------------------------------------------------
// <copyright file="ControlBuilder.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.UI {
    using System;
    using System.CodeDom;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.Specialized;
    using System.ComponentModel;
    using System.ComponentModel.Design;
    using System.Globalization;
    using System.Linq;
    using System.Reflection;
    using System.Text.RegularExpressions;
    using System.Web;
    using System.Web.Compilation;
    using System.Web.Instrumentation;
    using System.Web.RegularExpressions;
    using System.Web.UI.HtmlControls;
    using System.Web.UI.WebControls;
    using System.Web.Util;

    /// <devdoc>
    /// Implementation of a generic control builder used by all controls and child objects
    /// </devdoc>
    public class ControlBuilder {

        public readonly static string DesignerFilter = "__designer";
        private readonly static string ItemTypeProperty = "ItemType";

#if DEBUG
        private bool _initCalled;
#endif

        // Parses a databinding expression (e.g. <%# i+1 %>
        private readonly static Regex databindRegex = new DataBindRegex();
        internal readonly static Regex expressionBuilderRegex = new ExpressionBuilderRegex();
        private readonly static Regex bindExpressionRegex = new BindExpressionRegex();
        private readonly static Regex bindParametersRegex = new BindParametersRegex();
        private readonly static Regex bindItemExpressionRegex = new BindItemExpressionRegex();
        private readonly static Regex bindItemParametersRegex = new BindItemParametersRegex();
        private readonly static Regex evalExpressionRegex = new EvalExpressionRegex();
        private readonly static Regex formatStringRegex = new FormatStringRegex();

        private Type _controlType;
        private string _tagName;
        private string _skinID;
        private ArrayList _subBuilders;
        private ControlBuilderParseTimeData _parseTimeData;
        private IServiceProvider _serviceProvider;

        // 
        private ArrayList _eventEntries;
        private ArrayList _simplePropertyEntries;
        private ArrayList _complexPropertyEntries;
        private ArrayList _templatePropertyEntries;
        private ArrayList _boundPropertyEntries;

        //A placeholder dictionary passed to ControlBuilderInterceptor methods.
        private IDictionary _additionalState; 

        private PropertyDescriptor _bindingContainerDescriptor;

        // NOTE: All bool fields in this class should be using the
        // below flags to conserve memory.

        // const masks into the BitVector32
        private const int parseComplete                 = 0x00000001;
        private const int needsTagAttributeComputed     = 0x00000002;
        private const int needsTagAttribute             = 0x00000004;
        private const int doneInitObjectOptimizations   = 0x00000008;
        private const int isICollection                 = 0x00000010;
        private const int isIParserAccessor             = 0x00000020;
        private const int hasFilteredSimpleProps        = 0x00000040;
        private const int hasFilteredComplexProps       = 0x00000080;
        private const int hasFilteredTemplateProps      = 0x00000100;
        private const int hasFilteredBoundProps         = 0x00000200;
        private const int hasTwoWayBoundProps           = 0x00000400;
        private const int triedFieldToControlBinding    = 0x00000800;
        private const int hasFieldToControlBinding      = 0x00001000;
        private const int controlTypeIsControl          = 0x00002000; // Indicates that the type specified in _controlType derives from Control
        private const int entriesSorted                 = 0x00004000;
        private const int applyTheme                    = 0x00008000;
        #pragma warning disable 0649
        private SimpleBitVector32 flags;
        #pragma warning restore 0649


        /// <devdoc>
        /// </devdoc>
        public virtual Type BindingContainerType {
            get {
                if (NamingContainerBuilder == null) {
                    return typeof(System.Web.UI.Control);
                }

                Type ctrlType = NamingContainerBuilder.ControlType;

                Debug.Assert(ctrlType != null, "Control type is null.");
                Debug.Assert(typeof(INamingContainer).IsAssignableFrom(ctrlType), String.Format(CultureInfo.InvariantCulture, "NamingContainerBuilder.Control type {0} is not an INamingContainer", ctrlType.FullName));

                // Recursively lookup if the NamingContainerBuilder.ControlType is an INonBindingContainer
                if (typeof(INonBindingContainer).IsAssignableFrom(ctrlType)) {
                    return NamingContainerBuilder.BindingContainerType;
                }

                return NamingContainerBuilder.ControlType;
            }
        }

        public virtual ControlBuilder BindingContainerBuilder {
            get {
                if (NamingContainerBuilder != null) {

                    Type ctrlType = NamingContainerBuilder.ControlType;

                    Debug.Assert(ctrlType != null, "Control type is null.");
                    Debug.Assert(typeof(INamingContainer).IsAssignableFrom(ctrlType), String.Format(CultureInfo.InvariantCulture, "NamingContainerBuilder.Control type {0} is not an INamingContainer", ctrlType.FullName));

                    // Recursively lookup if the NamingContainerBuilder.ControlType is an INonBindingContainer
                    if (typeof(INonBindingContainer).IsAssignableFrom(ctrlType)) {
                        return NamingContainerBuilder.BindingContainerBuilder;
                    }
                }

                return NamingContainerBuilder;
            }
        }

        /// <devdoc>
        ///If there is a ModelType property set on BindingContainer, returns the type corresponding to it
        /// </devdoc>
        public virtual String ItemType {
            get {
                ControlBuilder bindingContainerBuilder = BindingContainerBuilder;
                if (bindingContainerBuilder != null) {
                    Debug.Assert(bindingContainerBuilder is TemplateBuilder, "Assert failure in ControlBuilder class, there's a scenario where BindingContainerBuilder is not a TemplateBuilder, is someone asking for ModelType out of a Data Binding Context??");
                    if (bindingContainerBuilder.BindingContainerBuilder != null) {
                        return (from object propertyEntry in bindingContainerBuilder.BindingContainerBuilder.SimplePropertyEntriesInternal
                                let simplePropertyEntry = propertyEntry as SimplePropertyEntry
                                where simplePropertyEntry != null && simplePropertyEntry.Name.Equals(ItemTypeProperty, StringComparison.OrdinalIgnoreCase)
                                select (string)simplePropertyEntry.Value).FirstOrDefault();
                    }
                }
                return null;
            }
        }

        internal ICollection EventEntries {
            get {
                // If there are no entries, return a static empty collection
                if (_eventEntries == null)
                    return EmptyCollection.Instance;

                return _eventEntries;
            }
        }

        private ArrayList EventEntriesInternal {
            get {
                // Create the ArrayList on demand
                if (_eventEntries == null)
                    _eventEntries = new ArrayList();

                return _eventEntries;
            }
        }

        internal ICollection SimplePropertyEntries {
            get {
                // If there are no entries, return a static empty collection
                if (_simplePropertyEntries == null)
                    return EmptyCollection.Instance;

                return _simplePropertyEntries;
            }
        }

        internal ArrayList SimplePropertyEntriesInternal {
            get {
                // Create the ArrayList on demand
                if (_simplePropertyEntries == null)
                    _simplePropertyEntries = new ArrayList();

                return _simplePropertyEntries;
            }
        }

        public ICollection ComplexPropertyEntries {
            get {
                // If there are no entries, return a static empty collection
                if (_complexPropertyEntries == null)
                    return EmptyCollection.Instance;

                return _complexPropertyEntries;
            }
        }

        private ArrayList ComplexPropertyEntriesInternal {
            get {
                // Create the ArrayList on demand
                if (_complexPropertyEntries == null)
                    _complexPropertyEntries = new ArrayList();

                return _complexPropertyEntries;
            }
        }

        public ICollection TemplatePropertyEntries {
            get {
                // If there are no entries, return a static empty collection
                if (_templatePropertyEntries == null)
                    return EmptyCollection.Instance;

                return _templatePropertyEntries;
            }
        }

        private ArrayList TemplatePropertyEntriesInternal {
            get {
                // Create the ArrayList on demand
                if (_templatePropertyEntries == null)
                    _templatePropertyEntries = new ArrayList();

                return _templatePropertyEntries;
            }
        }

        internal ICollection BoundPropertyEntries {
            get {
                // If there are no entries, return a static empty collection
                if (_boundPropertyEntries == null)
                    return EmptyCollection.Instance;

                return _boundPropertyEntries;
            }
        }

        private ArrayList BoundPropertyEntriesInternal {
            get {
                // Create the ArrayList on demand
                if (_boundPropertyEntries == null)
                    _boundPropertyEntries = new ArrayList();

                return _boundPropertyEntries;
            }
        }

        internal bool HasFilteredBoundEntries {
            get {
                return flags[hasFilteredBoundProps];
            }
        }

        internal bool IsNoCompile {
            get {
                return flags[parseComplete];
            }
        }

        internal string SkinID {
            get {
                return _skinID;
            }
            set {
                _skinID = value;
            }
        }

        internal IDictionary AdditionalState {
            get {
                if (_additionalState == null) {
                    _additionalState = new Dictionary<object, object>();
                }
                return _additionalState;
            }
        }

        /// <devdoc>
        /// Return the type of the control that this builder creates
        /// </devdoc>
        public Type ControlType {
            get {
                return _controlType;
            }
        }


        public IFilterResolutionService CurrentFilterResolutionService {
            get {
                if (ServiceProvider != null) {
                    return (IFilterResolutionService)ServiceProvider.GetService(typeof(IFilterResolutionService));
                }
                else {
                    // If there is no ServiceProvider, use the TemplateControl (VSWhidbey 551431)
                    return TemplateControl;
                }
            }
        }


        /// <devdoc>
        /// Return the type that will be used by codegen to declare the control
        /// </devdoc>
        public virtual Type DeclareType {
            get {
                return _controlType;
            }
        }

        /// <devdoc>
        /// Gets the IDesignerHost if we are in design mode. This is used to load
        /// config through IWebApplication rather than the RuntimeConfig object.
        /// </devdoc>
        private IDesignerHost DesignerHost {
            get {
                if (InDesigner && ParseTimeData != null) {
                    TemplateParser parser = ParseTimeData.Parser;
                    if (parser != null) {
                        return parser.DesignerHost;
                    }
                }
                return null;
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        private ControlBuilder DefaultPropertyBuilder {
            get {
                return ParseTimeData.DefaultPropertyBuilder;
            }
        }


        public IThemeResolutionService ThemeResolutionService {
            get {
                if (ServiceProvider != null) {
                    return (IThemeResolutionService)ServiceProvider.GetService(typeof(IThemeResolutionService));
                }
                else {
                    // If there is no ServiceProvider, use the TemplateControl (VSWhidbey 551431)
                    return TemplateControl as IThemeResolutionService;
                }
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        private EventDescriptorCollection EventDescriptors {
            get {
                if (ParseTimeData.EventDescriptors == null) {
                    ParseTimeData.EventDescriptors = TargetFrameworkUtil.GetEvents(_controlType);
                }

                return ParseTimeData.EventDescriptors;
            }
        }

        internal string Filter {
            get {
                return ParseTimeData.Filter;
            }
            set {
                ParseTimeData.Filter = value;
            }
        }


        /// <devdoc>
        ///
        /// </devdoc>
        protected bool FChildrenAsProperties {
            get {
                return ParseTimeData.ChildrenAsProperties;
            }
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        protected bool FIsNonParserAccessor {
            get {
                return ParseTimeData.IsNonParserAccessor;
            }
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public virtual bool HasAspCode {
            get {
                return ParseTimeData.HasAspCode;
            }
        }

        /*
         * Return the ID of the control that this builder creates
         */

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public string ID {
            get {
                return ParseTimeData.ID;
            }
            set {
                ParseTimeData.ID = value;
            }
        }

        internal bool IsGeneratedID {
            get {
                return ParseTimeData.IsGeneratedID;
            }
            set {
                ParseTimeData.IsGeneratedID = value;
            }
        }

        private bool IgnoreControlProperty {
            get {
                return ParseTimeData.IgnoreControlProperties;
            }
        }


        /// <devdoc>
        ///    <para> InDesigner property gets used by control builders so that they can behave
        ///         differently if needed. </para>
        /// </devdoc>
        protected bool InDesigner {
            get {
                // If  we're in no-compile page mode, return false
                if (IsNoCompile)
                    return false;

                // Simply return null when called without a Parser.
                // This is in the codepath from TemplateBuilder.NeedsTagInnerText()
                // to determine designer source code preservation behavior by tools.
                if (Parser == null)
                    return false;

                return Parser.FInDesigner;
            }
        }


        /// <devdoc>
        ///    <para> InPageTheme property indicates if the control builder is used to generate page themes.</para>
        /// </devdoc>
        protected bool InPageTheme {
            get {
                return Parser is PageThemeParser;
            }
        }

        internal bool IsControlSkin {
            get {
                return ParentBuilder is FileLevelPageThemeBuilder;
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        private bool IsHtmlControl {
            get {
                return ParseTimeData.IsHtmlControl;
            }
        }

        /// <devdoc>
        /// The source file line number at which this builder is defined
        /// </devdoc>
        internal int Line {
            get {
                return ParseTimeData.Line;
            }
            set {
                ParseTimeData.Line = value;
            }
        }

        public bool Localize {
            get {
                if (ParseTimeData != null) {
                    return ParseTimeData.Localize;
                }

                return true;
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        private ControlBuilder NamingContainerBuilder {
            get {
                if (ParseTimeData.NamingContainerSearched) {
                    return ParseTimeData.NamingContainerBuilder;
                }

                if (ParentBuilder == null || ParentBuilder.ControlType == null) {
                    ParseTimeData.NamingContainerBuilder = null;
                }
                else if (typeof(INamingContainer).IsAssignableFrom(ParentBuilder.ControlType)) {
                    ParseTimeData.NamingContainerBuilder = ParentBuilder;
                }
                else {
                    ParseTimeData.NamingContainerBuilder = ParentBuilder.NamingContainerBuilder;
                }

                ParseTimeData.NamingContainerSearched = true;
                return ParseTimeData.NamingContainerBuilder;
            }
        }


        /// <internalonly/>
        /// <devdoc>
        /// Return the type of the naming container of the control that this builder creates
        /// </devdoc>
        public Type NamingContainerType {
            get {
                if (NamingContainerBuilder == null) {
                    return typeof(System.Web.UI.Control);
                }

                return NamingContainerBuilder.ControlType;
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        internal CompilationMode CompilationMode {
            get {
                return Parser.CompilationMode;
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        internal ControlBuilder ParentBuilder {
            get {
                return ParseTimeData.ParentBuilder;
            }
        }


        /// <devdoc>
        ///
        /// </devdoc>
        protected internal TemplateParser Parser {
            get {
                return ParseTimeData.Parser;
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        private ControlBuilderParseTimeData ParseTimeData {
            get {
                if (_parseTimeData == null) {
                    if (IsNoCompile) {
                        throw new InvalidOperationException(SR.GetString(SR.ControlBuilder_ParseTimeDataNotAvailable));
                    }

                    _parseTimeData = new ControlBuilderParseTimeData();
                }

                return _parseTimeData;
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        private PropertyDescriptorCollection PropertyDescriptors {
            get {
                if (ParseTimeData.PropertyDescriptors == null) {
                    ParseTimeData.PropertyDescriptors = TargetFrameworkUtil.GetProperties(_controlType);
                }

                return ParseTimeData.PropertyDescriptors;
            }
        }

        private StringSet PropertyEntries {
            get {
                if (ParseTimeData.PropertyEntries == null) {
                    ParseTimeData.PropertyEntries = new CaseInsensitiveStringSet();
                }

                return ParseTimeData.PropertyEntries;
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        public ArrayList SubBuilders {
            get {
                if (_subBuilders == null) {
                    _subBuilders = new ArrayList();
                }

                return _subBuilders;
            }
        }

        public IServiceProvider ServiceProvider {
            get {
                return _serviceProvider;
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        private bool SupportsAttributes {
            get {
                return ParseTimeData.SupportsAttributes;
            }
        }


        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public string TagName {
            get {
                return _tagName;
            }
        }

        /// <devdoc>
        /// The name of the source file in which this builder is defined
        /// </devdoc>
        internal VirtualPath VirtualPath {
            get {
                return ParseTimeData.VirtualPath;
            }
            set {
                ParseTimeData.VirtualPath = value;
            }
        }

        public string PageVirtualPath {
            get {
                return System.Web.VirtualPath.GetVirtualPathString(VirtualPath);
            }
        }

        /// <devdoc>
        /// The template control that hosts the current control. For example, it is the usercontrol for controls defined in a usercontrol file.
        /// This property is available only in non-compiled cases.
        /// </devdoc>
        internal TemplateControl TemplateControl {
            get {
                HttpContext context = HttpContext.Current;
                if (context == null) {
                    return null;
                }

                return context.TemplateControl;
            }
        }

        private void AddBoundProperty(string filter, string name, string expressionPrefix,
            string expression, ExpressionBuilder expressionBuilder, object parsedExpressionData, string fieldName, string formatString, bool twoWayBound, bool encode, int line = 0, int column = 0) {
            AddBoundProperty(filter, name, expressionPrefix, expression, expressionBuilder, parsedExpressionData, false, fieldName, formatString, twoWayBound, encode, line, column);
        }

        /// <devdoc>
        ///
        /// </devdoc>
        private void AddBoundProperty(string filter, string name, string expressionPrefix,
            string expression, ExpressionBuilder expressionBuilder, object parsedExpressionData, bool generated, string fieldName, 
            string formatString, bool twoWayBound, bool encode, int line = 0, int column = 0) {

            Debug.Assert(!String.IsNullOrEmpty(name));

            string controlID = ParseTimeData.ID;

            // Get the IDesignerHost in case we need it to find ExpressionBuilders
            IDesignerHost host = DesignerHost;

            if (String.IsNullOrEmpty(expressionPrefix)) {
                // This is a databinding entry
                if (String.IsNullOrEmpty(controlID)) {
                    if (CompilationMode == CompilationMode.Never) {
                        throw new HttpException(SR.GetString(SR.NoCompileBinding_requires_ID, _controlType.Name, fieldName));
                    }
                    if (twoWayBound) {
                        throw new HttpException(SR.GetString(SR.TwoWayBinding_requires_ID, _controlType.Name, fieldName));
                    }
                }

                Debug.Assert(ControlType != null, "ControlType should not be null if we're adding a property entry");
                // We only support databindings on objects that have an event named "DataBinding"
                if (!flags[controlTypeIsControl]) {
                    if (TargetFrameworkUtil.GetEvent(ControlType, "DataBinding") == null) {
                        throw new InvalidOperationException(SR.GetString(SR.ControlBuilder_DatabindingRequiresEvent, _controlType.FullName));
                    }
                }
            }
            else {
                // If we don't have an expression builder yet, go get it
                if (expressionBuilder == null) {
                    expressionBuilder = ExpressionBuilder.GetExpressionBuilder(expressionPrefix, VirtualPath, host);
                }
            }

            Debug.Assert(!(String.IsNullOrEmpty(expressionPrefix) ^ (expressionBuilder == null)), "expressionBuilder should be non-null iff expressionPrefix is non-empty");

            // Set up a BoundPropertyEntry since we know this is an expression
            BoundPropertyEntry entry = new BoundPropertyEntry();

            entry.Filter = filter;
            entry.Expression = expression;
            entry.ExpressionBuilder = expressionBuilder;
            entry.ExpressionPrefix = expressionPrefix;
            entry.Generated = generated;
            entry.FieldName = fieldName;
            entry.FormatString = formatString;
            entry.ControlType = _controlType;
            entry.ControlID = controlID;
            entry.TwoWayBound = twoWayBound;
            entry.ParsedExpressionData = parsedExpressionData;
            entry.IsEncoded = encode;
            entry.Line = line;
            entry.Column = column;
            
            FillUpBoundPropertyEntry(entry, name);

            // Check for duplicate bound property entries and throws if it finds one.
            // This is done here rather than on AddBoundProperty(BoundPropertyEntry entry) since
            // that overload can be called by other control builders in two-way binding scenarios.
            // In that case it is valid to have duplicate bound property entries since they are on
            // the BindableTemplateBuilder, not the control's ControlBuilder.
            foreach (BoundPropertyEntry bpe in BoundPropertyEntriesInternal) {
                if (String.Equals(bpe.Name, entry.Name, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(bpe.Filter, entry.Filter, StringComparison.OrdinalIgnoreCase)) {
                    string fullPropertyName = entry.Name;
                    if (!String.IsNullOrEmpty(entry.Filter)) {
                        fullPropertyName = entry.Filter + ":" + fullPropertyName;
                    }
                    throw new InvalidOperationException(SR.GetString(SR.ControlBuilder_CannotHaveMultipleBoundEntries, fullPropertyName, ControlType));
                }
            }

            // Add these to the bound entries
            AddBoundProperty(entry);
        }

        private void AddBoundProperty(BoundPropertyEntry entry) {
            // Add these to the bound entries
            AddEntry(BoundPropertyEntriesInternal, entry);

            if (entry.TwoWayBound) {
                // Remember that this builder has some two-way entries
                flags[hasTwoWayBoundProps] = true;
            }
        }

        // Attach the TargetFrameworkProvider to enable designer Multi-Targeting
        private void AttachTypeDescriptionProvider(object obj) {
            if (InDesigner && (obj != null) && (_serviceProvider != null)) {
                TypeDescriptionProviderService tdpService = _serviceProvider.GetService(typeof(TypeDescriptionProviderService))
                    as TypeDescriptionProviderService;
                if (tdpService != null) {
                    TypeDescriptor.AddProvider(tdpService.GetProvider(obj), obj);
                }
            }
        }

        private void FillUpBoundPropertyEntry(BoundPropertyEntry entry, string name) {

            // Grab a member info corresponding to the property
            string objectModelName;

            MemberInfo memberInfo = PropertyMapper.GetMemberInfo(_controlType, name, out objectModelName);
            entry.Name = objectModelName;

            // If we got a memberInfo
            if (memberInfo != null) {

                if (memberInfo is PropertyInfo) {
                    // If it's a property, make sure it is persistable
                    PropertyInfo propInfo = ((PropertyInfo)memberInfo);

                    if (propInfo.GetSetMethod() == null) {
                        if (!SupportsAttributes) {
                            throw new HttpException(SR.GetString(SR.Property_readonly, name));
                        }
                        else {
                            // If the property is readonly, fall back to using SetAttribute
                            if (entry.TwoWayBound) {
                                entry.ReadOnlyProperty = true;
                            }
                            else {
                                entry.UseSetAttribute = true;
                            }
                        }
                    }
                    else {
                        // The property is settable, so we can use it
                        entry.PropertyInfo = propInfo;
                        entry.Type = propInfo.PropertyType;
                    }

                }
                else {
                    // If it's a field, just grab the type
                    Debug.Assert(memberInfo is FieldInfo);
                    entry.Type = ((FieldInfo)memberInfo).FieldType;
                }
            }
                // If we didn't find a member, we need to use the IAttributeAccessor
            else {
                if (!SupportsAttributes) {
                    throw new HttpException(SR.GetString(SR.Type_doesnt_have_property, _controlType.FullName, name));
                }
                else {
                    if (entry.TwoWayBound) {
                        throw new InvalidOperationException(SR.GetString(SR.ControlBuilder_TwoWayBindingNonProperty, name, ControlType.Name));
                    }
                    entry.Name = name;
                    entry.UseSetAttribute = true;
                }
            }

            // Make sure we have parsed expression data
            if (entry.ParsedExpressionData == null) {
                entry.ParseExpression(new ExpressionBuilderContext(VirtualPath));
            }

            if (!Parser.IgnoreParseErrors && entry.ParsedExpressionData == null) {
                // Disallow empty expressions (VSWhidbey 234273)
                if (Util.IsWhiteSpaceString(entry.Expression)) {

                    throw new HttpException(
                        SR.GetString(SR.Empty_expression));
                }
            }
        }


        /// <devdoc>
        /// </devdoc>
        private void AddCollectionItem(ControlBuilder builder) {
            // Just save the builder and filter and add it to the complex entries
            ComplexPropertyEntry entry = new ComplexPropertyEntry(true);

            entry.Builder = builder;
            entry.Filter = String.Empty;
            AddEntry(ComplexPropertyEntriesInternal, entry);
        }


        /// <devdoc>
        /// </devdoc>
        private void AddComplexProperty(string filter, string name, ControlBuilder builder) {

            // VSWhidbey 281887 Do not ignore complex properties, since templates could be defined inside collections
            // , databinding or code can be placed inside templates.
            /*
            if (IgnoreControlProperty) {
                return;
            }
            */

            Debug.Assert(!String.IsNullOrEmpty(name));
            Debug.Assert(builder != null);

            // Look for a MemberInfo
            string objectModelName = String.Empty;
            MemberInfo memberInfo = PropertyMapper.GetMemberInfo(_controlType, name, out objectModelName);

            // Initialize the entry
            ComplexPropertyEntry entry = new ComplexPropertyEntry();

            entry.Builder = builder;
            entry.Filter = filter;
            entry.Name = objectModelName;

            Type memberType = null;

            if (memberInfo != null) {
                if (memberInfo is PropertyInfo) {
                    PropertyInfo propInfo = ((PropertyInfo)memberInfo);

                    entry.PropertyInfo = propInfo;
                    if (propInfo.GetSetMethod() == null) {
                        entry.ReadOnly = true;
                    }

                    // Check if the property is themeable and persistable
                    ValidatePersistable(propInfo, false, false, false, filter);
                    memberType = propInfo.PropertyType;
                }
                else {
                    Debug.Assert(memberInfo is FieldInfo);
                    memberType = ((FieldInfo)memberInfo).FieldType;
                }

                entry.Type = memberType;
            }
            else {
                throw new HttpException(SR.GetString(SR.Type_doesnt_have_property, _controlType.FullName, name));
            }

            // Add the entry to the complex entries
            AddEntry(ComplexPropertyEntriesInternal, entry);
        }

        /// <devdoc>
        ///
        /// </devdoc>
        private void AddEntry(ArrayList entries, PropertyEntry entry) {
            // Only allow setting the ID property of a control using a simple property (e.g. ID="Button1").
            // This restricts the user from using databinding, expressions, implicit expressions,
            // or inner string properties to set the ID.
            if (String.Equals(entry.Name, "ID", StringComparison.OrdinalIgnoreCase) &&
                flags[controlTypeIsControl] &&
                !(entry is SimplePropertyEntry)) {
                throw new HttpException(SR.GetString(SR.ControlBuilder_IDMustUseAttribute));
            }

            // Remember the item index to perform a stable sort.
            entry.Index = entries.Count;

            // We used to sort the entries here via an insertion-type sort
            // But it's faster just to sort before we use the entries.
            entries.Add(entry);
        }

        /// <devdoc>
        //
        //// </devdoc>
        private void AddProperty(string filter, string name, string value, bool mainDirectiveMode) {
            Debug.Assert(!String.IsNullOrEmpty(name));

            //Second check is a hack to make the intellisense work with strongly typed controls. Existence of ModelType property
            //should force creation of code to make the intellisense to work, so far this is the only property
            //that is required to be identified at design time. 
            //If there's atleast one more property, this hack should be removed and another way should be figured out.
            if (IgnoreControlProperty && !name.Equals(ItemTypeProperty, StringComparison.OrdinalIgnoreCase)) {
                return;
            }

            string objectModelName = String.Empty;
            MemberInfo memberInfo = null;

            // This _controlType can be null if we're using a StringPropertyBuilder that has designer expandos
            if (_controlType != null) {
                if (String.Equals(name, BaseTemplateCodeDomTreeGenerator.skinIDPropertyName, StringComparison.OrdinalIgnoreCase) &&
                    flags[controlTypeIsControl]) {

                    // Make sure there isn't filter for skinID property.
                    if (!String.IsNullOrEmpty(filter)) {
                        throw new InvalidOperationException(SR.GetString(SR.Illegal_Device, BaseTemplateCodeDomTreeGenerator.skinIDPropertyName));
                    }

                    SkinID = value;
                    return;
                }

                memberInfo = PropertyMapper.GetMemberInfo(_controlType, name, out objectModelName);
            }

            if (memberInfo != null) {

                // Found a property on the object, so start building a simple property setter
                SimplePropertyEntry entry = new SimplePropertyEntry();

                entry.Filter = filter;
                entry.Name = objectModelName;
                entry.PersistedValue = value;

                Type memberType = null;

                if (memberInfo is PropertyInfo) {
                    PropertyInfo propInfo = ((PropertyInfo)memberInfo);

                    entry.PropertyInfo = propInfo;

                    // If the property is read-only
                    if (propInfo.GetSetMethod() == null) {
                        if (!SupportsAttributes) {
                            // If it doesn't support attributes, throw an exception
                            throw new HttpException(SR.GetString(SR.Property_readonly, name));
                        }
                        else {
                            // Otherwise, use the attribute accessor
                            entry.UseSetAttribute = true;

                            // Use the original casing of the name from the parsed data
                            entry.Name = name;
                        }
                    }

                    ValidatePersistable(propInfo, entry.UseSetAttribute, mainDirectiveMode, true, filter);
                    memberType = propInfo.PropertyType;
                }
                else {
                    Debug.Assert(memberInfo is FieldInfo);
                    memberType = ((FieldInfo)memberInfo).FieldType;
                }

                entry.Type = memberType;
                if (entry.UseSetAttribute) {
                    entry.Value = value;
                }
                else {
                    // Get the actual value for the property and store it in the entry
                    object objectValue = PropertyConverter.ObjectFromString(memberType, memberInfo, value);

                    DesignTimePageThemeParser themeParser = Parser as DesignTimePageThemeParser;
                    if (themeParser != null) {
                        object[] attrs = memberInfo.GetCustomAttributes(typeof(UrlPropertyAttribute), true);
                        if (attrs.Length > 0) {
                            string url = objectValue.ToString();
                            // Do not combine the url if it's apprelative, let controls resolve the url.
                            if (UrlPath.IsRelativeUrl(url) && !UrlPath.IsAppRelativePath(url)) {
                                objectValue = themeParser.ThemePhysicalPath + url;
                            }
                        }
                    }

                    entry.Value = objectValue;

                    // 

                    if (memberType.IsEnum) {
                        if (objectValue == null) {
                            throw new HttpException(SR.GetString(SR.Invalid_enum_value, value, name, entry.Type.FullName));
                        }

                        entry.PersistedValue = Enum.Format(memberType, objectValue, "G");
                    }
                    else if (memberType == typeof(Boolean)) {
                        // 
                        if (objectValue == null) {
                            entry.Value = true;
                        }
                    }
                }

                AddEntry(SimplePropertyEntriesInternal, entry);
            }
            else {
                bool foundEvent = false;

                // Check if the property is actually an event handler
                if (StringUtil.StringStartsWithIgnoreCase(name, "on")) {
                    string eventName = name.Substring(2);
                    EventDescriptor eventDesc = EventDescriptors.Find(eventName, true);

                    if (eventDesc != null) {
                        if (InPageTheme) {
                            throw new HttpException(SR.GetString(SR.Property_theme_disabled, eventName, ControlType.FullName));
                        }

                        if (value != null)
                            value = value.Trim();

                        if (String.IsNullOrEmpty(value)) {
                            throw new HttpException(SR.GetString(SR.Event_handler_cant_be_empty, name));
                        }

                        if (filter.Length > 0) {
                            throw new HttpException(SR.GetString(SR.Events_cant_be_filtered, filter, name));
                        }

                        foundEvent = true;

                        // First, give the PageParserFilter a chance to handle the event hookup
                        if (!Parser.PageParserFilterProcessedEventHookupAttribute(ID, eventDesc.Name, value)) {
                            // Make sure event handlers are allowed. In no-compile pages, they aren't. (VSWhidbey 450297)
                            Parser.OnFoundEventHandler(name);

                            EventEntry entry = new EventEntry();

                            entry.Name = eventDesc.Name;
                            entry.HandlerType = eventDesc.EventType;
                            entry.HandlerMethodName = value;
                            EventEntriesInternal.Add(entry);
                        }
                    }
                }

                // If we didn't find an eventhandler, we need to use the IAttributeAccessor
                if (!foundEvent) {
                    // Allow the designer filter expandos for simple attributes
                    if (!SupportsAttributes && (filter != DesignerFilter)) {
                        if (_controlType != null) {
                            throw new HttpException(SR.GetString(SR.Type_doesnt_have_property, _controlType.FullName, name));
                        }
                        else {
                            throw new HttpException(SR.GetString(SR.Property_doesnt_have_property, TagName, name));
                        }
                    }

                    SimplePropertyEntry entry = new SimplePropertyEntry();

                    entry.Filter = filter;
                    entry.Name = name;
                    entry.PersistedValue = value;
                    entry.UseSetAttribute = true;
                    entry.Value = value;
                    AddEntry(SimplePropertyEntriesInternal, entry);
                }
            }
        }


        /// <devdoc>
        /// </devdoc>
        private void AddTemplateProperty(string filter, string name, TemplateBuilder builder) {

            /* Do not ignore template properties since we do want to generate IDs for controls defined
               inside SingleInstanceTemplates. VSWhidbey 243341
            if (IgnoreControlProperty) {
                return;
            }
            */

            Debug.Assert(!String.IsNullOrEmpty(name));
            Debug.Assert(builder != null);

            // Look for a MemberInfo
            string objectModelName = String.Empty;
            MemberInfo memberInfo = PropertyMapper.GetMemberInfo(_controlType, name, out objectModelName);

            // Setup a template entry
            bool bindableTemplate = builder is BindableTemplateBuilder;
            TemplatePropertyEntry entry = new TemplatePropertyEntry(bindableTemplate);

            entry.Builder = builder;
            entry.Filter = filter;
            entry.Name = objectModelName;

            Type memberType = null;

            if (memberInfo != null) {
                if (memberInfo is PropertyInfo) {

                    PropertyInfo propInfo = ((PropertyInfo)memberInfo);

                    entry.PropertyInfo = propInfo;

                    ValidatePersistable(propInfo, false, false, false, filter);

                    // Check the attribute on the property to see if it has a ContainerType
                    TemplateContainerAttribute templateAttrib = (TemplateContainerAttribute)Attribute.GetCustomAttribute(propInfo, typeof(TemplateContainerAttribute), false);

                    if (templateAttrib != null) {
                        if (!typeof(INamingContainer).IsAssignableFrom(templateAttrib.ContainerType)) {
                            throw new HttpException(SR.GetString(SR.Invalid_template_container, name, templateAttrib.ContainerType.FullName));
                        }

                        // If it had one, make sure the builder knows what type it is
                        builder.SetControlType(templateAttrib.ContainerType);
                    }

                    entry.Type = propInfo.PropertyType;
                }
                else {
                    Debug.Assert(memberInfo is FieldInfo);
                    memberType = ((FieldInfo)memberInfo).FieldType;
                }

                entry.Type = memberType;
            }
            else {
                throw new HttpException(SR.GetString(SR.Type_doesnt_have_property, _controlType.FullName, name));
            }

            // Add it to the template entries
            AddEntry(TemplatePropertyEntriesInternal, entry);
        }

        /// <devdoc>
        ///
        /// </devdoc>
        internal void AddSubBuilder(object o) {
            SubBuilders.Add(o);
        }

        internal bool HasTwoWayBoundProperties {
            get {
                return flags[hasTwoWayBoundProps];
            }
        }


        /// <devdoc>
        ///
        /// </devdoc>
        public virtual bool AllowWhitespaceLiterals() {
            return true;
        }


        /// <devdoc>
        ///
        /// </devdoc>
        public virtual void AppendLiteralString(string s) {
            // Ignore null strings
            if (s == null) {
                return;
            }

            // If we are not building a control, or if our children define
            // properties, we should not get literal strings.  Ignore whitespace
            // ones, and fail for others
            if (FIsNonParserAccessor || FChildrenAsProperties) {
                // If there is a default property, delegate to its builder
                if (DefaultPropertyBuilder != null) {
                    DefaultPropertyBuilder.AppendLiteralString(s);
                    return;
                }

                s = s.Trim();
                if (FChildrenAsProperties) {
                    // Throw a better error message if the content start with the '<' char.
                    if (s.StartsWith("<", StringComparison.OrdinalIgnoreCase)) {
                        throw new HttpException(SR.GetString(SR.Literal_content_not_match_property, _controlType.FullName, s));
                    }
                }

                if (s.Length != 0) {
                    throw new HttpException(SR.GetString(SR.Literal_content_not_allowed, _controlType.FullName, s));
                }

                return;
            }

            // Ignore literals that are just whitespace if the control does not want them
            if ((AllowWhitespaceLiterals() == false) && Util.IsWhiteSpaceString(s))
                return;

            // A builder can specify its strings need to be html decoded
            if (HtmlDecodeLiterals()) {
                s = HttpUtility.HtmlDecode(s);
            }

            // If the last builder is a DataBoundLiteralControlBuilder, add the string
            // to it instead of to our list of sub-builders
            // But if page instrumentation is enabled, the strings need to be treated
            // separately, so don't combine them.
            DataBoundLiteralControlBuilder dataBoundBuilder = null;
            if (!PageInstrumentationService.IsEnabled) {
                object lastBuilder = GetLastBuilder();
                dataBoundBuilder = lastBuilder as DataBoundLiteralControlBuilder;
            }

            if (dataBoundBuilder != null) {
                Debug.Assert(!InDesigner, "!InDesigner");
                dataBoundBuilder.AddLiteralString(s);
            }
            else {
                AddSubBuilder(s);
            }
        }


        /// <devdoc>
        ///
        /// </devdoc>
        public virtual void AppendSubBuilder(ControlBuilder subBuilder) {
            // Tell the sub builder that it's about to be appended to its parent
            subBuilder.OnAppendToParentBuilder(this);
            if (FChildrenAsProperties) {
                // Don't allow code blocks when properties are expected (ASURT 97838)
                if (subBuilder is CodeBlockBuilder) {
                    throw new HttpException(SR.GetString(SR.Code_not_supported_on_not_controls));
                }

                // If there is a default property, delegate to its builder
                if (DefaultPropertyBuilder != null) {
                    DefaultPropertyBuilder.AppendSubBuilder(subBuilder);
                    return;
                }

                // The tagname is the property name
                string propName = subBuilder.TagName;

                if (subBuilder is TemplateBuilder) {
                    TemplateBuilder tplBuilder = (TemplateBuilder)subBuilder;

                    AddTemplateProperty(tplBuilder.Filter, propName, tplBuilder);
                }
                else if (subBuilder is CollectionBuilder) {
                    // If there are items in the collection, add them
                    if ((subBuilder.SubBuilders != null) && (subBuilder.SubBuilders.Count > 0)) {
                        IEnumerator subBuilders = subBuilder.SubBuilders.GetEnumerator();

                        while (subBuilders.MoveNext()) {
                            ControlBuilder builder = (ControlBuilder)subBuilders.Current;

                            subBuilder.AddCollectionItem(builder);
                        }

                        subBuilder.SubBuilders.Clear();
                        AddComplexProperty(subBuilder.Filter, propName, subBuilder);
                    }
                }
                else if (subBuilder is StringPropertyBuilder) {
                    // Trim this so whitespace doesn't matter inside a tag?
                    string text = ((StringPropertyBuilder)subBuilder).Text.Trim();

                    if (!String.IsNullOrEmpty(text)) {
                        // Make sure we haven't set this property in the attributes already (special case for TextBox and similar things)
                        AddComplexProperty(subBuilder.Filter, propName, subBuilder);
                    }
                }
                else {
                    AddComplexProperty(subBuilder.Filter, propName, subBuilder);
                }

                return;
            }

            CodeBlockBuilder codeBlockBuilder = subBuilder as CodeBlockBuilder;

            if (codeBlockBuilder != null) {
                // Don't allow code blocks inside non-control tags (ASURT 76719)
                if (ControlType != null && !flags[controlTypeIsControl]) {
                    throw new HttpException(SR.GetString(SR.Code_not_supported_on_not_controls));
                }

                // Is it a databinding expression?  <%# ... %>
                if (codeBlockBuilder.BlockType == CodeBlockType.DataBinding) {
                    // Bind statements are not allowed as DataBoundLiterals inside any template.
                    // Outside a template, they should be treated as calls to page code.
                    Match match;

                    if ((match = bindExpressionRegex.Match(codeBlockBuilder.Content, 0)).Success || (match = bindItemExpressionRegex.Match(codeBlockBuilder.Content, 0)).Success) {
                        ControlBuilder currentBuilder = this;

                        while (currentBuilder != null && !(currentBuilder is TemplateBuilder)) {
                            currentBuilder = currentBuilder.ParentBuilder;
                        }

                        if (currentBuilder != null && currentBuilder.ParentBuilder != null && currentBuilder is TemplateBuilder) {
                            throw new HttpException(SR.GetString(SR.DataBoundLiterals_cant_bind));
                        }
                    }

                    if (InDesigner) {
                        // In the designer, don't use the fancy multipart DataBoundLiteralControl,
                        // which breaks a number of things (ASURT 82925,86738).  Instead, use the
                        // simpler DesignerDataBoundLiteralControl, and do standard databinding
                        // on its Text property.
                        IDictionary attribs = new ParsedAttributeCollection();

                        attribs.Add("Text", "<%#" + codeBlockBuilder.Content + "%>");
                        subBuilder = CreateBuilderFromType(Parser, this, typeof(DesignerDataBoundLiteralControl),
                            null, null, attribs, codeBlockBuilder.Line, codeBlockBuilder.PageVirtualPath);
                    }
                    else {
                        // Get the last builder, and check if it's a DataBoundLiteralControlBuilder
                        object lastBuilder = GetLastBuilder();
                        DataBoundLiteralControlBuilder dataBoundBuilder = lastBuilder as DataBoundLiteralControlBuilder;

                        // If not, then we need to create one.  Otherwise, just append to the
                        // existing one
                        bool fNewDataBoundLiteralControl = false;

                        if (dataBoundBuilder == null) {
                            dataBoundBuilder = new DataBoundLiteralControlBuilder();
                            dataBoundBuilder.Init(Parser, this, typeof(DataBoundLiteralControl), null, null, null);
                            dataBoundBuilder.Line = codeBlockBuilder.Line;
                            dataBoundBuilder.VirtualPath = codeBlockBuilder.VirtualPath;
                            fNewDataBoundLiteralControl = true;

                            // If the previous builder was a string, add it as the first
                            // entry in the composite control.
                            // But if instrumentation is enabled, the strings need to be
                            // treated separately, so don't combine them
                            if (!PageInstrumentationService.IsEnabled) {
                                string s = lastBuilder as string;

                                if (s != null) {
                                    SubBuilders.RemoveAt(SubBuilders.Count - 1);
                                    dataBoundBuilder.AddLiteralString(s);
                                }
                            }
                        }

                        dataBoundBuilder.AddDataBindingExpression(codeBlockBuilder);
                        if (!fNewDataBoundLiteralControl)
                            return;

                        subBuilder = dataBoundBuilder;
                    }
                }
                else {
                    // Set a flag if there is at least one block of ASP code
                    ParseTimeData.HasAspCode = true;
                }
            }

            if (FIsNonParserAccessor) {
                throw new HttpException(SR.GetString(SR.Children_not_supported_on_not_controls));
            }

            AddSubBuilder(subBuilder);
        }

        /// <devdoc>
        /// Builds all child ControlBuilders of this ControlBuilder.
        /// Only used in the no-compile scenario.
        /// </devdoc>
        internal virtual void BuildChildren(object parentObj) {
            // Create all the children
            if (_subBuilders != null) {
                IEnumerator en = _subBuilders.GetEnumerator();

                for (int i = 0; en.MoveNext(); i++) {
                    object childObj;
                    object cur = en.Current;

                    if (cur is string) {
                        childObj = new LiteralControl((string)cur);
                    }
                    else if (cur is CodeBlockBuilder) {
                        if (InDesigner) {
                            CodeBlockBuilder cbb = (CodeBlockBuilder)cur;
                            string code;
                            switch (cbb.BlockType) {
                                case CodeBlockType.Code:
                                    code = "<%" + cbb.Content + "%>";
                                    break;
                                case CodeBlockType.Expression:
                                    code = "<%=" + cbb.Content + "%>";
                                    break;
                                case CodeBlockType.EncodedExpression:
                                    code = "<%:" + cbb.Content + "%>";
                                    break;
                                case CodeBlockType.DataBinding:
                                    code = "<%#" + (cbb.IsEncoded ? ":" : "") + cbb.Content + "%>";
                                    break;
                                default:
                                    Debug.Fail("Invalid value for CodeBlockType enum");
                                    code = null;
                                    break;
                            }
                            childObj = new LiteralControl(code);
                        }
                        else {
                            // In case this function is called at runtime, we want to be consistent with the past behavior
                            continue;
                        }
                    }
                    else {
                        ControlBuilder controlBuilder = (ControlBuilder)cur;

                        Debug.Assert(controlBuilder.ServiceProvider == null);
                        controlBuilder.SetServiceProvider(ServiceProvider);
                        try {
                            childObj = controlBuilder.BuildObject(flags[applyTheme]);

                            // If it's a user control, call its InitializeAsUserControl
                            if (!InDesigner) {
                                UserControl uc = childObj as UserControl;

                                if (uc != null) {
                                    Control parent = parentObj as Control;

                                    Debug.Assert(parent != null);
                                    uc.InitializeAsUserControl(parent.Page);
                                }
                            }
                        } finally {
                            controlBuilder.SetServiceProvider(null);
                        }
                    }

                    Debug.Assert(childObj != null);
                    Debug.Assert(typeof(IParserAccessor).IsAssignableFrom(parentObj.GetType()));
                    ((IParserAccessor)parentObj).AddParsedSubObject(childObj);
                }
            }
        }


        /// <devdoc>
        /// This code is only used in the no-compile mode.
        /// It is used at design-time and when the user calls Page.ParseControl.
        /// </devdoc>
        public virtual object BuildObject() {
            return BuildObjectInternal();
        }

        // Helper which sets themebility (This will only ever be true in the designer)
        internal object BuildObject(bool shouldApplyTheme) {
            if (flags[applyTheme] != shouldApplyTheme)
                flags[applyTheme] = shouldApplyTheme;
            return BuildObject();
        }

        internal object BuildObjectInternal() {
            // Can't assert these anymore since we've discarded this information by the time we call this method
            // Debug.Assert(InDesigner || CompilationMode == CompilationMode.Never, "Expected to be in designer mode.");
            // Since getting the ConstructorNeedsTagAttribute is very expensive, cache
            // the result in a flag
            if (!flags[needsTagAttributeComputed]) {
                // If it has a ConstructorNeedsTagAttribute, it needs a tag name
                ConstructorNeedsTagAttribute cnta = (ConstructorNeedsTagAttribute)TargetFrameworkUtil.GetAttributes(ControlType)[typeof(ConstructorNeedsTagAttribute)];

                if (cnta != null && cnta.NeedsTag) {
                    flags[needsTagAttribute] = true;
                }

                // Remember that we have cached it
                flags[needsTagAttributeComputed] = true;
            }

            Object obj;

            if (flags[needsTagAttribute]) {
                // Create the object, using its ctor that takes the tag name
                Object[] args = new Object[] { TagName };

                obj = HttpRuntime.CreatePublicInstance(_controlType, args);
            }
            else {
                // Create the object
                obj = HttpRuntime.FastCreatePublicInstance(_controlType);
            }

            if (flags[applyTheme]) obj = GetThemedObject(obj);

            AttachTypeDescriptionProvider(obj);
            RenderTraceListener.CurrentListeners.ShareTraceData(this, obj);
            InitObject(obj);
            return obj;
        }


        /// <devdoc>
        /// Called when the parser is done with parsing for this ControlBuilder.
        /// </devdoc>
        public virtual void CloseControl() {
        }

        internal static ParsedAttributeCollection ConvertDictionaryToParsedAttributeCollection(IDictionary attribs) {
            if (attribs is ParsedAttributeCollection) {
                return (ParsedAttributeCollection)attribs;
            }

            // Assert here so we know our own code is never passing in a plain IDictionary
            // System.Web.Mobile does this, so we don't assert
            // Debug.Assert(false);
            ParsedAttributeCollection newAttribs = new ParsedAttributeCollection();

            foreach (DictionaryEntry entry in attribs) {
                newAttribs.AddFilteredAttribute(String.Empty, entry.Key.ToString(), entry.Value.ToString());
            }

            return newAttribs;
        }

        internal ControlBuilder CreateChildBuilder(string filter, string tagName, IDictionary attribs, TemplateParser parser, ControlBuilder parentBuilder, string id, int line, VirtualPath virtualPath, ref Type childType, bool defaultProperty) {
            ControlBuilder subBuilder;

            if (FChildrenAsProperties) {
                // If there is a default property, delegate to its builder
                if (DefaultPropertyBuilder != null) {
                    // check if a property exists for this tag
                    PropertyInfo pInfo = TargetFrameworkUtil.GetProperty(_controlType, tagName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.IgnoreCase);

                    if (pInfo != null) {
                        subBuilder = GetChildPropertyBuilder(tagName, attribs, ref childType, parser, false);

                        // If items have already been added to the default builder, throw an exception
                        if (DefaultPropertyBuilder.SubBuilders.Count > 0) {
                            ParseChildrenAttribute pca = null;
                            object[] attrs = TargetFrameworkUtil.GetCustomAttributes(ControlType, typeof(ParseChildrenAttribute), /*inherit*/ true);

                            pca = (ParseChildrenAttribute)attrs[0];
                            Debug.Assert(pca != null);
                            throw new HttpException(SR.GetString(SR.Cant_use_default_items_and_filtered_collection, _controlType.FullName, pca.DefaultProperty));
                        }

                        // Can't use the default property builder anymore since we have filtered collections
                        ParseTimeData.DefaultPropertyBuilder = null;
                    }
                    else {
                        subBuilder = DefaultPropertyBuilder.CreateChildBuilder(filter, tagName, attribs, parser, parentBuilder, id, line, virtualPath, ref childType, false /*defaultProperty*/);
                    }
                }
                else {
                    subBuilder = GetChildPropertyBuilder(tagName, attribs, ref childType, parser, defaultProperty);
                }
            }
            else {
                string fullTagName = Util.CreateFilteredName(filter, tagName);

                childType = GetChildControlType(fullTagName, attribs);
                if (childType == null) {
                    return null;
                }

                // We have to pass in the fullTagName since these will be actual registered controls
                subBuilder = CreateBuilderFromType(parser, parentBuilder, childType, fullTagName,
                    id, attribs, line, PageVirtualPath);
            }

            if (subBuilder == null) {
                return null;
            }

            subBuilder.Filter = filter;
            subBuilder.SetParentBuilder((parentBuilder != null) ? parentBuilder : this);
            return subBuilder;
        }


        /// <devdoc>
        /// Create a ControlBuilder for a given tag
        /// </devdoc>
        public static ControlBuilder CreateBuilderFromType(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string id, IDictionary attribs, int line, string sourceFileName) {
            ControlBuilder builder = CreateBuilderFromType(type);

            // 

            builder.Line = line;
            builder.VirtualPath = System.Web.VirtualPath.CreateAllowNull(sourceFileName);

            // Initialize the builder
            builder.Init(parser, parentBuilder, type, tagName, id, attribs);
            return builder;
        }

#if !DONTUSEFACTORYGENERATOR
        // Cache instances of IWebObjectFactory for each control Type, which allow us
        // to instantiate the builders very efficiently, compared to calling
        // GetCustomAttributes and Activator.CreateInstance on every call.
        private static FactoryGenerator s_controlBuilderFactoryGenerator;
#endif // DONTUSEFACTORYGENERATOR
        private static Hashtable s_controlBuilderFactoryCache;

        private static ControlBuilder CreateBuilderFromType(Type type) {
            // Create the factory generator on demand
            if (s_controlBuilderFactoryCache == null) {
#if !DONTUSEFACTORYGENERATOR
                s_controlBuilderFactoryGenerator = new FactoryGenerator();
#endif // DONTUSEFACTORYGENERATOR

                // Create the factory cache
                s_controlBuilderFactoryCache = Hashtable.Synchronized(new Hashtable());

                // Seed the cache with a few types that we don't want to expose as public (they
                // need to be public for FactoryGenerator to be used).
                s_controlBuilderFactoryCache[typeof(Content)] = new ContentBuilderInternalFactory();
                s_controlBuilderFactoryCache[typeof(ContentPlaceHolder)] = new ContentPlaceHolderBuilderFactory();
            }

            // First, check if it's cached
            IWebObjectFactory factory = (IWebObjectFactory)s_controlBuilderFactoryCache[type];

            if (factory == null) {
                // Check whether the control's class exposes a custom builder type
                ControlBuilderAttribute cba = GetControlBuilderAttribute(type);

                if (cba != null) {
                    // Make sure the type has the correct base class (ASURT 123677)
                    Util.CheckAssignableType(typeof(ControlBuilder), cba.BuilderType);
#if !DONTUSEFACTORYGENERATOR
                    if (cba.BuilderType.IsPublic) {
                        // If the builder type is public, codegen a fast factory for it
                        factory = s_controlBuilderFactoryGenerator.CreateFactory(cba.BuilderType);
                    }
                    else {
                        Debug.Assert(false, "The type " + cba.BuilderType.Name + " should be made public for better performance.");
#endif // DONTUSEFACTORYGENERATOR

                        // It's not public, so we must stick with slower reflection
                        factory = new ReflectionBasedControlBuilderFactory(cba.BuilderType);
#if !DONTUSEFACTORYGENERATOR
                    }
#endif // DONTUSEFACTORYGENERATOR
                }
                else {
                    // use a factory that creates generic builders (i.e. ControlBuilder's)
                    factory = s_defaultControlBuilderFactory;
                }

                // Cache the factory
                s_controlBuilderFactoryCache[type] = factory;
            }

            return (ControlBuilder) factory.CreateInstance();
        }

        private static ControlBuilderAttribute GetControlBuilderAttribute(Type controlType) {
            // Check whether the control's class exposes a custom builder type
            ControlBuilderAttribute cba = null;
            object[] attrs = TargetFrameworkUtil.GetCustomAttributes(controlType, typeof(ControlBuilderAttribute), /*inherit*/ true);

            if ((attrs != null) && (attrs.Length > 0)) {
                Debug.Assert(attrs[0] is ControlBuilderAttribute);
                cba = (ControlBuilderAttribute)attrs[0];
            }

            return cba;
        }

        private ControlBuilder GetChildPropertyBuilder(string tagName, IDictionary attribs, ref Type childType, TemplateParser templateParser, bool defaultProperty) {
            Debug.Assert(FChildrenAsProperties, "ChildrenAsProperties");

            // Parse the device filter if any
            // The child is supposed to be a property, so look for it
            PropertyInfo pInfo = TargetFrameworkUtil.GetProperty(_controlType, tagName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.IgnoreCase);

            if (pInfo == null) {
                throw new HttpException(SR.GetString(SR.Type_doesnt_have_property, _controlType.FullName, tagName));
            }

            // Get its type
            childType = pInfo.PropertyType;

            ControlBuilder builder = null;

            // If it's a collection, return the collection builder
            if (typeof(ICollection).IsAssignableFrom(childType)) {
                // Check whether the prop has an IgnoreUnknownContentAttribute
                IgnoreUnknownContentAttribute attr = (IgnoreUnknownContentAttribute)Attribute.GetCustomAttribute(pInfo, typeof(IgnoreUnknownContentAttribute), true);

                builder = new CollectionBuilder(attr != null /*ignoreUnknownContent*/);
            }
            else if (typeof(ITemplate).IsAssignableFrom(childType)) {
                bool useBindableTemplate = false;
                bool allowMultipleInstances = true;
                object[] containerAttrs = pInfo.GetCustomAttributes(typeof(TemplateContainerAttribute), /*inherits*/ false);

                if ((containerAttrs != null) && (containerAttrs.Length > 0)) {
                    Debug.Assert(containerAttrs[0] is TemplateContainerAttribute);
                    useBindableTemplate = (((TemplateContainerAttribute)containerAttrs[0]).BindingDirection == BindingDirection.TwoWay);
                }

                allowMultipleInstances = Util.IsMultiInstanceTemplateProperty(pInfo);

                if (useBindableTemplate) {  // If it's a bindable template, return the bindable template builder
                    builder = new BindableTemplateBuilder();
                }
                else {  // If it's a template, return the template builder
                    builder = new TemplateBuilder();
                }

                if (builder is TemplateBuilder) {
                    ((TemplateBuilder)builder).AllowMultipleInstances = allowMultipleInstances;
                    // If we're in the designer, set a reference to the designer host
                    // so we can get to a filter resolution service later
                    if (InDesigner) {
                        ((TemplateBuilder)builder).SetDesignerHost(templateParser.DesignerHost);
                    }
                }
            }
            else if (childType == typeof(string)) {
                PersistenceModeAttribute persistenceAttr = (PersistenceModeAttribute)Attribute.GetCustomAttribute(pInfo, typeof(PersistenceModeAttribute), true);

                if (((persistenceAttr == null) || (persistenceAttr.Mode == PersistenceMode.Attribute)) && !defaultProperty) {
                    // If the property is supposed to be declared as an attribute on a control tag, throw if it was declared as an inner property
                    // We don't throw if we are simply building the DefaultPropertyBuilder.
                    throw new HttpException(SR.GetString(SR.ControlBuilder_CannotHaveComplexString, _controlType.FullName, tagName));
                }
                builder = new StringPropertyBuilder();
            }

            if (builder != null) {
                builder.Line = Line;
                builder.VirtualPath = VirtualPath;

                // Initialize the builder
                builder.Init(Parser, (ControlBuilder)this, null, tagName, null, attribs);
                return builder;
            }

            // Otherwise, simply return the builder for the property
            builder = CreateBuilderFromType(Parser, this, childType, tagName, null,
                attribs, Line, PageVirtualPath);
            return builder;
        }


        /// <devdoc>
        /// When overridden, returns the control type of any parsed child controls
        /// </devdoc>
        public virtual Type GetChildControlType(string tagName, IDictionary attribs) {
            return null;
        }

        /// <devdoc>
        /// Convenience method for grabbing the set of property entries that we need to set
        /// on an instance of the object this controlbuilder builds.
        /// </devdoc>
        internal ICollection GetFilteredPropertyEntrySet(ICollection entries) {
            // If we encounter the default value, put it in the table if it doesn't already exist
            // If we encounter the filter value, replace whatevers in the table.
            IDictionary filteredEntries = new HybridDictionary(true);
            IFilterResolutionService filterResolutionService = CurrentFilterResolutionService;

            if (filterResolutionService != null) {
                foreach (PropertyEntry entry in entries) {
                    if (!filteredEntries.Contains(entry.Name)) {
                        String filter = entry.Filter;
                        // empty filter always matches.
                        if (String.IsNullOrEmpty(filter) || filterResolutionService.EvaluateFilter(filter)) {
                            filteredEntries[entry.Name] = entry;
                        }
                    }
                }
            }
            else {
                // If there isn't a filter resolution service, just add anything from the default filter
                foreach (PropertyEntry entry in entries) {
                    if (String.IsNullOrEmpty(entry.Filter)) {
                        filteredEntries[entry.Name] = entry;
                    }
                }
            }

            return filteredEntries.Values;
        }

        // Check if any of the entries have a filter
        private bool HasFilteredEntries(ICollection entries) {
            foreach (PropertyEntry entry in entries) {
                if (entry.Filter.Length > 0)
                    return true;
            }

            // None of the entries are filtered
            return false;
        }

        /// <devdoc>
        /// Return the last sub builder added to this builder
        /// </devdoc>
        internal object GetLastBuilder() {
            if (SubBuilders.Count == 0) {
                return null;
            }

            return SubBuilders[SubBuilders.Count - 1];
        }


        public ObjectPersistData GetObjectPersistData() {
            return new ObjectPersistData(this, Parser.RootBuilder.BuiltObjects);
        }


        /// <devdoc>
        /// Does this control have a body.  e.g. <foo/> doesn't.
        /// </devdoc>
        public virtual bool HasBody() {
            return true;
        }


        public virtual bool HtmlDecodeLiterals() {
            return false;
        }


        /// <devdoc>
        /// @param parser The instance of the parser that is controlling us.
        /// @param tagName The name of the tag to be built.  This is necessary
        ///      to allow a builder to support multiple tag types.
        /// @param attribs IDictionary which holds all the attributes of
        ///      the tag.  It is immutable.
        /// @param type Type of the control that this builder will create.
        /// </devdoc>
        public virtual void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string id, IDictionary attribs) {
#if DEBUG
            Debug.Assert(!_initCalled, "ControlBuilder.Init() should never be called more than once on the same ControlBuilder.");
            _initCalled = true;
#endif
            if (parser != null && parser.ControlBuilderInterceptor != null) {
                parser.ControlBuilderInterceptor.PreControlBuilderInit(this, parser, parentBuilder, type, tagName, id, attribs, AdditionalState);
            }
            ParseTimeData.Parser = parser;
            ParseTimeData.ParentBuilder = parentBuilder;
            if (parser != null) {
                ParseTimeData.IgnoreControlProperties = parser.IgnoreControlProperties;
            }

            _tagName = tagName;
            if (type != null) {
                _controlType = type;
                flags[controlTypeIsControl] = typeof(Control).IsAssignableFrom(_controlType);

                ID = id;

                // Try to get a ParseChildrenAttribute from the object
                ParseChildrenAttribute pca = GetParseChildrenAttribute(type);

                // Is this a builder for an object that implements IParserAccessor?
                if (!typeof(IParserAccessor).IsAssignableFrom(type)) {
                    ParseTimeData.IsNonParserAccessor = true;

                    // Non controls never have children
                    ParseTimeData.ChildrenAsProperties = true;
                }
                else {
                    // Check if the nested tags define properties, as opposed to children
                    if (pca != null) {
                        ParseTimeData.ChildrenAsProperties = pca.ChildrenAsProperties;
                    }
                }

                if (FChildrenAsProperties) {
                    // Check if there is a default property
                    if (pca != null && pca.DefaultProperty.Length != 0) {
                        Type subType = null;

                        // Create a builder for the default prop
                        // Default property is always the default filter
                        ParseTimeData.DefaultPropertyBuilder = CreateChildBuilder(String.Empty, pca.DefaultProperty, null/*attribs*/, parser, null, null /*id*/, Line, VirtualPath, ref subType, true /*defaultProperty*/);
                        Debug.Assert(DefaultPropertyBuilder != null, pca.DefaultProperty);
                    }
                }

                // Check if the object is an HtmlControl
                ParseTimeData.IsHtmlControl = typeof(HtmlControl).IsAssignableFrom(_controlType);

                // Check if the object supports attributes
                ParseTimeData.SupportsAttributes = typeof(IAttributeAccessor).IsAssignableFrom(_controlType);
            }
            else {
                flags[controlTypeIsControl] = false;
            }

            // Process the attributes, if any
            if (attribs != null) {
                // This could be called by anyone, so if it's not the parser that's calling us
                // we have to copy all the attribs values over to a ParsedAttributeCollection
                // in the default filter
                PreprocessAttributes(ConvertDictionaryToParsedAttributeCollection(attribs));
            }

            // Check if the same control with identical skinID is already defined as a control skin.
            // If so, fails now instead of infinite recursion during runtime or designtime rendering.
            // VSWhidbey 531782.
            if (InPageTheme) {
                ControlBuilder builder = ((PageThemeParser)parser).CurrentSkinBuilder;
                if (builder != null && 
                    builder.ControlType == ControlType && 
                    String.Equals(builder.SkinID, SkinID, StringComparison.OrdinalIgnoreCase)) {
                        throw new InvalidOperationException(SR.GetString(SR.Cannot_set_recursive_skin, builder.ControlType.Name));
                }
            }
        }

        // Cache the custom ParseChildrenAttribute for each type to avoid having to call
        // GetCustomAttributes any more than necessary (it's extremely slow)
        private static ParseChildrenAttribute s_markerParseChildrenAttribute = new ParseChildrenAttribute();

        private static Hashtable s_parseChildrenAttributeCache = new Hashtable();

        private static ParseChildrenAttribute GetParseChildrenAttribute(Type controlType) {
            // First, see if we have it cached for this type
            ParseChildrenAttribute pca = (ParseChildrenAttribute)s_parseChildrenAttributeCache[controlType];

            if (pca == null) {
                // Try to get a ParseChildrenAttribute from the type
                object[] attrs = TargetFrameworkUtil.GetCustomAttributes(controlType, typeof(ParseChildrenAttribute), /*inherit*/ true);

                if ((attrs != null) && (attrs.Length > 0)) {
                    Debug.Assert(attrs[0] is ParseChildrenAttribute);
                    pca = (ParseChildrenAttribute)attrs[0];
                }

                // If it doesn't have one, use a default as a marker
                if (pca == null)
                    pca = s_markerParseChildrenAttribute;

                // Cache the ParseChildrenAttribute
                lock (s_parseChildrenAttributeCache.SyncRoot) {
                    s_parseChildrenAttributeCache[controlType] = pca;
                }
            }

            // If it's the marker one, just return null
            if (pca == s_markerParseChildrenAttribute)
                return null;

            return pca;
        }

        private void DoInitObjectOptimizations(object obj) {
            // Cache whether it's an ICollection, since IsAssignableFrom is expensive
            flags[isICollection] = typeof(ICollection).IsAssignableFrom(ControlType);

            // Cache whether it's an IParserAccessor, since IsAssignableFrom is expensive
            flags[isIParserAccessor] = typeof(IParserAccessor).IsAssignableFrom(obj.GetType());
            if (_simplePropertyEntries != null) {
                flags[hasFilteredSimpleProps] = HasFilteredEntries(_simplePropertyEntries);
            }

            if (_complexPropertyEntries != null) {
                flags[hasFilteredComplexProps] = HasFilteredEntries(_complexPropertyEntries);
            }

            if (_templatePropertyEntries != null) {
                flags[hasFilteredTemplateProps] = HasFilteredEntries(_templatePropertyEntries);
            }

            if (_boundPropertyEntries != null) {
                flags[hasFilteredBoundProps] = HasFilteredEntries(_boundPropertyEntries);
            }
        }

        internal virtual object GetThemedObject(object obj) {
            Control control = obj as Control;

            if (control == null) return obj;

            IThemeResolutionService themeService = ThemeResolutionService;

            if (themeService != null) {
                if (!String.IsNullOrEmpty(SkinID)) {
                    control.SkinID = SkinID;
                }

                // Apply the theme builders before we run the regular builders
                ThemeProvider themeProvider = themeService.GetStylesheetThemeProvider();
                SkinBuilder themeBuilder = null;

                if (themeProvider != null) {
                    themeBuilder = themeProvider.GetSkinBuilder(control);
                    if (themeBuilder != null) {
                        try {
                            themeBuilder.SetServiceProvider(ServiceProvider);
                            return themeBuilder.ApplyTheme();
                        } finally {
                            themeBuilder.SetServiceProvider(null);
                        }
                    }
                }
            }

            return control;
        }

        /// <devdoc>
        /// Sets all the properties of a built object corresponding to this ControlBuilder.
        /// This code is only used in the no-compile and designer modes
        /// </devdoc>
        internal virtual void InitObject(object obj) {
            // Can't assert these anymore since we've discarded this information by the time we call this method
            // Debug.Assert(InDesigner || CompilationMode == CompilationMode.Never, "Expected to be in designer mode.");
            // Make sure we initialize the property entries in the right order
            EnsureEntriesSorted();

            // Do some expensive one time pre-computations on demand
            if (!flags[doneInitObjectOptimizations]) {
                DoInitObjectOptimizations(obj);
                flags[doneInitObjectOptimizations] = true;
            }

            Control control = obj as Control;
            if (control != null) {
                if (InDesigner) {
                    control.SetDesignMode();
                }

                if (SkinID != null) {
                    control.SkinID = SkinID;
                }

                // Need to apply stylesheet on the controls in non-compiled pages.
                if (!InDesigner && TemplateControl != null) {
                    control.ApplyStyleSheetSkin(TemplateControl.Page);
                }
            }

            InitSimpleProperties(obj);
            if (flags[isICollection]) {
                InitCollectionsComplexProperties(obj);
            }
            else {
                InitComplexProperties(obj);
            }

            if (InDesigner) {
                if (control != null) {
                    if (Parser.DesignTimeDataBindHandler != null) {
                        control.DataBinding += Parser.DesignTimeDataBindHandler;
                    }

                    // Set a reference to the control builder that created this object
                    control.SetControlBuilder(this);
                }

                Parser.RootBuilder.BuiltObjects[obj] = this;
            }

            InitBoundProperties(obj);

            if (flags[isIParserAccessor]) {
                // Build the children
                BuildChildren(obj);
            }

            InitTemplateProperties(obj);

            if (control != null)
                BindFieldToControl(control);

            // 



        }

        private void InitSimpleProperties(object obj) {
            // Don't do anything if there are no entries
            if (_simplePropertyEntries == null)
                return;

            // If there are no filters in the picture, use the entries as is
            ICollection entries;

            if (flags[hasFilteredSimpleProps])
                entries = GetFilteredPropertyEntrySet(SimplePropertyEntries);
            else
                entries = SimplePropertyEntries;

            // Now that we have the proper set, set all the entries
            foreach (SimplePropertyEntry entry in entries) {
                SetSimpleProperty(entry, obj);
            }
        }

        internal void SetSimpleProperty(SimplePropertyEntry entry, object obj) {
            if (entry.UseSetAttribute) {
                ((IAttributeAccessor)obj).SetAttribute(entry.Name, entry.Value.ToString());
            }
            else {
                try {
                    PropertyMapper.SetMappedPropertyValue(obj, entry.Name, entry.Value, InDesigner);
                }
                catch (Exception e) {
                    throw new HttpException(SR.GetString(SR.Cannot_set_property, entry.PersistedValue, entry.Name), e);
                }
            }
        }

        private void InitCollectionsComplexProperties(object obj) {
            // Don't do anything if there are no entries
            if (_complexPropertyEntries == null)
                return;

            foreach (ComplexPropertyEntry entry in ComplexPropertyEntries) {
                try {
                    ControlBuilder controlBuilder = ((ComplexPropertyEntry)entry).Builder;
                    Debug.Assert(((ComplexPropertyEntry)entry).IsCollectionItem, "The entry should be a collection entry, instead it's a " + entry.GetType());
                    object objValue;

                    Debug.Assert(controlBuilder.ServiceProvider == null);
                    controlBuilder.SetServiceProvider(ServiceProvider);
                    try {
                        objValue = controlBuilder.BuildObject(flags[applyTheme]);
                    } finally {
                        controlBuilder.SetServiceProvider(null);
                    }

                    object[] parameters = new object[1];
                    parameters[0] = objValue;
                    MethodInfo methodInfo = ControlType.GetMethod("Add", BindingFlags.Public | BindingFlags.Instance, null, new Type[] { objValue.GetType() }, null);
                    if (methodInfo == null) {
                        throw new InvalidOperationException(SR.GetString(SR.ControlBuilder_CollectionHasNoAddMethod, TagName));
                    }
                    Util.InvokeMethod(methodInfo, obj, parameters);
                }
                catch (Exception ex) {
                    throw new HttpException(SR.GetString(SR.Cannot_add_value_not_collection, TagName, ex.Message), ex);
                }
            }
        }

        private void InitComplexProperties(object obj) {
            // Don't do anything if there are no entries
            if (_complexPropertyEntries == null)
                return;

            // If there are no filters in the picture, use the entries as is
            ICollection entries;

            if (flags[hasFilteredComplexProps])
                entries = GetFilteredPropertyEntrySet(ComplexPropertyEntries);
            else
                entries = ComplexPropertyEntries;

            foreach (ComplexPropertyEntry entry in entries) {
                if (entry.ReadOnly) {
                    try {
                        object objectValue = FastPropertyAccessor.GetProperty(obj, entry.Name, InDesigner);

                        entry.Builder.SetServiceProvider(ServiceProvider);
                        try {
                            // We must push the theme flag to child complex objects so they are init'd properly
                            
                            // DevDiv Bug 59351
                            // Set applytheme only when necessary.
                            if (entry.Builder.flags[applyTheme] != flags[applyTheme]) {
                                entry.Builder.flags[applyTheme] = flags[applyTheme];
                            }
                            entry.Builder.InitObject(objectValue);
                        }
                        finally {
                            entry.Builder.SetServiceProvider(null);
                        }
                    }
                    catch (Exception e) {
                        throw new HttpException(SR.GetString(SR.Cannot_init, entry.Name, e.Message), e);
                    }
                }
                else {
                    try {
                        ControlBuilder controlBuilder = entry.Builder;

                        Debug.Assert(controlBuilder.ServiceProvider == null);
                        object objectValue = null;
                        controlBuilder.SetServiceProvider(ServiceProvider);
                        try {
                            objectValue = controlBuilder.BuildObject(flags[applyTheme]);
                        }
                        finally {
                            controlBuilder.SetServiceProvider(null);
                        }

                        // Use the FastPropertyAccessor to assign the value
                        FastPropertyAccessor.SetProperty(obj, entry.Name, objectValue, InDesigner);
                    }
                    catch (Exception e) {
                        throw new HttpException(SR.GetString(SR.Cannot_set_property, TagName, entry.Name), e);
                    }
                }
            }
        }

        private void InitBoundProperties(object obj) {
            // Don't do anything if there are no entries
            if (_boundPropertyEntries == null)
                return;

            DataBindingCollection dataBindings = null;
            IAttributeAccessor attributeAccessor = null;

            // If there are no filters in the picture, use the entries as is
            ICollection entries;

            if (flags[hasFilteredBoundProps])
                entries = GetFilteredPropertyEntrySet(BoundPropertyEntries);
            else
                entries = BoundPropertyEntries;

            foreach (BoundPropertyEntry entry in entries) {

                if (entry.TwoWayBound && this is BindableTemplateBuilder) {
                    if (InDesigner) {
                        // Skip two-way entries for BindableTemplateBuilders in designer
                        continue;
                    }
                }

                InitBoundProperty(obj, entry, ref dataBindings, ref attributeAccessor);
            }
        }

        private void InitBoundProperty(object obj, BoundPropertyEntry entry,
            ref DataBindingCollection dataBindings, ref IAttributeAccessor attributeAccessor) {

            string expressionPrefix = entry.ExpressionPrefix == null ? String.Empty : entry.ExpressionPrefix.Trim();
            // If we're in the designer, add the bound properties to the collections
            if (InDesigner) {
                if (String.IsNullOrEmpty(expressionPrefix)) {
                    if (dataBindings == null && obj is IDataBindingsAccessor) {
                        dataBindings = ((IDataBindingsAccessor)obj).DataBindings;
                    }

                    dataBindings.Add(new DataBinding(entry.Name, entry.Type, entry.Expression.Trim()));
                }
                else {
                    if (obj is IExpressionsAccessor) {
                        string expression = entry.Expression == null ? String.Empty : entry.Expression.Trim();
                        ((IExpressionsAccessor)obj).Expressions.Add(new ExpressionBinding(entry.Name, entry.Type, expressionPrefix, expression, entry.Generated, entry.ParsedExpressionData));
                    }
                }
            }
            // If we're in no-compile mode, set the values for expressions that support evaluate
            else {
                if (!String.IsNullOrEmpty(expressionPrefix)) {
                    ExpressionBuilder eb = entry.ExpressionBuilder;
                    Debug.Assert(eb != null, "Did not expect null expression builder");
                    if (eb.SupportsEvaluate) {
                        string name = entry.Name;

                        // DevDiv Bugs 160497: Create the expression context with whatever information we have.
                        // We used to always use the TemplateControl one, but sometimes it's null, so we should
                        // fall back to the VirtualPath one if we can.
                        ExpressionBuilderContext expressionContext;
                        if (TemplateControl != null) {
                            expressionContext = new ExpressionBuilderContext(TemplateControl);
                        }
                        else {
                            expressionContext = new ExpressionBuilderContext(VirtualPath);
                        }
                        object value = eb.EvaluateExpression(obj, entry,
                            entry.ParsedExpressionData, expressionContext);

                        if (entry.UseSetAttribute) {
                            if (attributeAccessor == null) {
                                Debug.Assert(obj is IAttributeAccessor);
                                attributeAccessor = (IAttributeAccessor)obj;
                            }

                            attributeAccessor.SetAttribute(name, value.ToString());
                        }
                        else {
                            try {
                                PropertyMapper.SetMappedPropertyValue(obj, name, value, InDesigner);
                            }
                            catch (Exception e) {
                                throw new HttpException(SR.GetString(SR.Cannot_set_property, entry.ExpressionPrefix + ":" + entry.Expression, name), e);
                            }
                        }
                    }
                    else {
                        Debug.Fail("Got a ExpressionBuilder that does not support Evaluate in a non-compiled page");
                    }
                }
                else {
                    // no-compile Bind property handling
                    ((Control)obj).DataBinding += new EventHandler(DataBindingMethod);
                }
            }
        }

        private void DataBindingMethod(object sender, EventArgs e) {
            /*System.Web.UI.WebControls.DropDownList dataBindingExpressionBuilderTarget;
            dataBindingExpressionBuilderTarget = ((System.Web.UI.WebControls.DropDownList)(sender));
            System.Web.UI.IDataItemContainer Container;
            Container = ((System.Web.UI.IDataItemContainer)(dataBindingExpressionBuilderTarget.BindingContainer));
            if ((this.Page.GetDataItem() != null)) {
                dataBindingExpressionBuilderTarget.SelectedValue = System.Convert.ToString(this.Eval("FavVegetable"));
            }*/

            bool isBindableTemplateBuilder = this is BindableTemplateBuilder;
            bool isTemplateBuilder = this is TemplateBuilder;
            bool firstEntry = true;
            object evalValue;
            Control containerControl = null;

            ICollection entries;

            // If there are no filters in the picture, use the entries as is
            if (!flags[hasFilteredBoundProps]) {
                entries = BoundPropertyEntries;
            }
            else {
                Debug.Assert(ServiceProvider == null);
                Debug.Assert(TemplateControl != null, "TemplateControl should not be null in no-compile pages. We need it for the FilterResolutionService.");

                ServiceContainer container = new ServiceContainer();
                container.AddService(typeof(IFilterResolutionService), TemplateControl);

                try {
                    SetServiceProvider(container);
                    entries = GetFilteredPropertyEntrySet(BoundPropertyEntries);
                }
                finally {
                    SetServiceProvider(null);
                }
            }            
                
            foreach (BoundPropertyEntry entry in entries) {
                // Skip all one-way entries.  No-compile supported only on Bind statements.
                // Skip two-way entries if it's a BindableTemplateBuilder or the two way entry is read only
                if ((entry.TwoWayBound && (isBindableTemplateBuilder || entry.ReadOnlyProperty))
                    || (!entry.TwoWayBound && isTemplateBuilder))
                    continue;

                // We only care about databinding entries here
                if (!entry.IsDataBindingEntry)
                    continue;

                Debug.Assert(!entry.UseSetAttribute, "Two-way binding is not supported on expandos - this should have been prevented in ControlBuilder");

                if (firstEntry) {
                    firstEntry = false;

                    Debug.Assert(entry.ControlType.IsInstanceOfType(sender), "The DataBinding event sender was not of type " + entry.ControlType.Name);
                    if (_bindingContainerDescriptor == null) {
                        _bindingContainerDescriptor = TargetFrameworkUtil.GetProperties(typeof(Control))["BindingContainer"];
                    }
                    object container = _bindingContainerDescriptor.GetValue(sender);
                    containerControl = container as Control;
                    if (containerControl.Page.GetDataItem() == null) {
                        break; // nothing to do if GetDataItem is null
                    }
                }

                evalValue = containerControl.TemplateControl.Eval(entry.FieldName, entry.FormatString);

                string objectModelName;
                MemberInfo memberInfo = PropertyMapper.GetMemberInfo(entry.ControlType, entry.Name, out objectModelName);                        
                // If destination is property:
                //     If destination type is string:
                //         {{target}}.{{targetPropertyName}} = System.Convert.ToString( {{value}} );
                //     Else If destination type is reference type:
                //         {{target}}.{{targetPropertyName}} = ( {{destinationType}} ) {{value}};
                //     Else destination type is value type:
                //         {{target}}.{{targetPropertyName}} = ( {{destinationType}} ) ({value});
                if (entry.Type.IsValueType && evalValue == null) {
                    continue;
                }

                object convertedValue = evalValue;
                if (entry.Type == typeof(string)) {
                    convertedValue = System.Convert.ToString(evalValue, CultureInfo.CurrentCulture);
                }
                else if (evalValue != null && !entry.Type.IsAssignableFrom(evalValue.GetType())) {
                    convertedValue = PropertyConverter.ObjectFromString(entry.Type, memberInfo, System.Convert.ToString(evalValue, CultureInfo.CurrentCulture));
                }

                PropertyMapper.SetMappedPropertyValue(sender, objectModelName, convertedValue, InDesigner);
            }
        }
        
        private void InitTemplateProperties(object obj) {
            // Don't do anything if there are no entries
            if (_templatePropertyEntries == null)
                return;

            object[] parameters = new object[1];

            // If there are no filters in the picture, use the entries as is
            ICollection entries;

            if (flags[hasFilteredTemplateProps])
                entries = GetFilteredPropertyEntrySet(TemplatePropertyEntries);
            else
                entries = TemplatePropertyEntries;

            foreach (TemplatePropertyEntry entry in entries) {
                try {
                    ControlBuilder controlBuilder = ((TemplatePropertyEntry)entry).Builder;

                    Debug.Assert(controlBuilder.ServiceProvider == null);
                    controlBuilder.SetServiceProvider(ServiceProvider);
                    try {
                        parameters[0] = controlBuilder.BuildObject(flags[applyTheme]);
                    }
                    finally {
                        controlBuilder.SetServiceProvider(null);
                    }

                    MethodInfo methodInfo = entry.PropertyInfo.GetSetMethod();

                    Debug.Assert(methodInfo != null);
                    Util.InvokeMethod(methodInfo, obj, parameters);
                }
                catch (Exception e) {
                    throw new HttpException(SR.GetString(SR.Cannot_set_property, TagName, entry.Name), e);
                }
            }
        }

        // If the page has a field which name matches the ID of this control,
        // assign the control to the field.  This matches what we do for compiled
        // pages (VSWhidbey 252411)
        private void BindFieldToControl(Control control) {

            // If we tried before and did not find a field, don't try again
            if (flags[triedFieldToControlBinding] && !flags[hasFieldToControlBinding])
                return;

            flags[triedFieldToControlBinding] = true;

            TemplateControl templateControl = TemplateControl;
            if (templateControl == null)
                return;

            Type templateControlType = TemplateControl.GetType();

            // This logic only needs to be checked once
            if (!flags[hasFieldToControlBinding]) {
                // This doesn't apply to designer scenarios.  It's only for no-compile pages.
                if (InDesigner)
                    return;

                // Nothing to bind if the control doesn't have an ID
                if (control.ID == null)
                    return;

                // If the TemplateControl is a built in class (Page or UserControl),
                // there is no point in looking for fields.
                if (templateControlType.Assembly == typeof(HttpRuntime).Assembly)
                    return;
            }

            // Try to find a field named after the ID in the TemplateControl
            FieldInfo fieldInfo = TargetFrameworkUtil.GetField(templateControl.GetType(), control.ID,
                BindingFlags.IgnoreCase | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);

            // If we couldn't find a field or it doesn't qualify, give up
            if (fieldInfo == null || fieldInfo.IsPrivate || !fieldInfo.FieldType.IsAssignableFrom(control.GetType())) {
                return;
            }

            // Everything is in place, so set the field to the control
            fieldInfo.SetValue(templateControl, control);

            // Remember that it was successful so we know we should try again next time
            flags[hasFieldToControlBinding] = true;
        }


        /// <devdoc>
        /// Returns true is it needs SetTagInnerText() to be called.
        /// </devdoc>
        public virtual bool NeedsTagInnerText() {
            return false;
        }


        /// <devdoc>
        /// This method is used to tell the builder that it's about to be appended to its parent.
        /// </devdoc>
        public virtual void OnAppendToParentBuilder(ControlBuilder parentBuilder) {
            // If we have a default property, add it to ourselves
            if (DefaultPropertyBuilder != null) {
                ControlBuilder defaultPropBuilder = DefaultPropertyBuilder;

                // Need to make it null to avoid infinite recursion
                ParseTimeData.DefaultPropertyBuilder = null;
                AppendSubBuilder(defaultPropBuilder);
            }

            if (!(this is BindableTemplateBuilder)) {
                ControlBuilder currentBuilder = this;

                while (currentBuilder != null && !(currentBuilder is BindableTemplateBuilder)) {
                    currentBuilder = currentBuilder.ParentBuilder;
                }

                if (currentBuilder != null && currentBuilder is BindableTemplateBuilder) {

                    // Add all the TwoWay BoundPropertyEntry's to the BindableTemplateBuilder
                    foreach (BoundPropertyEntry entry in BoundPropertyEntries) {
                        if (entry.TwoWayBound) {
                            ((BindableTemplateBuilder)currentBuilder).AddBoundProperty(entry);
                        }
                    }
                }
            }
        }

        /// <devdoc>
        /// Prepares this ControlBuilder and all of it's subbuilders for
        /// use in no-compile pages (minimizing the memory usage).
        /// This makes the use of all parse-time properties invalid.
        /// </devdoc>
        internal virtual void PrepareNoCompilePageSupport() {
            // Clear out all the flags and cached data from parse time
            flags[parseComplete] = true;
            _parseTimeData = null;

            // Remove any property entry lists that aren't being used
            if ((_eventEntries != null) && (_eventEntries.Count == 0)) {
                _eventEntries = null;
            }

            if ((_simplePropertyEntries != null) && (_simplePropertyEntries.Count == 0)) {
                _simplePropertyEntries = null;
            }

            if (_complexPropertyEntries != null) {
                if (_complexPropertyEntries.Count == 0) {
                    _complexPropertyEntries = null;
                }
                else {
                    foreach (BuilderPropertyEntry entry in _complexPropertyEntries) {
                        if (entry.Builder != null)
                            entry.Builder.PrepareNoCompilePageSupport();
                    }
                }
            }

            if (_templatePropertyEntries != null) {
                if (_templatePropertyEntries.Count == 0) {
                    _templatePropertyEntries = null;
                }
                else {
                    foreach (BuilderPropertyEntry entry in _templatePropertyEntries) {
                        if (entry.Builder != null)
                            entry.Builder.PrepareNoCompilePageSupport();
                    }
                }
            }

            if ((_boundPropertyEntries != null) && (_boundPropertyEntries.Count == 0)) {
                _boundPropertyEntries = null;
            }

            if (_subBuilders != null) {
                if (_subBuilders.Count > 0) {
                    foreach (Object builderObj in _subBuilders) {
                        ControlBuilder builder = builderObj as ControlBuilder;

                        if (builder != null)
                            builder.PrepareNoCompilePageSupport();
                    }
                }
                else {
                    _subBuilders = null;
                }
            }

            // Sort the entry here to make sure we don't run into a race condition if we try to
            // do it later on demand (VSWhidbey 551431)
            EnsureEntriesSorted();
        }

        /// <devdoc>
        /// If the control has a Property which matches the name of the
        /// attribute, create an PropertyEntry for it, that will
        /// be used at BuildControl time.
        /// </devdoc>
        internal void PreprocessAttribute(string filter, string attribname, string attribvalue, bool mainDirectiveMode, int line = 0, int column = 0) {
            Match match;

            // Treat a null value as an empty string
            if (attribvalue == null) {
                attribvalue = String.Empty;
            }

            if ((match = databindRegex.Match(attribvalue, 0)).Success) {

                // Don't process databinding expressions during updatable precomp, because we're only
                // generating the base class, and only need the Type and ID of the controls (VSWhidbey 470549)
                if (BuildManager.PrecompilingForUpdatableDeployment)
                    return;

                Group codeGroup = match.Groups["code"];
                // Use it to calculate the column where the code starts,
                // which improves the debugging experience (VSWhidbey 87172)
                column += codeGroup.Index;

                string code = codeGroup.Value;
                bool encode = match.Groups["encode"].Success;

                bool isParsedBindingStatement = false;
                bool isTwoWayBindingStatement = false;
                bool isBindItemStatement = false;
                if (!InDesigner) {
                    if ((match = bindExpressionRegex.Match(code, 0)).Success) {
                        isParsedBindingStatement = true;
                        isTwoWayBindingStatement = true;
                    }
                    else if ((match = bindItemExpressionRegex.Match(code, 0)).Success) {
                        isParsedBindingStatement = true;
                        isTwoWayBindingStatement = true;
                        isBindItemStatement = true;
                    }
                    // Treat it as a binding statement for skin files so the expression
                    // format will be checked first.
                    else if ((CompilationMode == CompilationMode.Never || InPageTheme) && 
                        (match = evalExpressionRegex.Match(code, 0)).Success) {
                        isParsedBindingStatement = true;
                    }
                }

                // Is it a two-way binding statement or eval in no-compile?
                if (isParsedBindingStatement) {
                    string paramString = match.Groups["params"].Value;

                    if (!isBindItemStatement) {
                        if (!(match = bindParametersRegex.Match(paramString, 0)).Success) {
                            throw new HttpException(SR.GetString(SR.BadlyFormattedBind));
                        }
                    }
                    else if (!(match = bindItemParametersRegex.Match(paramString, 0)).Success) {
                        throw new HttpException(SR.GetString(SR.BadlyFormattedBindItem));
                    }

                    string fieldName = match.Groups["fieldName"].Value;
                    string formatString = String.Empty;
                    Group formatStringGroup = match.Groups["formatString"];

                    if (formatStringGroup != null) {
                        formatString = formatStringGroup.Value;
                    }

                    if (formatString.Length > 0) {
                        if (!(match = formatStringRegex.Match(formatString, 0)).Success) {
                            throw new HttpException(SR.GetString(SR.BadlyFormattedBind));
                        }
                    }

                    // Pass the code expression to AddBoundProperty since the Eval expression needs to be compiled in skin files.
                    // The bind expression needs to call without code
                    if (InPageTheme && !isTwoWayBindingStatement) {
                        AddBoundProperty(filter, attribname, String.Empty, code, null /*expressionBuilder*/, null /*parsedExpressionData*/, String.Empty, String.Empty, false, encode, line, column);
                        return;
                    }

                    AddBoundProperty(filter, attribname, String.Empty, code, null /*expressionBuilder*/, null /*parsedExpressionData*/, fieldName, formatString, isTwoWayBindingStatement, encode, line, column);
                    return;
                }
                else {
                    // First, give the PageParserFilter a chance to handle the databinding
                    if (!Parser.PageParserFilterProcessedDataBindingAttribute(ID, attribname, code)) {
                        // If it's a non compiled page and it's not a Bind or Eval statement, fail
                        Parser.EnsureCodeAllowed();

                        // Get the piece of code and add the property
                        AddBoundProperty(filter, attribname, String.Empty, code, null /*expressionBuilder*/, null /*parsedExpressionData*/, String.Empty, String.Empty, false, encode, line, column);
                    }
                    return;
                }
            }
            else if ((match = expressionBuilderRegex.Match(attribvalue, 0)).Success) {
                if (InPageTheme) {
                    throw new HttpParseException(SR.GetString(SR.ControlBuilder_ExpressionsNotAllowedInThemes));
                }

                // Don't process expression builders during updatable precomp, because we're only
                // generating the base class, and only need the Type and ID of the controls (VSWhidbey 434350)
                if (BuildManager.PrecompilingForUpdatableDeployment)
                    return;
                
                string code = match.Groups["code"].Value.Trim();

                int indexOfColon = code.IndexOf(':');
                if (indexOfColon == -1) {
                    throw new HttpParseException(SR.GetString(SR.InvalidExpressionSyntax, attribvalue));
                }

                string expressionPrefix = code.Substring(0, indexOfColon).Trim();
                string expressionCode = code.Substring(indexOfColon + 1).Trim();
                if (expressionPrefix.Length == 0) {
                    throw new HttpParseException(SR.GetString(SR.MissingExpressionPrefix, attribvalue));
                }
                if (expressionCode.Length == 0) {
                    throw new HttpParseException(SR.GetString(SR.MissingExpressionValue, attribvalue));
                }

                // If it's a non compiled page, fail if the expressiom builder has SupportsEvaluate==false
                ExpressionBuilder expressionBuilder = null;
                if (CompilationMode == CompilationMode.Never) {
                    expressionBuilder = ExpressionBuilder.GetExpressionBuilder(expressionPrefix, Parser.CurrentVirtualPath);
                    if ((expressionBuilder != null) && !expressionBuilder.SupportsEvaluate) {
                        throw new InvalidOperationException(SR.GetString(SR.Cannot_evaluate_expression, expressionPrefix + ":" + expressionCode));
                    }
                }

                AddBoundProperty(filter, attribname, expressionPrefix, expressionCode, expressionBuilder, null /*parsedExpressionData*/, String.Empty, String.Empty, false, encode : false );
                return;
            }

            AddProperty(filter, attribname, attribvalue, mainDirectiveMode);
        }

        /// <devdoc>
        /// Indicates whether this ControlBuilder should allow meta:localize and meta:resourcekey
        /// attributes on the tag. We only allow this for tags that represent controls and tags
        /// that represent collection items.
        /// </devdoc>
        private bool IsValidForImplicitLocalization() {
            if (flags[controlTypeIsControl]) {
                // If this is a control, we can localize
                return true;
            }

            if (ParentBuilder == null) {
                // We must have a parent builder
                return false;
            }

            // If we have a parent builder, check that we are a collection item either through our
            // immediate parent, or our parent's default property builder, which is our effective
            // parent.
            if (ParentBuilder.DefaultPropertyBuilder != null) {
                return typeof(ICollection).IsAssignableFrom(ParentBuilder.DefaultPropertyBuilder.ControlType);
            }
            else {
                return typeof(ICollection).IsAssignableFrom(ParentBuilder.ControlType);
            }
        }

        /// <devdoc>
        /// Process implicit resources if the control has a meta:resourcekey attribute
        /// </devdoc>
        internal void ProcessImplicitResources(ParsedAttributeCollection attribs) {

            // Check if meta:localize="false" was specified.  Always do this since we need it at design-time
            string localize = (string)((IDictionary)attribs)["meta:localize"];
            if (localize != null) {
                // Depending on the control type, don't allow meta:localize (e.g. ITemplate case) (VSWhidbey 276398, 454894)
                if (!IsValidForImplicitLocalization()) {
                    throw new InvalidOperationException(SR.GetString(SR.meta_localize_notallowed, TagName));
                }

                bool parseResult;
                if (!Boolean.TryParse(localize, out parseResult)) {
                    throw new HttpException(SR.GetString(SR.ControlBuilder_InvalidLocalizeValue, localize));
                }
                ParseTimeData.Localize = parseResult;
            }
            else {
                ParseTimeData.Localize = true;
            }

            // Check whether a resource key was specified
            string keyPrefix = (string) ((IDictionary)attribs)["meta:resourcekey"];

            // Remove all meta attributes from the collection (VSWhidbey 230192)
            attribs.ClearFilter("meta");

            if (keyPrefix == null)
                return;

            // Depending on the control type, don't allow meta:reskey (e.g. ITemplate case) (VSWhidbey 276398, 454894)
            if (!IsValidForImplicitLocalization()) {
                throw new InvalidOperationException(SR.GetString(SR.meta_reskey_notallowed, TagName));
            }
            Debug.Assert(_controlType != null, "If we get here then the tag type must be either an ICollection or a Control, so how can it be null?");

            // Restrict resource keys the same way as we restrict ID's (VSWhidbey 256438)
            if (!System.CodeDom.Compiler.CodeGenerator.IsValidLanguageIndependentIdentifier(keyPrefix)) {
                throw new HttpException(SR.GetString(SR.Invalid_resourcekey, keyPrefix));
            }

            if (!ParseTimeData.Localize) {
                // If we have a key prefix (from meta:resourcekey) but we also have
                // meta:localize=false, we throw.
                throw new HttpException(SR.GetString(SR.meta_localize_error));
            }

            ParseTimeData.ResourceKeyPrefix = keyPrefix;

            // Try to get the implicit resources for this specific Page
            IImplicitResourceProvider implicitResourceProvider;
            if (Parser.FInDesigner && Parser.DesignerHost != null) {
                implicitResourceProvider = (IImplicitResourceProvider)Parser.DesignerHost.GetService(typeof(IImplicitResourceProvider));
            }
            else {
                implicitResourceProvider = Parser.GetImplicitResourceProvider();
            }

            // If the Page has resources, get the specific ones for this meta:resourcekey
            ICollection tagResources = null;
            if (implicitResourceProvider != null)
                tagResources = implicitResourceProvider.GetImplicitResourceKeys(keyPrefix);

            if (tagResources != null) {
                // Get the IDesignerHost in case we need it to find ExpressionBuilders
                IDesignerHost host = DesignerHost;

                // Note: this code expect that the "resources" expression builder be
                // registered in config.  If the user removes it, they will get an error.
                ExpressionBuilder resourcesExpressionBuilder = ExpressionBuilder.GetExpressionBuilder("resources", Parser.CurrentVirtualPath, host);
                bool usingStandardResources = typeof(ResourceExpressionBuilder) == resourcesExpressionBuilder.GetType();
                foreach (ImplicitResourceKey entry in tagResources) {

                    // Put together the complete resource key, as would appear in an explicit resource
                    string fullResourceKey = keyPrefix + "." + entry.Property;
                    if (entry.Filter.Length > 0)
                        fullResourceKey = entry.Filter + ':' + fullResourceKey;

                    // Replace '.' with '-', since that's what AddBoundProperty expects
                    string property = entry.Property.Replace('.', '-');

                    object parsedExpressionData = null;
                    string expression;
                    if (usingStandardResources) {
                        // If we're using the standard System.Web.Compilation.ResourceExpressionBuilder
                        // we can optimized the parsed data.
                        parsedExpressionData = ResourceExpressionBuilder.ParseExpression(fullResourceKey);
                        expression = String.Empty;
                    }
                    else {
                        expression = fullResourceKey;
                    }

                    AddBoundProperty(entry.Filter, property, "resources",
                        expression, resourcesExpressionBuilder, parsedExpressionData, true, String.Empty, String.Empty, false, encode:false);
                }
            }
        }

        /// <devdoc>
        /// Preprocess all the attributes at parse time, so that we'll be left
        /// with as little work as possible when we build the control.
        /// </devdoc>
        private void PreprocessAttributes(ParsedAttributeCollection attribs) {

            ProcessImplicitResources(attribs);

            //Since the attribute column values are only used for generating line pragmas at design time for intellisense to work,
            //we populate that only at design time so that runtime memory usage is not affected.
            bool isDesignerMode = BuildManagerHost.InClientBuildManager;
            IDictionary<String, Pair> attributeValuePositions = null;

            if (isDesignerMode) {
                //This dictionary indicates the column values at which the attribute value expressions begin and 
                //that is used for generating line pragmas at design time for intellisense.
                attributeValuePositions = attribs.AttributeValuePositionsDictionary;
            }

            // Preprocess all the attributes
            foreach (FilteredAttributeDictionary filteredAttributes in attribs.GetFilteredAttributeDictionaries()) {
                string filter = filteredAttributes.Filter;

                foreach (DictionaryEntry attribute in filteredAttributes) {
                    string name = attribute.Key.ToString();
                    string value = attribute.Value.ToString();
                    int column = 0; 
                    int line = 0;
                    if (isDesignerMode && attributeValuePositions.ContainsKey(name)) {
                        line = (int)attributeValuePositions[name].First;
                        column = (int)attributeValuePositions[name].Second;
                    }

                    PreprocessAttribute(filter, name, value, false, line, column);
                }
            }
        }

        // 
        public /* internal */ void SetServiceProvider(IServiceProvider serviceProvider) {
            _serviceProvider = serviceProvider;
        }

        internal void EnsureEntriesSorted() {
            // Always perform the sorting only once, even in derived classes, 
            // so as to avoid concurrency issues (DevDiv bugs 203787).
            if (!flags[entriesSorted]) {
                flags[entriesSorted] = true;
                SortEntries();
            }
        }

        internal virtual void SortEntries() {
            // Don't sort the entries in a collection builder
            if (this is CollectionBuilder) {
                return;
            }

            FilteredPropertyEntryComparer comparer = null;

            ProcessAndSortPropertyEntries(_boundPropertyEntries, ref comparer);
            ProcessAndSortPropertyEntries(_complexPropertyEntries, ref comparer);
            ProcessAndSortPropertyEntries(_simplePropertyEntries, ref comparer);
            ProcessAndSortPropertyEntries(_templatePropertyEntries, ref comparer);
        }
        

        internal void ProcessAndSortPropertyEntries(ArrayList propertyEntries, 
            ref FilteredPropertyEntryComparer comparer) {

            if (propertyEntries != null && propertyEntries.Count > 1) {
                HybridDictionary dictionary = new HybridDictionary(propertyEntries.Count, true);
                int index = 0;

                // Determine the order of the entry based on location of the first entry with the same name
                foreach (PropertyEntry entry in propertyEntries) {
                    object o = dictionary[entry.Name];
                    if (o != null) {
                        entry.Order = (int)o;
                    }
                    else {
                        entry.Order = index;
                        dictionary.Add(entry.Name, index++);
                    }
                }

                if (comparer == null) {
                    comparer = new FilteredPropertyEntryComparer(CurrentFilterResolutionService);
                }
                propertyEntries.Sort(comparer);
            }
        }

        /// <devdoc>
        ///
        /// </devdoc>
        internal void SetControlType(Type controlType) {
            _controlType = controlType;
            if (_controlType != null) {
                flags[controlTypeIsControl] = typeof(Control).IsAssignableFrom(_controlType);
            }
            else {
                flags[controlTypeIsControl] = false;
            }
        }

        /// <devdoc>
        /// Set the ControlBuilder that's the parent of this ControlBuilder
        /// </devdoc>
        internal virtual void SetParentBuilder(ControlBuilder parentBuilder) {
            ParseTimeData.ParentBuilder = parentBuilder;
            if ((ParseTimeData.FirstNonThemableProperty != null) && (parentBuilder is FileLevelPageThemeBuilder)) {
                throw new InvalidOperationException(SR.GetString(SR.Property_theme_disabled, ParseTimeData.FirstNonThemableProperty.Name, ControlType.FullName));
            }
        }

        // 
        public string GetResourceKey() {

            // This should only be used in the designer
            Debug.Assert(InDesigner);

            return ParseTimeData.ResourceKeyPrefix;
        }

        // 
        public void SetResourceKey(string resourceKey) {

            // This should only be used in the designer
            Debug.Assert(InDesigner);

            SimplePropertyEntry entry = new SimplePropertyEntry();
            entry.Filter = "meta";
            entry.Name = "resourcekey";
            entry.Value = resourceKey;
            entry.PersistedValue = resourceKey;
            entry.UseSetAttribute = true;
            entry.Type = typeof(string);

            AddEntry(SimplePropertyEntriesInternal, entry);
        }


        /// <devdoc>
        ///  Give the builder the raw inner text of the tag.
        /// </devdoc>
        public virtual void SetTagInnerText(string text) {
        }

        /// <devdoc>
        ///  Give the ControlBuilder a chance to look at and modify the tree
        /// </devdoc>
        public virtual void ProcessGeneratedCode(
            CodeCompileUnit codeCompileUnit,
            CodeTypeDeclaration baseType,
            CodeTypeDeclaration derivedType,
            CodeMemberMethod buildMethod,
            CodeMemberMethod dataBindingMethod) { }

        /// <devdoc>
        /// Make sure the given property with the specified context (using SetAttribute to set the value or a directive property) is persistable
        /// throwing otherwise
        /// </devdoc>
        private void ValidatePersistable(PropertyInfo propInfo, bool usingSetAttribute,
            bool mainDirectiveMode, bool simplePropertyEntry, string filter) {

            // Get the appropriate PropertyDescriptorCollection.  If it's for our own type, just
            // call our PropertyDescriptors property, which caches it.  Otherwise (for sub properties)
            // get it directly without caching (less common case).
            PropertyDescriptorCollection propertyDescriptors;

            // Use the current control type if it derives from propInfo.DeclaringType
            bool useCurrentControlType = propInfo.DeclaringType.IsAssignableFrom(_controlType);

            if (useCurrentControlType) {
                propertyDescriptors = PropertyDescriptors;
            }
            else {
                // See comments below regarding when we check sub-properties for validity.
                propertyDescriptors = TargetFrameworkUtil.GetProperties(propInfo.DeclaringType);
            }

            PropertyDescriptor propDesc = propertyDescriptors[propInfo.Name];

            if (propDesc != null) {
                if (useCurrentControlType) {
                    // These checks are only done for top-level properties (e.g. Text="hello").
                    // We don't do it for sub-properties (e.g. Font-Name="Arial") since it would
                    // break backwards compatibility with v1.1 (where we did not do these checks).

                    // If it's an HtmlControl, check the HtmlControlPersistableAttribute to see if the property is persistable
                    if (IsHtmlControl) {
                        if (propDesc.Attributes.Contains(HtmlControlPersistableAttribute.No)) {
                            throw new HttpException(SR.GetString(SR.Property_Not_Persistable, propDesc.Name));
                        }
                    }
                    // Otherwise, if we're not using the attribute accessor, we're not processing the main directive
                    // check if the property is persistable
                    else if (!usingSetAttribute && !mainDirectiveMode && propDesc.Attributes.Contains(DesignerSerializationVisibilityAttribute.Hidden)) {
                        throw new HttpException(SR.GetString(SR.Property_Not_Persistable, propDesc.Name));
                    }
                }

                // These checks are done for both top-level properties, as well as sub-properties.
                // Backwards compatibility is satisfied since the Filterable() and Themeable()
                // attributes are new in v2.0.

                // Make sure the property is filterable if there is a filter
                if (!FilterableAttribute.IsPropertyFilterable(propDesc) && !String.IsNullOrEmpty(filter)) {
                    throw new InvalidOperationException(SR.GetString(SR.Illegal_Device, propDesc.Name));
                }

                if (InPageTheme && (ParseTimeData.FirstNonThemableProperty == null)) {
                    // For simple properties, don't validate if it's a customAttribute
                    if (!simplePropertyEntry || !usingSetAttribute) {
                        ThemeableAttribute attr = (ThemeableAttribute)propDesc.Attributes[typeof(ThemeableAttribute)];
                        if (attr != null && !attr.Themeable) {
                            if (this.ParentBuilder != null) {
                                if (ParentBuilder is FileLevelPageThemeBuilder) {
                                    throw new InvalidOperationException(SR.GetString(SR.Property_theme_disabled, propDesc.Name, ControlType.FullName));
                                }
                            }
                            else {
                                ParseTimeData.FirstNonThemableProperty = propDesc;
                            }
                        }
                    }
                }
            }
        }

        // Default factory used create base ControlBuilder objects
        private static IWebObjectFactory s_defaultControlBuilderFactory = new DefaultControlBuilderFactory();

        private class DefaultControlBuilderFactory : IWebObjectFactory {
            object IWebObjectFactory.CreateInstance() {
                return new ControlBuilder();
            }
        }

        // Factories used when we cannot generate a fast factory (e.g. because the ControlBuilder
        // type is internal).
        private class ReflectionBasedControlBuilderFactory : IWebObjectFactory {
            private Type _builderType;

            internal ReflectionBasedControlBuilderFactory(Type builderType) {
                _builderType = builderType;
            }

            object IWebObjectFactory.CreateInstance() {
                return (ControlBuilder)HttpRuntime.CreateNonPublicInstance(_builderType);
            }
        }

        /// <devdoc>
        /// Space-saving class used to store variables used only during parse and codegen time.
        /// All these are cleared when the ControlBuilder is used in a no-compile page.
        /// </devdoc>
        private sealed class ControlBuilderParseTimeData {

            // const masks into the BitVector32
            private const int childrenAsProperties = 0x00000001;
            private const int hasAspCode = 0x00000002;
            private const int isHtmlControl = 0x00000004;
            private const int isNonParserAccessor = 0x00000008;
            private const int namingContainerSearched = 0x00000010;
            private const int supportsAttributes = 0x00000020;
            private const int isGeneratedID = 0x00000040;
            private const int localize = 0x00000080;
            private const int ignoreControlProperties = 0x00000100;
            #pragma warning disable 0649
            private SimpleBitVector32 flags;
            #pragma warning restore 0649

            internal bool ChildrenAsProperties {
                get { return flags[childrenAsProperties]; }
                set { flags[childrenAsProperties] = value; }
            }

            internal ControlBuilder DefaultPropertyBuilder;

            internal EventDescriptorCollection EventDescriptors;

            internal string Filter;

            internal bool HasAspCode {
                get { return flags[hasAspCode]; }
                set { flags[hasAspCode] = value; }
            }

            internal bool IsHtmlControl {
                get { return flags[isHtmlControl]; }
                set { flags[isHtmlControl] = value; }
            }

            internal bool IgnoreControlProperties {
                get { return flags[ignoreControlProperties]; }
                set { flags[ignoreControlProperties] = value; }
            }

            internal bool IsNonParserAccessor {
                get { return flags[isNonParserAccessor]; }
                set { flags[isNonParserAccessor] = value; }
            }

            internal bool IsGeneratedID {
                get { return flags[isGeneratedID]; }
                set { flags[isGeneratedID] = value; }
            }

            internal string ID;

            internal int Line;

            internal bool Localize {
                get { return flags[localize]; }
                set { flags[localize] = value; }
            }

            internal bool NamingContainerSearched {
                get { return flags[namingContainerSearched]; }
                set { flags[namingContainerSearched] = value; }
            }

            internal ControlBuilder NamingContainerBuilder;

            internal ControlBuilder ParentBuilder;

            internal TemplateParser Parser;

            internal PropertyDescriptorCollection PropertyDescriptors;

            internal StringSet PropertyEntries;

            internal bool SupportsAttributes {
                get { return flags[supportsAttributes]; }
                set { flags[supportsAttributes] = value; }
            }

            internal VirtualPath VirtualPath;

            internal PropertyDescriptor FirstNonThemableProperty;

            internal string ResourceKeyPrefix;
        }

        internal sealed class FilteredPropertyEntryComparer : IComparer {
            IFilterResolutionService _filterResolutionService;

            public FilteredPropertyEntryComparer(IFilterResolutionService filterResolutionService) {
                _filterResolutionService = filterResolutionService;
            }

            int IComparer.Compare(object o1, object o2) {
                if (o1 == o2) {
                    return 0;
                }

                if (o1 == null) {
                    return 1;
                }

                if (o2 == null) {
                    return -1;
                }

                Debug.Assert(o1 is PropertyEntry);
                Debug.Assert(o2 is PropertyEntry);

                PropertyEntry entry1 = (PropertyEntry)o1;
                PropertyEntry entry2 = (PropertyEntry)o2;

                // Compare the order of the item to make the sorting stable.
                int compareValue = entry1.Order - entry2.Order;

                if (compareValue == 0) {
                    if (_filterResolutionService == null) {
                        if (String.IsNullOrEmpty(entry1.Filter)) {
                            if ((entry2.Filter != null) && (entry2.Filter.Length > 0)) {
                                compareValue = 1;
                            }
                            else {
                                compareValue = 0;
                            }
                        }
                        else {
                            if (String.IsNullOrEmpty(entry2.Filter)) {
                                compareValue = -1;
                            }
                            else {
                                compareValue = 0;
                            }
                        }
                    }
                    else {
                        string filter1 = (entry1.Filter.Length == 0) ? "Default" : entry1.Filter;
                        string filter2 = (entry2.Filter.Length == 0) ? "Default" : entry2.Filter;

                        compareValue = _filterResolutionService.CompareFilters(filter1, filter2);
                    }

                    // Compare the index of the item in the array to make the sorting stable.
                    if (compareValue == 0) {
                        return entry1.Index - entry2.Index;
                    }
                }

                return compareValue;
            }
        }
    }
}