public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string ID, IDictionary attribs)
 {
     this._contentPlaceHolderID = ID;
     if (parser.FInDesigner)
     {
         base.Init(parser, parentBuilder, type, tagName, ID, attribs);
     }
     else
     {
         if (string.IsNullOrEmpty(ID))
         {
             throw new HttpException(System.Web.SR.GetString("Control_Missing_Attribute", new object[] { "ID", type.Name }));
         }
         this._templateName = ID;
         MasterPageParser parser2 = parser as MasterPageParser;
         if (parser2 == null)
         {
             throw new HttpException(System.Web.SR.GetString("ContentPlaceHolder_only_in_master"));
         }
         base.Init(parser, parentBuilder, type, tagName, ID, attribs);
         if (parser2.PlaceHolderList.Contains(this.Name))
         {
             throw new HttpException(System.Web.SR.GetString("ContentPlaceHolder_duplicate_contentPlaceHolderID", new object[] { this.Name }));
         }
         parser2.PlaceHolderList.Add(this.Name);
     }
 }

        public override void Init(TemplateParser parser, ControlBuilder parentBuilder,
                                  Type type, string tagName, string ID, IDictionary attribs) {

            base.Init(parser, parentBuilder, type /*type*/, tagName, ID, attribs);

            SetControlType(typeof(string));
        }

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public override void Init(TemplateParser parser, ControlBuilder parentBuilder,
                                  Type type, string tagName, string ID, IDictionary attribs) {

            base.Init(parser, parentBuilder, type /*type*/, tagName, ID, attribs);

            // 



            PropertyInfo propInfo = TargetFrameworkUtil.GetProperty(parentBuilder.ControlType, 
                tagName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.IgnoreCase);
            SetControlType(propInfo.PropertyType);
            Debug.Assert(ControlType != null, "ControlType != null");

            BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;

            // Look for an "item" property on the collection that takes in an integer index
            // (similar to IList::Item)
            propInfo = TargetFrameworkUtil.GetProperty(ControlType, "Item", bindingFlags, types: new Type[] { typeof(int) });
            if (propInfo == null) {
                // fall-back on finding a non-specific Item property
                // a type with overloaded indexed properties will result in an exception however
                propInfo = TargetFrameworkUtil.GetProperty(ControlType, "Item", bindingFlags);
            }

            // If we got one, use it to determine the type of the items
            if (propInfo != null)
                _itemType = propInfo.PropertyType;
        }

		public RootBuilder (TemplateParser parser)
		{
			foundry = new AspComponentFoundry ();
			line = 1;
			fileName = parser.InputFile;
			Init (parser, null, null, null, null, null);
		}

    // Create a PageParserFilter and initialize it
    internal static PageParserFilter Create(PagesSection pagesConfig, VirtualPath virtualPath, TemplateParser parser) {
        PageParserFilter pageParserFilter = pagesConfig.CreateControlTypeFilter();
        if (pageParserFilter != null)
            pageParserFilter.InitializeInternal(virtualPath, parser);

        return pageParserFilter;
    }

		public override void Init (TemplateParser parser,
					   ControlBuilder parentBuilder,
					   Type type,
					   string tagName,
					   string id,
					   IDictionary attribs) 
		{
			if (attribs == null)
				throw new ParseException (parser.Location, "Error in ObjectTag.");

			attribs.Remove ("runat");
			this.id = attribs ["id"] as string;
			attribs.Remove ("id");
			if (this.id == null || this.id.Trim () == "")
				throw new ParseException (parser.Location, "Object tag must have a valid ID.");

			scope = attribs ["scope"] as string;
			string className = attribs ["class"] as string;
			attribs.Remove ("scope");
			attribs.Remove ("class");
			if (className == null || className.Trim () == "")
				throw new ParseException (parser.Location, "Object tag must have 'class' attribute.");

			this.type = parser.LoadType (className);
			if (this.type == null)
				throw new ParseException (parser.Location, "Type " + className + " not found.");

			if (attribs ["progid"] != null || attribs ["classid"] != null)
				throw new ParseException (parser.Location, "ClassID and ProgID are not supported.");

			if (attribs.Count > 0)
				throw new ParseException (parser.Location, "Unknown attribute");
		}

        public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string id,
		                          IDictionary attribs)
        {
            base.Init(parser, parentBuilder, type, tagName, id, attribs);

            _typeName = (string)attribs["typename"];
        }

        public override void Init(TemplateParser parser, ControlBuilder parentBuilder,
                                  Type type, string tagName, string ID, IDictionary attribs) {

            // Copy the ID so that it will be available when BuildObject is called
            _contentPlaceHolderID = ID;

            if (parser.FInDesigner) {
                // shortcut for designer
                base.Init(parser, parentBuilder, type, tagName, ID, attribs);
                return;
            }

            if (String.IsNullOrEmpty(ID)) {
                throw new HttpException(SR.GetString(SR.Control_Missing_Attribute, "ID", type.Name));
            }

            _templateName = ID;

            MasterPageParser masterPageParser = parser as MasterPageParser;
            if (masterPageParser == null) {
                throw new HttpException(SR.GetString(SR.ContentPlaceHolder_only_in_master));
            }

			base.Init(parser, parentBuilder, type, tagName, ID, attribs);

            if (masterPageParser.PlaceHolderList.Contains(Name))
                throw new HttpException(SR.GetString(SR.ContentPlaceHolder_duplicate_contentPlaceHolderID, Name));

            masterPageParser.PlaceHolderList.Add(Name);
        }

		protected override void OverrideAssemblyPrefix (TemplateParser parser, AssemblyBuilder assemblyBuilder)
		{
			if (parser == null || assemblyBuilder == null)
				return;

			string newPrefix = assemblyBuilder.OutputFilesPrefix + parser.ClassName + ".";
			assemblyBuilder.OutputFilesPrefix = newPrefix;
		}

 public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string ID, IDictionary attribs)
 {
     base.Init(parser, parentBuilder, type, tagName, ID, attribs);
     if ((base.InPageTheme && (base.ParentBuilder != null)) && base.ParentBuilder.IsControlSkin)
     {
         ((PageThemeParser) base.Parser).CurrentSkinBuilder = parentBuilder;
     }
 }

 /// <summary>
 /// This methood is called before a <see cref="System.Web.UI.ControlBuilder"/> for an element in the markup is initialized.
 /// </summary>
 /// <param name="controlBuilder">The control builder which is about to be initialized.</param>
 /// <param name="parser">The <see cref="System.Web.UI.TemplateParser"/> which was used to parse the markup.</param>
 /// <param name="parentBuilder">The parent control builder (typically the builder corresponding to the parent element in the markup).</param>
 /// <param name="type">The type of the control that this builder will create.</param>
 /// <param name="tagName">The name of the tag to be built.</param>
 /// <param name="id">ID of the element in the markup.</param>
 /// <param name="attributes">List of attributes of the element in the markup.</param>
 /// <param name="additionalState">This is an additional state which can be used to store/retrive data within several methods of <see cref="System.Web.Compilation.ControlBuilderInterceptor"/>.
 /// The state is per control builder.</param>
 public virtual void PreControlBuilderInit(ControlBuilder controlBuilder, 
                                           TemplateParser parser, 
                                           ControlBuilder parentBuilder, 
                                           Type type, 
                                           string tagName, 
                                           string id, 
                                           IDictionary attributes,
                                           IDictionary additionalState) { 
 }

		public override void Init (TemplateParser parser,
					  ControlBuilder parentBuilder,
					  Type type,
					  string tagName,
					  string ID,
					  IDictionary attribs)
		{
			throw new NotImplementedException ();
		}

		public override void Init (TemplateParser parser,
					  ControlBuilder parentBuilder,
					  Type type,
					  string tagName,
					  string ID,
					  IDictionary attribs)
		{
			// enough?
			base.Init (parser, parentBuilder, type, tagName, ID, attribs);
		}

 internal BuildResultNoCompileUserControl(Type baseType, TemplateParser parser) : base(baseType, parser)
 {
     UserControlParser parser2 = (UserControlParser) parser;
     OutputCacheParameters outputCacheParameters = parser2.OutputCacheParameters;
     if ((outputCacheParameters != null) && (outputCacheParameters.Duration > 0))
     {
         this._cachingAttribute = new PartialCachingAttribute(outputCacheParameters.Duration, outputCacheParameters.VaryByParam, outputCacheParameters.VaryByControl, outputCacheParameters.VaryByCustom, outputCacheParameters.SqlDependency, parser2.FSharedPartialCaching);
         this._cachingAttribute.ProviderName = parser2.Provider;
     }
 }

 internal CompileLiteralTextParser(TemplateParser parser, 
                                 ControlBuilder parentBuilder, 
                                 String fileName, 
                                 int lineNumber)
 {
     _parser = parser;
     _parentBuilder = parentBuilder;
     _fileName = fileName;
     _lineNumber = lineNumber;
 }

		public override void Init (TemplateParser parser,
					  ControlBuilder parentBuilder,
					  Type type,
					  string tagName,
					  string ID,
					  IDictionary attribs)
		{
			base.Init (parser, parentBuilder, type, tagName, ID, attribs);
			placeHolderID = attribs ["ContentPlaceHolderID"] as string;
		}

        public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string id, System.Collections.IDictionary attribs)
        {
            string dataItemTypeName = attribs["DataItemType"] as string;
            Type dataItemType = typeof(object);
            if (!string.IsNullOrEmpty(dataItemTypeName))
            {
                dataItemType = BuildManager.GetType(dataItemTypeName, true);
            }
            Type repeaterFakeType = new RepeaterFakeType(dataItemType);

            base.Init(parser, parentBuilder, repeaterFakeType, tagName, id, attribs);
        }

 public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string id, IDictionary attribs)
 {
     // Nasty hack to get internal property value.
     TypedGridViewControlBuilder typedGridViewControlBuilder = parentBuilder.GetValue("ParentBuilder") as TypedGridViewControlBuilder;
     Type fakeType = type;
     if (typedGridViewControlBuilder != null)
     {
         Type dataItemType = typedGridViewControlBuilder.DataItemType;
         if (dataItemType != null)
             fakeType = new TypedTemplateFieldFakeType(dataItemType);
     }
     base.Init(parser, parentBuilder, fakeType, tagName, id, attribs);
 }

 public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string ID, IDictionary attribs)
 {
     base.Init(parser, parentBuilder, type, tagName, ID, attribs);
     PropertyInfo info = TargetFrameworkUtil.GetProperty(parentBuilder.ControlType, tagName, BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.IgnoreCase);
     base.SetControlType(info.PropertyType);
     BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.Instance;
     info = TargetFrameworkUtil.GetProperty(base.ControlType, "Item", bindingAttr, null, null, new Type[] { typeof(int) }, null);
     if (info == null)
     {
         info = TargetFrameworkUtil.GetProperty(base.ControlType, "Item", bindingAttr);
     }
     if (info != null)
     {
         this._itemType = info.PropertyType;
     }
 }

		public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string id, IDictionary attribs)
		{
			IDictionary attributes = new Hashtable(attribs.Count);

			foreach(DictionaryEntry entry in attribs)
			{
				var attributeName = (string)entry.Key;

				if(string.Equals(attributeName, "ID", StringComparison.OrdinalIgnoreCase))
				{
					if(string.IsNullOrEmpty(id))
						id = (string)entry.Value;

					if(Environment.OSVersion.Platform == PlatformID.Unix ||
					   Environment.OSVersion.Platform == PlatformID.MacOSX)
					{
						attributes["$ID"] = id;
						continue;
					}
				}

				var property = type.GetProperty(attributeName, (BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase));

				if(property != null && property.IsDefined(typeof(BindableAttribute), true))
				{
					var attribute = Attribute.GetCustomAttribute(property, typeof(PropertyMetadataAttribute), true);

					if(attribute != null)
					{
						if(((PropertyMetadataAttribute)attribute).Bindable)
							attributeName = "$" + attributeName;
					}
					else
					{
						attribute = Attribute.GetCustomAttribute(property, typeof(BindableAttribute), true);

						if(attribute != null && ((BindableAttribute)attribute).Bindable)
							attributeName = "$" + attributeName;
					}
				}

				attributes[attributeName] = entry.Value;
			}

			base.Init(parser, parentBuilder, type, tagName, id, attributes);
		}