[bcl] Updates referencesource to 4.7.1

[mono-project.git] / mcs / class / referencesource / System.Configuration / System / Configuration / MgmtConfigurationRecord.cs

//------------------------------------------------------------------------------
// <copyright file="MgmtConfigurationRecord.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//------------------------------------------------------------------------------

namespace System.Configuration {
    using System.CodeDom.Compiler;
    using System.Collections;
    using System.Collections.Generic;
    using System.Collections.Specialized;
    using System.Configuration.Internal;
    using System.Globalization;
    using System.IO;
    using System.Reflection;
    using System.Security;
    using System.Security.Permissions;
    using System.Text;
    using System.Xml;
    using System.Runtime.Versioning;

    internal sealed class MgmtConfigurationRecord : BaseConfigurationRecord {
        private const int   DEFAULT_INDENT = 4;
        private const int   MAX_INDENT = 10;

        private Hashtable   _sectionGroups;         // ConfigurationSectionGroups that have been evaluated,
                                                    // which may or may not be defined in this web.config file.
                                                    // config key -> ConfigurationSectionGroup

        private Hashtable   _sectionFactories;      // All inherited section declarations
                                                    // configKey -> FactoryId

        private Hashtable   _sectionGroupFactories; // All inherited section group declarations
                                                    // configKey -> FactoryId

        private Hashtable   _removedSections;       // Sections that have been removed with ConfigurationSectionCollection.Remove()
                                                    // configKey -> configKey

        private Hashtable   _removedSectionGroups;  // Section groups that have been removed with ConfigurationSectionCollection.Remove()
                                                    // configKey -> configKey

        private Hashtable   _locationTags;          // List of all location tags encountered, even if empty
                                                    // locationSubPath -> locationSubPath

        private HybridDictionary _streamInfoUpdates; // List of StreamInfo, including the main config file, the configSource this record uses, and
                                                    // new configSource stream added thru API


        static internal MgmtConfigurationRecord Create(
                IInternalConfigRoot         configRoot,
                IInternalConfigRecord       parent,
                string                      configPath,
                string                      locationSubPath) {

            MgmtConfigurationRecord configRecord = new MgmtConfigurationRecord();
            configRecord.Init(configRoot, parent, configPath, locationSubPath);
            return configRecord;
        }

        // don't allow instantiation except by Create
        private MgmtConfigurationRecord() {
        }

        private void Init(
                IInternalConfigRoot         configRoot,
                IInternalConfigRecord       parent,
                string                      configPath,
                string                      locationSubPath) {

            base.Init(configRoot, (BaseConfigurationRecord) parent, configPath, locationSubPath);

            if (    IsLocationConfig &&
                    (MgmtParent._locationTags == null || !MgmtParent._locationTags.Contains(_locationSubPath))) {

                // By instantiating a "new" LocationSubPath class, we have implicitly
                // asked for one to be created
                _flags[ForceLocationWritten] = true;
            }

            // Copy all stream information so that we can model changes to ConfigSource
            InitStreamInfoUpdates();
        }

        private void InitStreamInfoUpdates() {
            _streamInfoUpdates = new HybridDictionary(true);
            if (ConfigStreamInfo.HasStreamInfos) {
                foreach (StreamInfo streamInfo in ConfigStreamInfo.StreamInfos.Values) {
                    _streamInfoUpdates.Add(streamInfo.StreamName, streamInfo.Clone());
                }
            }
        }

        // The parent config record cast to this type
        private MgmtConfigurationRecord MgmtParent {
            get {
                return(MgmtConfigurationRecord) _parent;
            }
        }

        // The IInternalConfigHost cast to UpdateConfigHost.
        private UpdateConfigHost UpdateConfigHost {
            get {
                return (UpdateConfigHost) Host;
            }
        }

        // Class flags
        static readonly SimpleBitVector32 MgmtClassFlags = new SimpleBitVector32(
                     ClassSupportsKeepInputs
                   | ClassIgnoreLocalErrors);

        override protected SimpleBitVector32 ClassFlags {
            get {
                return MgmtClassFlags;
            }
        }

        //
        // Create the factory object that is used to create new instances of a ConfigurationSection.
        // Our factory is a ConstructorInfo that creates the section.
        //
        override protected object CreateSectionFactory(FactoryRecord factoryRecord) {

            // Get the type of the factory
            Type type = TypeUtil.GetTypeWithReflectionPermission(Host, factoryRecord.FactoryTypeName, true);

            //
            // If the type is not a ConfigurationSection, use the DefaultSection if the type
            // implements IConfigurationSectionHandler.
            //
            if (!typeof(ConfigurationSection).IsAssignableFrom(type)) {
                TypeUtil.VerifyAssignableType(typeof(IConfigurationSectionHandler), type, true);
                type = typeof(DefaultSection);
            }

            ConstructorInfo ctor = TypeUtil.GetConstructorWithReflectionPermission(type, typeof(ConfigurationSection), true);

            return ctor;
        }

        //
        // Create the ConfigurationSection.
        //
        override protected object CreateSection(bool inputIsTrusted, FactoryRecord factoryRecord, SectionRecord sectionRecord, SectionInput sectionInput, object parentConfig, ConfigXmlReader reader) {
            // Create an instance of the ConfigurationSection
            ConstructorInfo ctor = (ConstructorInfo) factoryRecord.Factory;
            ConfigurationSection configSection = (ConfigurationSection) TypeUtil.InvokeCtorWithReflectionPermission(ctor);

            // Attach the ConfigurationSection to this record
            configSection.SectionInformation.AttachToConfigurationRecord(this, factoryRecord, sectionRecord);
            configSection.CallInit();

            // Initialize the ConfigurationSection with XML or just its parent.
            ConfigurationSection parentConfigSection = (ConfigurationSection) parentConfig;
            configSection.Reset(parentConfigSection);
            if (reader != null) {
                configSection.DeserializeSection(reader);
            }

            if (sectionInput != null && sectionInput.ConfigBuilder != null) {
                configSection = CallHostProcessConfigurationSection(configSection, sectionInput.ConfigBuilder);
            }

            // Clear the modified bit.
            configSection.ResetModified();

            return configSection;
        }

        //
        // Create the type used to create new instances of a ConfigurationSectionGroup.
        // Our factory is a ConstructorInfo that creates the section group.
        //
        private ConstructorInfo CreateSectionGroupFactory(FactoryRecord factoryRecord) {
            Type type;

            if (String.IsNullOrEmpty(factoryRecord.FactoryTypeName)) {
                type = typeof(ConfigurationSectionGroup);
            }
            else {
                type = TypeUtil.GetTypeWithReflectionPermission(Host, factoryRecord.FactoryTypeName, true);
            }

            ConstructorInfo ctor = TypeUtil.GetConstructorWithReflectionPermission(type, typeof(ConfigurationSectionGroup), true);

            return ctor;
        }

        //
        // Ensure the existence of a section group factory, and return it.
        //
        private ConstructorInfo EnsureSectionGroupFactory(FactoryRecord factoryRecord) {
            ConstructorInfo factory = (ConstructorInfo) factoryRecord.Factory;
            if (factory == null) {
                factory = CreateSectionGroupFactory(factoryRecord);
                factoryRecord.Factory = factory;
            }

            return factory;
        }


        //
        // Create a new ConfigurationSection with the same values as the parent.
        // We must use a different instance than the parent, as the parent is cached
        // by the config system and the child ConfigurationSection may change due to
        // user interaction.
        //
        override protected object UseParentResult(string configKey, object parentResult, SectionRecord sectionRecord) {
            FactoryRecord factoryRecord = FindFactoryRecord(configKey, false);
            if (factoryRecord == null) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_unrecognized_configuration_section, configKey));
            }

            object result = CallCreateSection(false, factoryRecord, sectionRecord, null, parentResult, null);
            return result;
        }

        //
        // There is no runtime object at designtime - always return the result.
        //
        override protected object GetRuntimeObject(object result) {
            return result;
        }

        //
        // Return the section result cast to a ConfigurationSection,
        // or null if the section does not exist or has not been evaluated.
        //
        private ConfigurationSection GetConfigSection(string configKey) {
            SectionRecord sectionRecord = GetSectionRecord(configKey, false);
            if (sectionRecord != null && sectionRecord.HasResult) {
                return (ConfigurationSection) sectionRecord.Result;
            }
            else {
                return null;
            }
        }

        //
        // Return the collection of ConfigurationSectionGroups.
        //
        private Hashtable SectionGroups {
            get {
                if (_sectionGroups == null) {
                    _sectionGroups = new Hashtable();
                }

                return _sectionGroups;
            }
        }

        //
        // Return the collection of removed sections.
        //
        private Hashtable RemovedSections {
            get {
                if (_removedSections == null) {
                    _removedSections = new Hashtable();
                }

                return _removedSections;
            }
        }

        //
        // Return the collection of removed section groups.
        //
        private Hashtable RemovedSectionGroups {
            get {
                if (_removedSectionGroups == null) {
                    _removedSectionGroups = new Hashtable();
                }

                return _removedSectionGroups;
            }
        }

        //
        // Lookup a section group. Return null if it doesn't exist or hasn't been evaluated.
        //
        internal ConfigurationSectionGroup LookupSectionGroup(string configKey) {
            ConfigurationSectionGroup configSectionGroup = null;
            if (_sectionGroups != null) {
                configSectionGroup = (ConfigurationSectionGroup) _sectionGroups[configKey];
            }

            return configSectionGroup;
        }

        // Returns the ConfigurationSectionGroup of the configKey.
        // The ConfigurationSectionGroup is created if it doesn't exist.
        // This method only returns null if a FactoryRecord does not exist for the
        // desired configKey.
        internal ConfigurationSectionGroup GetSectionGroup(string configKey) {
            ConfigurationSectionGroup configSectionGroup = LookupSectionGroup(configKey);
            if (configSectionGroup == null) {
                BaseConfigurationRecord configRecord;
                FactoryRecord factoryRecord = FindFactoryRecord(configKey, false, out configRecord);
                if (factoryRecord == null) {
                    return null;
                }

                if (!factoryRecord.IsGroup) {
                    throw ExceptionUtil.ParameterInvalid("sectionGroupName");
                }

                if (factoryRecord.FactoryTypeName == null) {
                    //
                    // If no type is defined for the section group, return a base ConfigurationSectionGroup.
                    // For example:
                    //  <configSections>
                    //      <sectionGroup name="mySectionGroup" />
                    //  </configSections>
                    //
                    configSectionGroup = new ConfigurationSectionGroup();
                }
                else {
                    //
                    // Create the section group of the desired type.
                    // For example:
                    //  <configSections>
                    //      <sectionGroup name="mySectionGroup" type="MySectionGroupType, acme" />
                    //  </configSections>
                    //
                    ConstructorInfo ctor = EnsureSectionGroupFactory(factoryRecord);

                    try {
                        configSectionGroup = (ConfigurationSectionGroup) TypeUtil.InvokeCtorWithReflectionPermission(ctor);
                    }
                    catch (Exception e) {
                        throw new ConfigurationErrorsException(SR.GetString(SR.Config_exception_creating_section_handler, factoryRecord.ConfigKey),
                                e, factoryRecord);
                    }
                }

                configSectionGroup.AttachToConfigurationRecord(this, factoryRecord);

                // Add it to the collection
                SectionGroups[configKey] = configSectionGroup;
            }

            return configSectionGroup;
        }

        //
        // Create a collection of all location tags encountered in the file.
        //
        internal ConfigurationLocationCollection GetLocationCollection(Configuration config) {
            ArrayList locations = new ArrayList();

            // Now add the other empty location sections we recorded
            if (_locationTags != null) {
                foreach (string subPath in _locationTags.Values) {
                    locations.Add(new ConfigurationLocation(config, subPath));
                }
            }

            return new ConfigurationLocationCollection(locations);
        }

        //
        // AddLocation
        //
        // Record all location tags in the config file, even if they are empty.
        //
        protected override void AddLocation(string locationSubPath) {
            if (_locationTags == null) {
                _locationTags = new Hashtable(StringComparer.OrdinalIgnoreCase);
            }

            _locationTags[locationSubPath] = locationSubPath;
        }

        //
        // Collection of all section factories, both in this file and inherited.
        //
        internal Hashtable SectionFactories {
            get {
                if (_sectionFactories == null) {
                    _sectionFactories = GetAllFactories(false);
                }

                return _sectionFactories;
            }
        }

        //
        // Collection of all section groups, both in this file and inherited.
        //
        internal Hashtable SectionGroupFactories {
            get {
                if (_sectionGroupFactories == null) {
                    _sectionGroupFactories = GetAllFactories(true);
                }

                return _sectionGroupFactories;
            }
        }

        //
        // Get all the factories available, both in this file and inherited.
        //
        private Hashtable GetAllFactories(bool isGroup) {
            Hashtable   factories = new Hashtable();

            MgmtConfigurationRecord configRecord = this;
            do {
                if (configRecord._factoryRecords != null) {
                    foreach (FactoryRecord factoryRecord in configRecord._factoryRecords.Values) {
                        if (factoryRecord.IsGroup == isGroup) {
                            string configKey = factoryRecord.ConfigKey;
                            factories[configKey] = new FactoryId(factoryRecord.ConfigKey, factoryRecord.Group, factoryRecord.Name);
                        }
                    }
                }

                configRecord = configRecord.MgmtParent;
            } while (!configRecord.IsRootConfig);

            return factories;
        }

        internal ConfigurationSection FindImmediateParentSection(ConfigurationSection section) {
            ConfigurationSection result = null;

            string configKey = section.SectionInformation.SectionName;
            SectionRecord sectionRecord = GetSectionRecord(configKey, false);
            if (sectionRecord.HasLocationInputs) {
                SectionInput input = sectionRecord.LastLocationInput;
                Debug.Assert(input.HasResult, "input.HasResult");
                result = (ConfigurationSection) input.Result;
            }
            else if (sectionRecord.HasIndirectLocationInputs) {
                Debug.Assert(IsLocationConfig, "Indirect location inputs exist only in location config record");
                SectionInput input = sectionRecord.LastIndirectLocationInput;
                Debug.Assert(input != null);
                Debug.Assert(input.HasResult, "input.HasResult");
                result = (ConfigurationSection) input.Result;
            }
            else if (IsRootDeclaration(configKey, true)) {
                FactoryRecord factoryRecord = GetFactoryRecord(configKey, false);

                object resultObject;
                object resultRuntimeObject;
                CreateSectionDefault(configKey, false, factoryRecord, null, out resultObject, out resultRuntimeObject);
                result = (ConfigurationSection) resultObject;
            }
            else {
                MgmtConfigurationRecord current = this.MgmtParent;
                while (!current.IsRootConfig) {
                    sectionRecord = current.GetSectionRecord(configKey, false);
                    if (sectionRecord != null && sectionRecord.HasResult) {
                        result = (ConfigurationSection) sectionRecord.Result;
                        break;
                    }

                    current = current.MgmtParent;
                }

                Debug.Assert(!current.IsRootConfig, "An immediate parent result should have been found");
            }

            if (!result.IsReadOnly()) {
                result.SetReadOnly();
            }

            return result;
        }

        //
        // Get the immediate parent configuration section, and clone it.
        //
        internal ConfigurationSection FindAndCloneImmediateParentSection(ConfigurationSection configSection) {
            string configKey = configSection.SectionInformation.ConfigKey;
            ConfigurationSection parentSection = FindImmediateParentSection(configSection);
            SectionRecord sectionRecord = GetSectionRecord(configKey, false);
            ConfigurationSection clone = (ConfigurationSection) UseParentResult(configKey, parentSection, sectionRecord);
            return clone;
        }

        //
        // Revert the ConfigurationSection to the value of its parent.
        //
        internal void RevertToParent(ConfigurationSection configSection) {

            // Remove any RawXml set by ConfigurationSection.SetRawXml
            configSection.SectionInformation.RawXml = null;

            try {
                // Reset to parent value
                ConfigurationSection parentConfigSection = FindImmediateParentSection(configSection);
                configSection.Reset(parentConfigSection);

                // Consider it to be unmodified
                configSection.ResetModified();
            }
            catch (Exception e) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_exception_in_config_section_handler, configSection.SectionInformation.SectionName),
                        e, ConfigStreamInfo.StreamName, 0);
            }

            // Record that the section is to be removed.
            configSection.SectionInformation.Removed = true;
        }

        //
        // Return the outer XML of a section as a string.
        // Return null if the section does not exist in the file.
        //
        internal string GetRawXml(string configKey) {
            // Get the section record created during Init
            SectionRecord sectionRecord = GetSectionRecord(configKey, false);
            if (sectionRecord == null || !sectionRecord.HasFileInput) {
                return null;
            }

            // The section exists, so find and return its RawXml.
            string [] keys = configKey.Split(ConfigPathSeparatorParams);
            ConfigXmlReader reader = GetSectionXmlReader(keys, sectionRecord.FileInput);

            return reader.RawXml;
        }

        //
        // Update the section with the XML provided.
        //
        // This method will throw out any changes made to the section up to this point.
        //
        // If xmlElement is null or empty, it is equivalent to calling RevertToParent
        //
        internal void SetRawXml(ConfigurationSection configSection, string xmlElement) {

            // Null or empty is equivalent to RevertToParent().
            if (string.IsNullOrEmpty(xmlElement)) {
                RevertToParent(configSection);
                return;
            }

            ValidateSectionXml(xmlElement, configSection.SectionInformation.Name);

            // Reset the ConfigurationSection with the XML.
            ConfigurationSection parentConfigSection = FindImmediateParentSection(configSection);
            ConfigXmlReader reader = new ConfigXmlReader(xmlElement, null, 0);

            // Store the raw XML.
            configSection.SectionInformation.RawXml = xmlElement;

            // Update the section with the xml
            try {
                try {
                    bool wasPresent = configSection.ElementPresent;
                    PropertySourceInfo saveInfo = configSection.ElementInformation.PropertyInfoInternal();

                    configSection.Reset(parentConfigSection);
                    configSection.DeserializeSection(reader);
                    configSection.ResetModified();

                    configSection.ElementPresent = wasPresent;
                    configSection.ElementInformation.ChangeSourceAndLineNumber(saveInfo);
                }
                catch {
                    configSection.SectionInformation.RawXml = null;
                    throw;
                }
            }
            catch (Exception e) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_exception_in_config_section_handler, configSection.SectionInformation.SectionName),
                        e, null, 0);
            }

            // Ignore previous attempts to remove the section.
            configSection.SectionInformation.Removed = false;
        }

        //
        // Return true if a stream is being used by a configSource directive in other input.
        //
        private bool IsStreamUsed(string oldStreamName) {
            MgmtConfigurationRecord current = this;
            if (IsLocationConfig) {
                //
                // For a location configuration, the input we need to check
                // are the section records and location sections in the file,
                // which are available in the parent record.
                //
                current = MgmtParent;

                //
                // Check whether a file section is using the configsource directive.
                //
                if (current._sectionRecords != null) {
                    foreach (SectionRecord sectionRecord in current._sectionRecords.Values) {
                        if (    sectionRecord.HasFileInput &&
                                StringUtil.EqualsIgnoreCase(sectionRecord.FileInput.SectionXmlInfo.ConfigSourceStreamName, oldStreamName)) {
                            return true;
                        }
                    }
                }
            }

            //
            // Check whether a location is using the configsource directive.
            //
            if (current._locationSections != null) {
                foreach (LocationSectionRecord locationSectionRecord in current._locationSections) {
                    if (StringUtil.EqualsIgnoreCase(locationSectionRecord.SectionXmlInfo.ConfigSourceStreamName, oldStreamName)) {
                        return true;
                    }
                }
            }

            return false;
        }

        //
        // Set the configSource attribute on a ConfigurationSection
        //
        internal void ChangeConfigSource(
                SectionInformation sectionInformation,
                string oldConfigSource,
                string oldConfigSourceStreamName,
                string newConfigSource) {

            if (String.IsNullOrEmpty(oldConfigSource)) {
                oldConfigSource = null;
            }

            if (String.IsNullOrEmpty(newConfigSource)) {
                newConfigSource = null;
            }

            // Check if there is a change to config source
            if (StringUtil.EqualsIgnoreCase(oldConfigSource, newConfigSource))
                return;

            if (String.IsNullOrEmpty(ConfigStreamInfo.StreamName)) {
                throw new ConfigurationErrorsException(SR.GetString(SR.Config_source_requires_file));
            }

            string newConfigSourceStreamName = null;
            if (newConfigSource != null) {
                newConfigSourceStreamName = Host.GetStreamNameForConfigSource(ConfigStreamInfo.StreamName, newConfigSource);
            }

            // Add the stream to the updates
            if (newConfigSourceStreamName != null) {
                //
                // Ensure that no parent is using the same config source stream
                //
                ValidateUniqueChildConfigSource(sectionInformation.ConfigKey, newConfigSourceStreamName, newConfigSource, null);

                StreamInfo streamInfo = (StreamInfo) _streamInfoUpdates[newConfigSourceStreamName];
                if (streamInfo != null) {
                    //
                    // Detect if another section in this file is using the same configSource
                    // with has a different section name.
                    //
                    if (streamInfo.SectionName != sectionInformation.ConfigKey) {
                        throw new ConfigurationErrorsException(
                            SR.GetString(SR.Config_source_cannot_be_shared, newConfigSource));
                    }
                }
                else {
                    //
                    // Add stream to updates
                    //
                    streamInfo = new StreamInfo(sectionInformation.ConfigKey, newConfigSource, newConfigSourceStreamName);
                    _streamInfoUpdates.Add(newConfigSourceStreamName, streamInfo);
                }
            }

            // remove old streamname if no longer referenced
            if (oldConfigSourceStreamName != null && !IsStreamUsed(oldConfigSourceStreamName)) {
                _streamInfoUpdates.Remove(oldConfigSourceStreamName);
            }

            // update the configSourceStreamName
            sectionInformation.ConfigSourceStreamName = newConfigSourceStreamName;
        }

        //
        // Verify that the string is valid xml, begins with the expected section name,
        // and contains no more or less than a single element.
        //
        // Throws a ConfigurationErrorsException if there is an error.
        //
        private void ValidateSectionXml(string xmlElement, string configKey) {
            if (string.IsNullOrEmpty(xmlElement))
                return;

            XmlTextReader reader = null;
            try {
                XmlParserContext context = new XmlParserContext(null, null, null, XmlSpace.Default, Encoding.Unicode);
                reader = new XmlTextReader(xmlElement, XmlNodeType.Element, context);

                // Verify that the it is an element
                reader.Read();
                if (reader.NodeType != XmlNodeType.Element) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_unexpected_node_type, reader.NodeType));
                }

                // Verify the name of the element is a section
                string group, name;
                SplitConfigKey(configKey, out group, out name);
                if (reader.Name != name) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_unexpected_element_name, reader.Name));
                }

                for (;;) {
                    if (!reader.Read()) {
                        // ensure there is a matching end element
                        if (reader.Depth != 0) {
                            throw new ConfigurationErrorsException(SR.GetString(SR.Config_unexpected_element_end),reader);
                        }

                        break;
                    }

                    switch (reader.NodeType) {
                        // disallowed node types within a section
                        case XmlNodeType.XmlDeclaration:
                        case XmlNodeType.DocumentType:
                            throw new ConfigurationErrorsException(SR.GetString(SR.Config_invalid_node_type),reader);

                        default:
                            break;
                    }


                    // don't allow XML after the end element
                    if (reader.Depth <= 0 && reader.NodeType != XmlNodeType.EndElement) {
                        throw new ConfigurationErrorsException(SR.GetString(SR.Config_more_data_than_expected),reader);
                    }
                }
            }
            finally {
                if (reader != null) {
                    reader.Close();
                }
            }
        }

        //
        // Add a new configuration section to this config file.
        // This adds both the section declaration and definition to the config file.
        //
        // Called from ConfigurationSectionCollection.Add().
        // Note this method DOES NOT update the associated ConfigurationSectionCollection.
        //
        internal void AddConfigurationSection(string group, string name, ConfigurationSection configSection) {

            // <configSections> is not permitted within a <location> tag.
            if (IsLocationConfig) {
                throw new InvalidOperationException(SR.GetString(SR.Config_add_configurationsection_in_location_config));
            }

            VerifySectionName(name, null, false);

            if (configSection == null) {
                throw new ArgumentNullException("configSection");
            }

            // Ensure the section is not already part of the configuration hierarchy.
            if (configSection.SectionInformation.Attached) {
                throw new InvalidOperationException(SR.GetString(SR.Config_add_configurationsection_already_added));
            }

            string configKey = BaseConfigurationRecord.CombineConfigKey(group, name);

            // Ensure the section is not already declared.
            FactoryRecord factoryRecord = FindFactoryRecord(configKey, true);
            if (factoryRecord != null) {
                throw new ArgumentException(SR.GetString(SR.Config_add_configurationsection_already_exists));
            }

            // Add the configSource if needed.
            if (!String.IsNullOrEmpty(configSection.SectionInformation.ConfigSource)) {
                ChangeConfigSource(configSection.SectionInformation, null, null, configSection.SectionInformation.ConfigSource);
            }

            // Add to list of all sections.
            if (_sectionFactories != null) {
                _sectionFactories.Add(configKey, new FactoryId(configKey, group, name));
            }

            // Get the type name.
            string typeName = configSection.SectionInformation.Type;
            if (typeName == null) {
                typeName = Host.GetConfigTypeName(configSection.GetType());
            }

            // Add a factory record for the section.
            factoryRecord = new FactoryRecord(configKey,
                    group,
                    name,
                    typeName,
                    configSection.SectionInformation.AllowLocation,
                    configSection.SectionInformation.AllowDefinition,
                    configSection.SectionInformation.AllowExeDefinition,
                    configSection.SectionInformation.OverrideModeDefaultSetting,
                    configSection.SectionInformation.RestartOnExternalChanges,
                    configSection.SectionInformation.RequirePermission,
                    _flags[IsTrusted],
                    false,  // isUndeclared
                    ConfigStreamInfo.StreamName,
                    -1);

            // Construct a factory for the section
            factoryRecord.Factory = TypeUtil.GetConstructorWithReflectionPermission(
                    configSection.GetType(), typeof(ConfigurationSection), true);

            factoryRecord.IsFactoryTrustedWithoutAptca = TypeUtil.IsTypeFromTrustedAssemblyWithoutAptca(configSection.GetType());

            EnsureFactories()[configKey] = factoryRecord;

            // Add a section record for the section.
            // Since we are adding a new definition, it cannot be locked.
            SectionRecord sectionRecord = EnsureSectionRecordUnsafe(configKey, false);
            sectionRecord.Result = configSection;
            sectionRecord.ResultRuntimeObject = configSection;

            // Undo any previous removals of the section.
            if (_removedSections != null) {
                _removedSections.Remove(configKey);
            }

            // Attach the section to the configuration record.
            configSection.SectionInformation.AttachToConfigurationRecord(this, factoryRecord, sectionRecord);

            //
            // If there is rawXml, set it now. Note this will override any other changes to the section
            // definition made after the call to SetXml.
            //
            string rawXml = configSection.SectionInformation.RawXml;
            if (!String.IsNullOrEmpty(rawXml)) {
                configSection.SectionInformation.RawXml = null;
                configSection.SectionInformation.SetRawXml(rawXml);
            }
        }

        //
        // Remove a configuration section from this config file.
        // This removes both the section declaration and definition from the config file.
        // Note, however, that if a parent config file declares the section,
        // a new instance of the section can be retrieved having the value of the
        // immediate parent.
        //
        // Called from ConfigurationSectionCollection.Remove().
        // Note this method DOES NOT update the associated ConfigurationSectionCollection.
        //
        internal void RemoveConfigurationSection(string group, string name) {
            bool sectionIsUsed = false;     // Is section used in our record

            VerifySectionName(name, null, true);

            string configKey = BaseConfigurationRecord.CombineConfigKey(group, name);

            // If it's already removed, don't try to remove it again.
            if (RemovedSections.Contains(configKey)) {
                return;
            }

            // If it's not a registered section, there's nothing to do.
            if (FindFactoryRecord(configKey, true) == null) {
                return;
            }

            // Detach from this record
            ConfigurationSection configSection = GetConfigSection(configKey);
            if (configSection != null) {
                configSection.SectionInformation.DetachFromConfigurationRecord();
            }

            // Remove from list of all sections if this is the root declaration.
            bool isRootDeclaration = IsRootDeclaration(configKey, false);
            if (_sectionFactories != null && isRootDeclaration) {
                _sectionFactories.Remove(configKey);
            }

            // Remove from collection of factory records.
            if (!IsLocationConfig && _factoryRecords != null && _factoryRecords.Contains(configKey)) {
                sectionIsUsed = true;
                _factoryRecords.Remove(configKey);
            }

            // Remove from collection of section records.
            if (_sectionRecords != null && _sectionRecords.Contains(configKey)) {
                sectionIsUsed = true;
                _sectionRecords.Remove(configKey);
            }

            // Remove all location section records for this section in this file.
            if (_locationSections != null) {
                int i = 0;
                while (i < _locationSections.Count) {
                    LocationSectionRecord locationSectionRecord = (LocationSectionRecord) _locationSections[i];
                    if (locationSectionRecord.ConfigKey != configKey) {
                        i++;
                    }
                    else {
                        sectionIsUsed = true;
                        _locationSections.RemoveAt(i);
                    }
                }
            }

            if (sectionIsUsed) {
                // Add to RemovedSections since we need to remove
                // it from the file later.
                RemovedSections.Add(configKey, configKey);
            }

            //
            // Remove all references from configSource
            // Note that we can't remove an item while enumerating it.
            //
            List<string> streamsToRemove = new List<string>();
            foreach (StreamInfo streamInfo in _streamInfoUpdates.Values) {
                if (streamInfo.SectionName == configKey) {
                    streamsToRemove.Add(streamInfo.StreamName);
                }
            }

            foreach (string stream in streamsToRemove) {
                _streamInfoUpdates.Remove(stream);
            }
        }

        //
        // Add a new configuration section group to this config file.
        //
        // Called from ConfigurationSectionGroupCollection.Add().
        // Note this method DOES NOT update the associated ConfigurationSectionGroupCollection.
        //
        internal void AddConfigurationSectionGroup(string group, string name, ConfigurationSectionGroup configSectionGroup) {
            // <location> tags can't have a <configSections> declaration.
            if (IsLocationConfig) {
                throw new InvalidOperationException(SR.GetString(SR.Config_add_configurationsectiongroup_in_location_config));
            }

            // Validate name argument.
            VerifySectionName(name, null, false);

            // Validate configSectionGroup argument.
            if (configSectionGroup == null) {
                throw ExceptionUtil.ParameterInvalid("name");
            }

            // A section group can only belong to one section group collection.
            if (configSectionGroup.Attached) {
                throw new InvalidOperationException(SR.GetString(SR.Config_add_configurationsectiongroup_already_added));
            }

            string configKey = BaseConfigurationRecord.CombineConfigKey(group, name);

            // Do not add if the section group already exists, even if it is of a different type.
            FactoryRecord factoryRecord = FindFactoryRecord(configKey, true);
            if (factoryRecord != null) {
                throw new ArgumentException(SR.GetString(SR.Config_add_configurationsectiongroup_already_exists));
            }

            // Add to list of all section groups.
            if (_sectionGroupFactories != null) {
                _sectionGroupFactories.Add(configKey, new FactoryId(configKey, group, name));
            }

            // Get the type name - if it is not specified explicitly, get it from the type of the object.
            string typeName = configSectionGroup.Type;
            if (typeName == null) {
                typeName = Host.GetConfigTypeName(configSectionGroup.GetType());
            }

            // Create a factory record and add it to the collection of factory records.
            factoryRecord = new FactoryRecord(configKey, group, name, typeName, ConfigStreamInfo.StreamName, -1);
            EnsureFactories()[configKey] = factoryRecord;

            // Add it to list of evaluated configuration section groups.
            SectionGroups[configKey] = configSectionGroup;

            // Remove it from RemovedSectionGroups if it was previously removed.
            if (_removedSectionGroups != null) {
                _removedSectionGroups.Remove(configKey);
            }

            // Attach to the configuration record.
            configSectionGroup.AttachToConfigurationRecord(this, factoryRecord);
        }

        //
        // Return a list of all FactoryRecords of sections that are descendents of
        // a section group.
        //
        private ArrayList GetDescendentSectionFactories(string configKey) {
            ArrayList sectionGroups = new ArrayList();

            string configKeyAncestor;
            if (configKey.Length == 0) {
                configKeyAncestor = string.Empty;
            }
            else {
                configKeyAncestor = configKey + "/";
            }

            foreach (FactoryId factoryId in SectionFactories.Values) {
                if (factoryId.Group == configKey || StringUtil.StartsWith(factoryId.Group, configKeyAncestor)) {
                    sectionGroups.Add(factoryId);
                }
            }

            return sectionGroups;
        }

        //
        // Return a list of all FactoryRecords of section groups that are descendents of
        // a section group, including the section group itself.
        //
        private ArrayList GetDescendentSectionGroupFactories(string configKey) {

            ArrayList sectionGroups = new ArrayList();

            string configKeyAncestor;
            if (configKey.Length == 0) {
                configKeyAncestor = string.Empty;
            }
            else {
                configKeyAncestor = configKey + "/";
            }

            foreach (FactoryId factoryId in SectionGroupFactories.Values) {
                if (factoryId.ConfigKey == configKey || StringUtil.StartsWith(factoryId.ConfigKey, configKeyAncestor)) {
                    sectionGroups.Add(factoryId);
                }
            }

            return sectionGroups;
        }

        //
        // Remove a configuration section group from this config file.
        // This removes both the section group declaration and definition from the config file,
        // along with all descendent groups and sections.
        //
        // Note, however, that if a parent config file declares the section group,
        // a new instance of the section can be retrieved having the value of the
        // immediate parent.
        //
        // Called from ConfigurationSectionGroupCollection.Remove().
        // Note this method DOES NOT update the associated ConfigurationSectionCollection.
        //
        internal void RemoveConfigurationSectionGroup(string group, string name) {
            // Validate arguments
            VerifySectionName(name, null, false);

            string configKey = BaseConfigurationRecord.CombineConfigKey(group, name);

            // If it's not a registered section, there's nothing to do.
            if (FindFactoryRecord(configKey, true) == null) {
                return;
            }

            // Remove all descendent sections.
            ArrayList sections = GetDescendentSectionFactories(configKey);
            foreach (FactoryId descendent in sections) {
                RemoveConfigurationSection(descendent.Group, descendent.Name);
            }

            // Remove all descendent sections groups, including the configKey group.
            ArrayList sectionGroups = GetDescendentSectionGroupFactories(configKey);
            foreach (FactoryId descendent in sectionGroups) {
                //
                // If it's already removed, don't try to remove it again.
                // We don't do this test above the loop for configKey, because
                // the section groups contained within the section group may
                // be changed by the user once added.
                //
                if (RemovedSectionGroups.Contains(descendent.ConfigKey)) {
                    continue;
                }

                // If the section group has been evaluated, detatch it.
                ConfigurationSectionGroup sectionGroup = LookupSectionGroup(descendent.ConfigKey);
                if (sectionGroup != null) {
                    sectionGroup.DetachFromConfigurationRecord();
                }

                // Remove from list of all section group factories if this is the root declaration.
                bool isRootDeclaration = IsRootDeclaration(descendent.ConfigKey, false);
                if (_sectionGroupFactories != null && isRootDeclaration) {
                    _sectionGroupFactories.Remove(descendent.ConfigKey);
                }

                // Remove from list of factory records.
                if (!IsLocationConfig && _factoryRecords != null) {
                    _factoryRecords.Remove(descendent.ConfigKey);
                }

                // Remove from evaluated section groups.
                if (_sectionGroups != null) {
                    _sectionGroups.Remove(descendent.ConfigKey);
                }

                //
                // Add to list of section groups that are removed
                // Note that this will add section groups that might not be used
                // in this config file. That just results in some extra work during
                // save, it is not harmful.
                //
                RemovedSectionGroups.Add(descendent.ConfigKey, descendent.ConfigKey);
            }
        }

        //
        // Return the file path to this configuration file.
        //
        internal string ConfigurationFilePath {
            get {
                string filepath = UpdateConfigHost.GetNewStreamname(ConfigStreamInfo.StreamName);
                if (filepath == null) {
                    filepath = String.Empty;
                }

                if (!String.IsNullOrEmpty(filepath)) {
                    new FileIOPermission(FileIOPermissionAccess.PathDiscovery, filepath).Demand();
                }

                return filepath;
            }
        }


        //
        // Update the config file with the changes in each ConfigurationSection
        //
        internal void SaveAs(string filename, ConfigurationSaveMode saveMode, bool forceUpdateAll) {

            // Get the updates.
            SectionUpdates declarationUpdates = GetConfigDeclarationUpdates(saveMode, forceUpdateAll);

            ConfigDefinitionUpdates definitionUpdates;
            ArrayList configSourceUpdates;
            bool checkedConfigForUpdates = false;
            bool requireUpdates = (filename != null);
            GetConfigDefinitionUpdates(requireUpdates, saveMode, forceUpdateAll, out definitionUpdates, out configSourceUpdates);

            if (filename != null) {
                Debug.Assert(filename.Length > 0, "The caller should make sure that filename is not empty");

                //
                // Verify that the filename is not being used.
                //
                // Note that if we are using a remote host, all the streamName's in _streamInfoUpdates
                // are actually fullpaths on the remote machine.  In this case there is no way to
                // detect if we have a conflict or not.
                if (!Host.IsRemote && _streamInfoUpdates.Contains(filename)) {
                    throw new ArgumentException(SR.GetString(SR.Filename_in_SaveAs_is_used_already, filename));
                }

                //
                // If there was no config file for this config record,
                // record the new stream name and version.
                //
                if (String.IsNullOrEmpty(ConfigStreamInfo.StreamName)) {
                    StreamInfo streamInfo = new StreamInfo(null, null, filename);
                    _streamInfoUpdates.Add(filename, streamInfo);

                    ConfigStreamInfo.StreamName = filename;
                    ConfigStreamInfo.StreamVersion = MonitorStream(null, null, ConfigStreamInfo.StreamName);
                }

                //
                // Update the host to redirect filenames
                //
                UpdateConfigHost.AddStreamname(ConfigStreamInfo.StreamName, filename, Host.IsRemote);

                // Redirect also all configSource filenames
                foreach (StreamInfo streamInfo in _streamInfoUpdates.Values) {
                    if (!String.IsNullOrEmpty(streamInfo.SectionName)) {
                        // Get the new configSource streamName based on the new filename path
                        string newStreamName = InternalConfigHost.StaticGetStreamNameForConfigSource(
                            filename, streamInfo.ConfigSource);

                    // Ask UpdateConfigHost to intercept them.
                    UpdateConfigHost.AddStreamname(streamInfo.StreamName, newStreamName, Host.IsRemote);
                    }
                }

            }

            if (!requireUpdates) {
                // Check if there are any updates needed for the
                // configuration record itself.
                requireUpdates = RecordItselfRequiresUpdates;
            }

            if (declarationUpdates != null || definitionUpdates != null || requireUpdates) {
                // Copy the input stream before opening the output stream.
                byte[] readBuffer = null;
                Encoding encoding = null;
                if (ConfigStreamInfo.HasStream) {
                    using (Stream streamRead = Host.OpenStreamForRead(ConfigStreamInfo.StreamName)) {
                        if (streamRead == null) {
                            throw new ConfigurationErrorsException(SR.GetString(SR.Config_file_has_changed), ConfigStreamInfo.StreamName, 0);
                        }

                        readBuffer = new byte[streamRead.Length];
                        int count = streamRead.Read(readBuffer, 0, (int) streamRead.Length);
                        if (count != streamRead.Length) {
                            throw new ConfigurationErrorsException(SR.GetString(SR.Config_data_read_count_mismatch));
                        }
                    }
                    // Read the first byte so that we can determine the encoding.
                    try {
                        using (StreamReader reader = new StreamReader(ConfigStreamInfo.StreamName)) {
                            if (reader.Peek() >= 0) {
                                reader.Read();
                            }

                            // Dev10 bug 687017 - Handle only UTF-16 explicitly, so that handling of other 
                            // encodings are not affected.
                            if (reader.CurrentEncoding is UnicodeEncoding) {
                                encoding = reader.CurrentEncoding;
                            }
                        }
                    }
                    catch {
                        // Ignore any errors, encoding will remain null.
                    }
                }

                string changedStreamName = FindChangedConfigurationStream();
                if (changedStreamName != null) {
                    throw new ConfigurationErrorsException(SR.GetString(SR.Config_file_has_changed), changedStreamName, 0);
                }

                checkedConfigForUpdates = true;

                // Write the changes to the output stream.
                object writeContext = null;
                bool streamOpened = false;
                try {
                    try {
                        using (Stream streamWrite = Host.OpenStreamForWrite(ConfigStreamInfo.StreamName, null, ref writeContext)) {
                            streamOpened = true;
                            // Use the default StreamWriter constructor if encoding is null,
                            // otherwise specify the encoding.
                            using (StreamWriter streamWriter = encoding == null ? new StreamWriter(streamWrite) : new StreamWriter(streamWrite, encoding)) {
                                XmlUtilWriter utilWriter = new XmlUtilWriter(streamWriter, true);
                                if (ConfigStreamInfo.HasStream) {
                                    CopyConfig(declarationUpdates, definitionUpdates, readBuffer,
                                            ConfigStreamInfo.StreamName, NamespaceChangeNeeded, utilWriter);
                                }
                                else {
                                    CreateNewConfig(declarationUpdates, definitionUpdates, NamespaceChangeNeeded, utilWriter);
                                }
                            }
                        }
                    }
                    catch {
                        if (streamOpened) {
                            Host.WriteCompleted(ConfigStreamInfo.StreamName, false, writeContext);
                        }

                        throw;
                    }
                }
                //
                // Guarantee that exceptions contain at least the name of the stream by wrapping them
                // in a ConfigurationException.
                //
                catch (Exception e) {
                    throw ExceptionUtil.WrapAsConfigException(SR.GetString(SR.Config_error_loading_XML_file), e, ConfigStreamInfo.StreamName, 0);
                }

                Host.WriteCompleted(ConfigStreamInfo.StreamName, true, writeContext);

                // Update stream information for the config file
                ConfigStreamInfo.HasStream = true;
                ConfigStreamInfo.ClearStreamInfos();
                ConfigStreamInfo.StreamVersion = MonitorStream(null, null, ConfigStreamInfo.StreamName);
            }

            if (configSourceUpdates != null) {
                // If we haven't checked before, check now
                if (!checkedConfigForUpdates) {
                    string changedStreamName = FindChangedConfigurationStream();
                    if (changedStreamName != null) {
                        throw new ConfigurationErrorsException(SR.GetString(SR.Config_file_has_changed), changedStreamName, 0);
                    }
                }

                // write updates
                foreach (DefinitionUpdate update in configSourceUpdates) {
                    SaveConfigSource(update);
                }
            }

            // Update state to reflect the changes to the config file
            UpdateRecords();
        }

        private bool AreDeclarationAttributesModified(FactoryRecord factoryRecord, ConfigurationSection configSection) {
            return     factoryRecord.FactoryTypeName != configSection.SectionInformation.Type
                    || factoryRecord.AllowLocation != configSection.SectionInformation.AllowLocation
                    || factoryRecord.RestartOnExternalChanges != configSection.SectionInformation.RestartOnExternalChanges
                    || factoryRecord.RequirePermission != configSection.SectionInformation.RequirePermission
                    || factoryRecord.AllowDefinition != configSection.SectionInformation.AllowDefinition
                    || factoryRecord.AllowExeDefinition != configSection.SectionInformation.AllowExeDefinition
                    || factoryRecord.OverrideModeDefault.OverrideMode != configSection.SectionInformation.OverrideModeDefaultSetting.OverrideMode   // Compare the value only
                    || configSection.SectionInformation.IsModifiedFlags();
        }

        private void AppendAttribute(StringBuilder sb, string key, string value) {
            sb.Append(key);
            sb.Append("=\"");
            sb.Append(value);
            sb.Append("\" ");
        }

        private string GetUpdatedSectionDeclarationXml(FactoryRecord factoryRecord, ConfigurationSection configSection, ConfigurationSaveMode saveMode) {
            StringBuilder sb = new StringBuilder();
            sb.Append('<');
            sb.Append(KEYWORD_SECTION);
            sb.Append(' ');
            string type = (configSection.SectionInformation.Type != null) ? configSection.SectionInformation.Type : factoryRecord.FactoryTypeName;
            if (TypeStringTransformerIsSet)
                type = TypeStringTransformer(type);

            AppendAttribute(sb, KEYWORD_SECTION_NAME, configSection.SectionInformation.Name);
            AppendAttribute(sb, KEYWORD_SECTION_TYPE, type);

            if ( !configSection.SectionInformation.AllowLocation ||
                 (saveMode == ConfigurationSaveMode.Full)        ||
                 ((saveMode == ConfigurationSaveMode.Modified) &&
                   configSection.SectionInformation.AllowLocationModified)) {
                AppendAttribute(sb,
                                KEYWORD_SECTION_ALLOWLOCATION,
                                configSection.SectionInformation.AllowLocation ?
                                    KEYWORD_TRUE :
                                    KEYWORD_FALSE);
            }

            if ((configSection.SectionInformation.AllowDefinition != ConfigurationAllowDefinition.Everywhere) ||
                    (saveMode == ConfigurationSaveMode.Full) ||
                    (saveMode == ConfigurationSaveMode.Modified  && configSection.SectionInformation.AllowDefinitionModified)) {

                string v = null;
                switch (configSection.SectionInformation.AllowDefinition) {
                    case ConfigurationAllowDefinition.Everywhere:
                        v = KEYWORD_SECTION_ALLOWDEFINITION_EVERYWHERE;
                        break;
                    case ConfigurationAllowDefinition.MachineOnly:
                        v = KEYWORD_SECTION_ALLOWDEFINITION_MACHINEONLY;
                        break;

                    case ConfigurationAllowDefinition.MachineToWebRoot:
                        v = KEYWORD_SECTION_ALLOWDEFINITION_MACHINETOWEBROOT;
                        break;

                    case ConfigurationAllowDefinition.MachineToApplication:
                        v = KEYWORD_SECTION_ALLOWDEFINITION_MACHINETOAPPLICATION;
                        break;
                }

                AppendAttribute(sb, KEYWORD_SECTION_ALLOWDEFINITION, v);
            }

            if ((configSection.SectionInformation.AllowExeDefinition !=
                    ConfigurationAllowExeDefinition.MachineToApplication ) ||
                    (saveMode == ConfigurationSaveMode.Full) ||
                    (saveMode == ConfigurationSaveMode.Modified  && configSection.SectionInformation.AllowExeDefinitionModified)) {

                AppendAttribute( sb,
                        KEYWORD_SECTION_ALLOWEXEDEFINITION,
                        ExeDefinitionToString(
                        configSection.SectionInformation.AllowExeDefinition )
                        );
            }

            if (    (configSection.SectionInformation.OverrideModeDefaultSetting.IsDefaultForSection == false) ||
                    (saveMode == ConfigurationSaveMode.Full) ||
                    (saveMode == ConfigurationSaveMode.Modified  && configSection.SectionInformation.OverrideModeDefaultModified)) {

                AppendAttribute(    sb,
                                    KEYWORD_SECTION_OVERRIDEMODEDEFAULT,
                                    configSection.SectionInformation.OverrideModeDefaultSetting.OverrideModeXmlValue);
            }

            if (!configSection.SectionInformation.RestartOnExternalChanges) {
                AppendAttribute(sb, KEYWORD_SECTION_RESTARTONEXTERNALCHANGES, KEYWORD_FALSE);
            }
            else if ((saveMode == ConfigurationSaveMode.Full) ||
                    (saveMode == ConfigurationSaveMode.Modified  && configSection.SectionInformation.RestartOnExternalChangesModified)) {
                AppendAttribute(sb, KEYWORD_SECTION_RESTARTONEXTERNALCHANGES, KEYWORD_TRUE);
            }

            if (!configSection.SectionInformation.RequirePermission) {
                AppendAttribute(sb, KEYWORD_SECTION_REQUIREPERMISSION, KEYWORD_FALSE);
            }
            else if ((saveMode == ConfigurationSaveMode.Full) ||
                    (saveMode == ConfigurationSaveMode.Modified  && configSection.SectionInformation.RequirePermissionModified)) {
                AppendAttribute(sb, KEYWORD_SECTION_REQUIREPERMISSION, KEYWORD_TRUE);
            }

            sb.Append("/>");

            return sb.ToString();
        }

        // ExeDefinitionToString
        //
        // Take an ExeDefinition and translate it to a string
        //
        private string ExeDefinitionToString(
                ConfigurationAllowExeDefinition allowDefinition ) {
            switch (allowDefinition) {
                case ConfigurationAllowExeDefinition.MachineOnly:
                    return KEYWORD_SECTION_ALLOWDEFINITION_MACHINEONLY;

                case ConfigurationAllowExeDefinition.MachineToApplication:
                    return KEYWORD_SECTION_ALLOWDEFINITION_MACHINETOAPPLICATION;

                case ConfigurationAllowExeDefinition.MachineToRoamingUser:
                    return KEYWORD_SECTION_ALLOWEXEDEFINITION_MACHTOROAMING;

                case ConfigurationAllowExeDefinition.MachineToLocalUser:
                    return KEYWORD_SECTION_ALLOWEXEDEFINITION_MACHTOLOCAL;
            }

            throw ExceptionUtil.PropertyInvalid("AllowExeDefinition");
        }

        private string GetUpdatedSectionGroupDeclarationXml(FactoryRecord factoryRecord, ConfigurationSectionGroup configSectionGroup) {
            if (TargetFramework != null && !configSectionGroup.ShouldSerializeSectionGroupInTargetVersion(TargetFramework))
                return null;

            StringBuilder sb = new StringBuilder();
            sb.Append('<');
            sb.Append(KEYWORD_SECTIONGROUP);
            sb.Append(' ');
            AppendAttribute(sb, KEYWORD_SECTIONGROUP_NAME, configSectionGroup.Name);
            string type = (configSectionGroup.Type != null) ? configSectionGroup.Type : factoryRecord.FactoryTypeName;
            if (TypeStringTransformerIsSet)
                type = TypeStringTransformer(type);

            AppendAttribute(sb, KEYWORD_SECTIONGROUP_TYPE, type);

            sb.Append('>');

            return sb.ToString();
        }

        private bool HasRemovedSectionsOrGroups {
            get {
                return(_removedSections != null && _removedSections.Count > 0)
                || (_removedSectionGroups != null && _removedSectionGroups.Count > 0);
            }
        }

        // HasRemovedSections
        //
        // Does this MgmtConfigrationRecord have any sections to be removed?
        //
        private bool HasRemovedSections {
            get {
                return( ( _removedSections != null   ) &&
                        ( _removedSections.Count > 0 ) );
            }
        }

        // Gather all the updates to the configuration section declarations.
        private SectionUpdates GetConfigDeclarationUpdates(ConfigurationSaveMode saveMode, bool forceUpdateAll) {
            if (IsLocationConfig)
                return null;

            // hasChanged will be set to true if there is any change that will impact the current config file.
            bool hasChanged = HasRemovedSectionsOrGroups;
            SectionUpdates sectionUpdates = new SectionUpdates(string.Empty);

            if (_factoryRecords != null) {
                foreach (FactoryRecord factoryRecord in _factoryRecords.Values) {
                    if (!factoryRecord.IsGroup) {
                        string updatedXml = null;

                        // Never write out an undeclared section.
                        if (factoryRecord.IsUndeclared) {
                            continue;
                        }

                        // Note that GetConfigSection will return only those sections that have a sectionRecord
                        // and has a result.  In another word, only sections that have been accessed.
                        ConfigurationSection configSection = GetConfigSection(factoryRecord.ConfigKey);

                        if (configSection != null) {

                            // We should skip this section declaration only if all below hold true:
                            // 1. The section should not be declared at this level.  Reasons:
                            //      i. The section is originally not declared at this level, or
                            //      ii. The user calls SectionInformation.ForceDeclaration(false)
                            // 2. It's not machine.config.  Otherwise we must declare it even if the user called ForceDeclaration(false)
                            // 3. It's already declared higher up.
                            // 4. It's not valid in the current Target Framework version
                            if (!configSection.SectionInformation.IsDeclared
                                    && !MgmtParent.IsRootConfig
                                    && MgmtParent.FindFactoryRecord(factoryRecord.ConfigKey, false) != null) {

                                if (factoryRecord.HasFile) {
                                    hasChanged = true;
                                }

                                continue;
                            }
                            if (TargetFramework != null &&
                                !configSection.ShouldSerializeSectionInTargetVersion(TargetFramework))
                            {
                                continue;
                            }

                            if (AreDeclarationAttributesModified(factoryRecord, configSection) || !factoryRecord.HasFile) {
                                updatedXml = GetUpdatedSectionDeclarationXml(factoryRecord, configSection, saveMode);
                                if (!string.IsNullOrEmpty(updatedXml))
                                    hasChanged = true;
                            }
                        }

                        DeclarationUpdate update = new DeclarationUpdate(factoryRecord.ConfigKey, !factoryRecord.HasFile, updatedXml);
                        sectionUpdates.AddSection(update);
                    }
                    else {
                        bool addGroupUpdate = false;

                        // LookupSectionGroup will return an object only if the group has been accessed
                        ConfigurationSectionGroup configSectionGroup = LookupSectionGroup(factoryRecord.ConfigKey);

                        if (!factoryRecord.HasFile) {
                            // Not in the file, so it means the group is added programmatically.
                            addGroupUpdate = true;
                        }
                        else if (configSectionGroup != null && configSectionGroup.IsDeclarationRequired) {
                            // The section group is declared in this config file
                            addGroupUpdate = true;
                        }
                        else if (factoryRecord.FactoryTypeName != null || configSectionGroup != null) {
                            FactoryRecord parentFactoryRecord = null;
                            if (!MgmtParent.IsRootConfig) {
                                parentFactoryRecord = MgmtParent.FindFactoryRecord(factoryRecord.ConfigKey, false);
                            }

                            // Add it if declaration is required.  Please note this check is identical to the check
                            // for _declarationRequired in ConfigurationSectionGroup.AttachToConfigurationRecord.
                            addGroupUpdate = (parentFactoryRecord == null || parentFactoryRecord.FactoryTypeName == null);
                        }

                        if (addGroupUpdate) {
                            string updatedXml = null;

                            if (!factoryRecord.HasFile
                                    || (configSectionGroup != null && configSectionGroup.Type != factoryRecord.FactoryTypeName)) {

                                updatedXml = GetUpdatedSectionGroupDeclarationXml(factoryRecord, configSectionGroup);
                                if (!string.IsNullOrEmpty(updatedXml)) {
                                    hasChanged = true;
                                }
                            }

                            Debug.Assert(!factoryRecord.IsUndeclared, "!factoryRecord.IsUndeclared");
                            Debug.Assert(!IsImplicitSection(factoryRecord.ConfigKey), "We should never write out an implicit section");

                            DeclarationUpdate update = new DeclarationUpdate(factoryRecord.ConfigKey, !factoryRecord.HasFile, updatedXml);
                            sectionUpdates.AddSectionGroup(update);
                        }
                    }
                }
            }

            if (_sectionRecords != null) {
                foreach (SectionRecord sectionRecord in _sectionRecords.Values) {
                    if (GetFactoryRecord(sectionRecord.ConfigKey, false) != null || !sectionRecord.HasResult) {
                        // Skip because this factory is defined locally ( in
                        // which case we handled above), or it was not used
                        continue;
                    }

                    ConfigurationSection configSection = (ConfigurationSection) sectionRecord.Result;
                    FactoryRecord factoryRecord = MgmtParent.FindFactoryRecord(sectionRecord.ConfigKey, false);

                    // Add this section declaration if:
                    // 1. The section is not declared locally (otherwise it's handled above)
                    // 2. SectionInformation.IsDeclared is true (i.e. user called SectionInformation.ForceDeclaration(true))
                    if (configSection.SectionInformation.IsDeclared) {
                        Debug.Assert(!IsImplicitSection(sectionRecord.ConfigKey), "We should never write out an implicit section");
                        Debug.Assert(!factoryRecord.IsUndeclared, "!factoryRecord.IsUndeclared");
                        string updatedXml = GetUpdatedSectionDeclarationXml(factoryRecord, configSection, saveMode);
                        if (!string.IsNullOrEmpty(updatedXml)) {
                            hasChanged = true;
                            DeclarationUpdate update = new DeclarationUpdate(factoryRecord.ConfigKey, true, updatedXml);
                            sectionUpdates.AddSection(update);
                        }
                    }
                }
            }

            if (_sectionGroups != null) {
                foreach (ConfigurationSectionGroup configSectionGroup in _sectionGroups.Values) {
                    if (GetFactoryRecord(configSectionGroup.SectionGroupName, false) != null) {
                        continue;
                    }

                    FactoryRecord factoryRecord = MgmtParent.FindFactoryRecord(configSectionGroup.SectionGroupName, false);
                    if (    configSectionGroup.IsDeclared ||
                            (factoryRecord != null && configSectionGroup.Type != factoryRecord.FactoryTypeName)) {

                        string updatedXml = GetUpdatedSectionGroupDeclarationXml(factoryRecord, configSectionGroup);
                        if (!string.IsNullOrEmpty(updatedXml)) {
                            hasChanged = true;
                            DeclarationUpdate update = new DeclarationUpdate(factoryRecord.ConfigKey, true, updatedXml);
                            sectionUpdates.AddSectionGroup(update);
                        }
                    }
                }
            }

            if (hasChanged) {
                return sectionUpdates;
            }
            else {
                return null;
            }
        }

        private bool AreLocationAttributesModified(SectionRecord sectionRecord, ConfigurationSection configSection) {

            OverrideModeSetting overrideMode                = OverrideModeSetting.LocationDefault;
            bool                inheritInChildApplications  = true;

            if (sectionRecord.HasFileInput) {
                SectionXmlInfo sectionXmlInfo = sectionRecord.FileInput.SectionXmlInfo;
                overrideMode = sectionXmlInfo.OverrideModeSetting;
                inheritInChildApplications = !sectionXmlInfo.SkipInChildApps;
            }

            // We will use IsSameForLocation tag so that we flag modes that cant go into the same location tag
            // as different. If we don't do that it will appear like the mode was not changed which will
            // case conflict later when determining if the section is moved ( when writing the new config updates )

            return
                   (!OverrideModeSetting.CanUseSameLocationTag(overrideMode, configSection.SectionInformation.OverrideModeSetting))
                || (inheritInChildApplications != configSection.SectionInformation.InheritInChildApplications);
        }

        private bool AreSectionAttributesModified(SectionRecord sectionRecord, ConfigurationSection configSection) {
            string configSource;
            string protectionProviderName;
            string configBuilderName;

            if (sectionRecord.HasFileInput) {
                SectionXmlInfo sectionXmlInfo = sectionRecord.FileInput.SectionXmlInfo;
                configSource = sectionXmlInfo.ConfigSource;
                protectionProviderName = sectionXmlInfo.ProtectionProviderName;
                configBuilderName = sectionXmlInfo.ConfigBuilderName;
            }
            else {
                configSource = null;
                protectionProviderName = null;
                configBuilderName = null;
            }

            return
                   !StringUtil.EqualsNE(configSource, configSection.SectionInformation.ConfigSource)
                || !StringUtil.EqualsNE(protectionProviderName, configSection.SectionInformation.ProtectionProviderName)
                || !StringUtil.EqualsNE(configBuilderName, configSection.SectionInformation.ConfigBuilderName)
                || AreLocationAttributesModified(sectionRecord, configSection);
        }

        private bool IsConfigSectionMoved(SectionRecord sectionRecord, ConfigurationSection configSection) {
            if (!sectionRecord.HasFileInput)
                return true;

            return AreLocationAttributesModified(sectionRecord, configSection);
        }

        // Gather all the updates to the configuration section definitions.
        private void GetConfigDefinitionUpdates(
                bool requireUpdates, ConfigurationSaveMode saveMode, bool forceSaveAll,
                out ConfigDefinitionUpdates definitionUpdates, out ArrayList configSourceUpdates) {

            definitionUpdates = new ConfigDefinitionUpdates();
            configSourceUpdates = null;
            bool hasChanged = HasRemovedSections;

            // Loop through all the section records.
            if (_sectionRecords != null) {
                InitProtectedConfigurationSection(); // Make sure we have the initialized the protected config section, otherwise the foreach loop may ---- up
                foreach (DictionaryEntry de in _sectionRecords) {
                    string configKey = (string)de.Key;
                    SectionRecord sectionRecord = (SectionRecord) de.Value;
                    sectionRecord.AddUpdate = false;
                    bool addUpdate = sectionRecord.HasFileInput;    // If true, add this section to definitionUpdates, and optinally to configSourceUpdates
                    OverrideModeSetting overrideMode = OverrideModeSetting.LocationDefault;
                    bool inheritInChildApplications = true;
                    bool moved = false;
                    string updatedXml = null;
                    bool addToConfigSourceUpdates = false;      // If true, we have to update the external config file for this section

                    if (!sectionRecord.HasResult) {
                        if (sectionRecord.HasFileInput) {
                            SectionXmlInfo sectionXmlInfo = sectionRecord.FileInput.SectionXmlInfo;
                            overrideMode = sectionXmlInfo.OverrideModeSetting;
                            inheritInChildApplications = !sectionXmlInfo.SkipInChildApps;
                            addToConfigSourceUpdates = requireUpdates && !String.IsNullOrEmpty(sectionXmlInfo.ConfigSource);
                        }
                    }
                    else {
                        ConfigurationSection configSection = (ConfigurationSection) sectionRecord.Result;

                        if (TargetFramework != null && !configSection.ShouldSerializeSectionInTargetVersion(TargetFramework))
                            continue;

                        overrideMode = configSection.SectionInformation.OverrideModeSetting;
                        inheritInChildApplications = configSection.SectionInformation.InheritInChildApplications;

                        // it is an error to require a location section when the type doesn't allow locations.
                        if (!configSection.SectionInformation.AllowLocation && (!overrideMode.IsDefaultForLocationTag || !inheritInChildApplications)) {
                            throw new ConfigurationErrorsException(SR.GetString(SR.Config_inconsistent_location_attributes, configKey));
                        }

                        addToConfigSourceUpdates = requireUpdates && !String.IsNullOrEmpty(configSection.SectionInformation.ConfigSource);
                        try {
                            bool isModified = configSection.SectionInformation.ForceSave ||
                                    configSection.IsModified() ||
                                    (forceSaveAll && !configSection.SectionInformation.IsLocked);

                            bool sectionAttributesModified = AreSectionAttributesModified(sectionRecord, configSection);
                            bool sectionContentModified = (isModified || configSection.SectionInformation.RawXml != null);

                            // Get the updated XML if the section has been modified.
                            if (sectionContentModified || sectionAttributesModified) {
                                configSection.SectionInformation.VerifyIsEditable();
                                configSection.SectionInformation.Removed = false;
                                addUpdate = true;
                                moved = IsConfigSectionMoved(sectionRecord, configSection);

                                if (!addToConfigSourceUpdates) {
                                    addToConfigSourceUpdates =
                                               !String.IsNullOrEmpty(configSection.SectionInformation.ConfigSource)
                                            && (sectionContentModified || configSection.SectionInformation.ConfigSourceModified);
                                }

                                if (    isModified ||
                                        configSection.SectionInformation.RawXml == null ||
                                        saveMode == ConfigurationSaveMode.Full) {
                                    // Note: we won't use RawXml if saveMode == Full because Full means we want to
                                    // write all properties, and RawXml may not have all properties.

                                    // 'System.Windows.Forms.ApplicationConfiguration' is declared as an implicit section. Saving this section definition without declaration in machine .config file is causing IIS 
                                    // and "wcfservice' project creation failed. See bug #297811 for more details. Following fix exclude this section empty definition in the machine.config while saving it.
                                    if (String.Equals(configSection.SectionInformation.Name, ConfigurationStringConstants.WinformsApplicationConfigurationSectionName, StringComparison.Ordinal) &&
                                        String.Equals(configSection._configRecord.ConfigPath, ClientConfigurationHost.MachineConfigName, StringComparison.Ordinal)) {
                                        updatedXml = null;
                                    }
                                    else {
                                        ConfigurationSection parentConfigSection = FindImmediateParentSection(configSection);
                                        updatedXml = configSection.SerializeSection(parentConfigSection, configSection.SectionInformation.Name, saveMode);
                                    }
                                    ValidateSectionXml(updatedXml, configKey);
                                }
                                else {
                                    updatedXml = configSection.SectionInformation.RawXml;
                                }

                                if (string.IsNullOrEmpty(updatedXml)) {
                                    //
                                    // We always need to emit a section, even if empty, when:
                                    // * The section has configSoure
                                    // * The section is in a location section that has non-default attributes
                                    // * The section is encrypted.
                                    //
                                    if (    !String.IsNullOrEmpty(configSection.SectionInformation.ConfigSource) ||
                                            !configSection.SectionInformation.LocationAttributesAreDefault ||
                                            (configSection.SectionInformation.ProtectionProvider != null)) {

                                        updatedXml = WriteEmptyElement(configSection.SectionInformation.Name);
                                    }
                                }

                                if (string.IsNullOrEmpty(updatedXml)) {
                                    configSection.SectionInformation.Removed = true;
                                    // configSection.ElementPresent = false;
                                    updatedXml = null;
                                    addUpdate = false;
                                    if (sectionRecord.HasFileInput) {
                                        hasChanged = true;
                                        // VSWhidbey 580658: When a section is to be removed, its corresponding file
                                        // input should be cleared as well so this section will be indicated as "moved"
                                        // next time something is added back to the section.  Without marking it as "moved",
                                        // adding new content to a removed section fails as the bug describes.
                                        sectionRecord.RemoveFileInput();
                                    }
                                }
                                else {
                                    // configSection.ElementPresent = true;
                                    if (sectionAttributesModified || moved || String.IsNullOrEmpty(configSection.SectionInformation.ConfigSource)) {
                                        hasChanged = true;
                                    }

                                    // Encrypt if required.
                                    if (configSection.SectionInformation.ProtectionProvider != null) {
                                        ProtectedConfigurationSection protectedConfig = GetSection(BaseConfigurationRecord.RESERVED_SECTION_PROTECTED_CONFIGURATION) as ProtectedConfigurationSection;
                                        try {
                                            string encryptedSection = Host.EncryptSection(updatedXml, configSection.SectionInformation.ProtectionProvider, protectedConfig);

                                            // VsWhidbey 495120: The config host is responsible for encrypting a section, but it is the job of
                                            // System.Configuration to format an encrypted section during write (and to detect an encrypted section during read.)
                                            updatedXml = ProtectedConfigurationSection.FormatEncryptedSection(encryptedSection, configSection.SectionInformation.Name, configSection.SectionInformation.ProtectionProvider.Name);
                                        }
                                        catch (Exception e) {
                                            throw new ConfigurationErrorsException(
                                                    SR.GetString(SR.Encryption_failed, configSection.SectionInformation.SectionName, configSection.SectionInformation.ProtectionProvider.Name, e.Message),
                                                    e);
                                        }
                                    }
                                }
                            }
                            else if (configSection.SectionInformation.Removed) {
                                addUpdate = false;
                                if (sectionRecord.HasFileInput) {
                                    hasChanged = true;
                                }
                            }
                        }
                        catch (Exception e) {
                            throw new ConfigurationErrorsException(SR.GetString(SR.Config_exception_in_config_section_handler, configSection.SectionInformation.SectionName), e);
                        }
                    }

                    if (addUpdate) {
                        // Make sure we are not addingh a definition of a locked section
                        if (GetSectionLockedMode(sectionRecord.ConfigKey) == OverrideMode.Deny) {
                            throw new ConfigurationErrorsException(SR.GetString(SR.Config_section_locked), (IConfigErrorInfo)(null));
                        }

                        sectionRecord.AddUpdate = true;
                        DefinitionUpdate definitionUpdate = definitionUpdates.AddUpdate(overrideMode, inheritInChildApplications, moved, updatedXml, sectionRecord);
                        if (addToConfigSourceUpdates) {
                            if (configSourceUpdates == null) {
                                configSourceUpdates = new ArrayList();
                            }

                            configSourceUpdates.Add(definitionUpdate);
                        }
                    }
                }
            }

            if (_flags[ ForceLocationWritten ]) {
                // We must write the location tag
                hasChanged = true;
                definitionUpdates.RequireLocation = true;
            }

            if (_flags[ SuggestLocationRemoval ]) {
                // We should try to remove location
                hasChanged = true;
            }

            if (hasChanged) {
                definitionUpdates.CompleteUpdates();
            }
            else {
                definitionUpdates = null;
            }
        }

        //
        // WriteEmptyElement
        //
        // Take a element name, and create an xml string that contains
        // that element in an empty state
        //
        private string WriteEmptyElement( string ElementName ) {
            StringBuilder sb;

            sb = new StringBuilder();

            // Create element
            sb.Append('<');
            sb.Append(ElementName);
            sb.Append(" />");

            return sb.ToString();
        }

        // After the config file has been written out, update the section records
        // to reflect changes that were made in the config file.
        private void UpdateRecords() {
            if (_factoryRecords != null) {
                foreach (FactoryRecord factoryRecord in _factoryRecords.Values) {
                    // Update stream information
                    if (String.IsNullOrEmpty(factoryRecord.Filename)) {
                        factoryRecord.Filename = ConfigStreamInfo.StreamName;
                    }

                    factoryRecord.LineNumber = 0;

                    ConfigurationSection configSection = GetConfigSection(factoryRecord.ConfigKey);
                    if (configSection != null) {
                        if (configSection.SectionInformation.Type != null) {
                            factoryRecord.FactoryTypeName = configSection.SectionInformation.Type;
                        }

                        factoryRecord.AllowLocation = configSection.SectionInformation.AllowLocation;
                        factoryRecord.RestartOnExternalChanges = configSection.SectionInformation.RestartOnExternalChanges;
                        factoryRecord.RequirePermission = configSection.SectionInformation.RequirePermission;
                        factoryRecord.AllowDefinition = configSection.SectionInformation.AllowDefinition;
                        factoryRecord.AllowExeDefinition = configSection.SectionInformation.AllowExeDefinition;
                    }
                }
            }

            if (_sectionRecords != null) {
                string definitionConfigPath = (IsLocationConfig) ? _parent.ConfigPath : ConfigPath;
                foreach (SectionRecord sectionRecord in _sectionRecords.Values) {
                    string configSource;
                    string configSourceStreamName;
                    object configSourceStreamVersion;
                    ConfigurationSection configSection;

                    if (sectionRecord.HasResult) {
                        configSection = (ConfigurationSection) sectionRecord.Result;
                        configSource = configSection.SectionInformation.ConfigSource;
                        if (String.IsNullOrEmpty(configSource)) {
                            configSource = null;
                        }

                        configSourceStreamName = configSection.SectionInformation.ConfigSourceStreamName;
                        if (String.IsNullOrEmpty(configSourceStreamName)) {
                            configSourceStreamName = null;
                        }
                    }
                    else {
                        configSection = null;
                        configSource = null;
                        configSourceStreamName = null;

                        // If there is no result, then the only way there could be a
                        // section record is:
                        // 1. For there to be input in the file.
                        // 2. A location tag applies to this record
                        Debug.Assert(sectionRecord.HasFileInput || sectionRecord.HasLocationInputs, "sectionRecord.HasFileInput || sectionRecord.HasLocationInputs");

                        // Note that if it's a location input, we don't need to monitor the configSource because
                        // that stream is monitored by one of our parent's config record
                        if (sectionRecord.HasFileInput) {
                            SectionXmlInfo sectionXmlInfo = sectionRecord.FileInput.SectionXmlInfo;
                            configSource = sectionXmlInfo.ConfigSource;
                            configSourceStreamName = sectionXmlInfo.ConfigSourceStreamName;
                        }
                    }

                    if (!String.IsNullOrEmpty(configSource)) {
                        configSourceStreamVersion = MonitorStream(sectionRecord.ConfigKey, configSource, configSourceStreamName);
                    }
                    else {
                        configSourceStreamVersion = null;
                    }

                    if (!sectionRecord.HasResult) {
                        Debug.Assert(sectionRecord.HasFileInput || sectionRecord.HasLocationInputs, "sectionRecord.HasFileInput || sectionRecord.HasLocationInputs");

                        // Note that if it's a location input, we don't need to monitor the configSource because
                        // that stream is monitored by one of our parent's config record
                        if (sectionRecord.HasFileInput) {
                            SectionXmlInfo sectionXmlInfo = sectionRecord.FileInput.SectionXmlInfo;
                            sectionXmlInfo.StreamVersion = ConfigStreamInfo.StreamVersion;
                            sectionXmlInfo.ConfigSourceStreamVersion = configSourceStreamVersion;
                        }
                    }
                    else {
                        configSection.SectionInformation.RawXml = null;
                        bool addUpdate = sectionRecord.AddUpdate;
                        sectionRecord.AddUpdate = false;

                        if (addUpdate) {
                            SectionInput fileInput = sectionRecord.FileInput;
                            if (fileInput == null) {
                                SectionXmlInfo sectionXmlInfo = new SectionXmlInfo(
                                        sectionRecord.ConfigKey, definitionConfigPath, _configPath, _locationSubPath,
                                        ConfigStreamInfo.StreamName, 0, ConfigStreamInfo.StreamVersion, null,
                                        configSource, configSourceStreamName, configSourceStreamVersion,
                                        configSection.SectionInformation.ConfigBuilderName,
                                        configSection.SectionInformation.ProtectionProviderName,
                                        configSection.SectionInformation.OverrideModeSetting,
                                        !configSection.SectionInformation.InheritInChildApplications);

                                fileInput = new SectionInput(sectionXmlInfo, null);
                                fileInput.Result = configSection;
                                fileInput.ResultRuntimeObject = configSection;
                                sectionRecord.AddFileInput(fileInput);
                            }
                            else {
                                SectionXmlInfo sectionXmlInfo = fileInput.SectionXmlInfo;
                                sectionXmlInfo.LineNumber = 0;
                                sectionXmlInfo.StreamVersion = ConfigStreamInfo.StreamVersion;

                                sectionXmlInfo.RawXml = null;
                                sectionXmlInfo.ConfigSource = configSource;
                                sectionXmlInfo.ConfigSourceStreamName = configSourceStreamName;
                                sectionXmlInfo.ConfigSourceStreamVersion = configSourceStreamVersion;
                                sectionXmlInfo.ConfigBuilderName = configSection.SectionInformation.ConfigBuilderName;
                                sectionXmlInfo.ProtectionProviderName = configSection.SectionInformation.ProtectionProviderName;
                                sectionXmlInfo.OverrideModeSetting = configSection.SectionInformation.OverrideModeSetting;
                                sectionXmlInfo.SkipInChildApps = !configSection.SectionInformation.InheritInChildApplications;
                            }

                            fileInput.ProtectionProvider = configSection.SectionInformation.ProtectionProvider;
                        }

                        try {
                            configSection.ResetModified();
                        }
                        catch (Exception e) {
                            throw new ConfigurationErrorsException(SR.GetString(SR.Config_exception_in_config_section_handler, sectionRecord.ConfigKey), e, ConfigStreamInfo.StreamName, 0);
                        }
                    }
                }
            }

            // Copy remaining stream updates, which correspond to streams used by location sections
            foreach (StreamInfo streamInfo in _streamInfoUpdates.Values) {
                if (!ConfigStreamInfo.StreamInfos.Contains(streamInfo.StreamName)) {
                    MonitorStream(streamInfo.SectionName, streamInfo.ConfigSource, streamInfo.StreamName);
                }
            }

            // reinitialize _streamInfoUpdates
            InitStreamInfoUpdates();

            // Update namespace value
            _flags[ NamespacePresentInFile ] = _flags[ NamespacePresentCurrent ];

            // You only have one chance to force the location config, now you
            // will have to recreate the object
            _flags[ ForceLocationWritten ]   = false;
            _flags[ SuggestLocationRemoval ] = false;

            // Handle removed location sections
            if (!IsLocationConfig && _locationSections != null && _removedSections != null && _removedSections.Count > 0) {
                int i = 0;
                while (i < _locationSections.Count) {
                    LocationSectionRecord locationSectionRecord = (LocationSectionRecord) _locationSections[i];
                    if (_removedSections.Contains(locationSectionRecord.ConfigKey)) {
                        _locationSections.RemoveAt(i);
                    }
                    else {
                        i++;
                    }
                }
            }

            _removedSections = null;
            _removedSectionGroups = null;
        }

        // Create a new config file.
        private void CreateNewConfig(
                SectionUpdates          declarationUpdates,
                ConfigDefinitionUpdates definitionUpdates,
                NamespaceChange         namespaceChange,
                XmlUtilWriter           utilWriter) {
            int linePosition = DEFAULT_INDENT + 1;
            int indent = DEFAULT_INDENT;

            // Write Header
            utilWriter.Write(string.Format(CultureInfo.InvariantCulture,
                    FORMAT_NEWCONFIGFILE,
                    ConfigStreamInfo.StreamEncoding.WebName));

            // Write <configuration> tag
            if (namespaceChange == NamespaceChange.Add) {
                utilWriter.Write(string.Format(CultureInfo.InvariantCulture,
                        FORMAT_CONFIGURATION_NAMESPACE,
                        KEYWORD_CONFIGURATION_NAMESPACE));
            }
            else {
                utilWriter.Write(FORMAT_CONFIGURATION);
            }


            if (declarationUpdates != null) {
                WriteNewConfigDeclarations(declarationUpdates, utilWriter, linePosition, indent, false);
            }

            WriteNewConfigDefinitions(definitionUpdates, utilWriter, linePosition, indent);

            utilWriter.Write(FORMAT_CONFIGURATION_ENDELEMENT);
        }

        private void WriteNewConfigDeclarations(SectionUpdates declarationUpdates, XmlUtilWriter utilWriter, int linePosition, int indent, bool skipFirstIndent) {
            if (!skipFirstIndent) {
                utilWriter.AppendSpacesToLinePosition(linePosition);
            }

            utilWriter.Write("<configSections>\r\n");
            WriteUnwrittenConfigDeclarations(declarationUpdates, utilWriter, linePosition + indent, indent, false);
            utilWriter.AppendSpacesToLinePosition(linePosition);
            utilWriter.Write("</configSections>\r\n");

            if (skipFirstIndent) {
                utilWriter.AppendSpacesToLinePosition(linePosition);
            }
        }

        private void WriteUnwrittenConfigDeclarations(SectionUpdates declarationUpdates, XmlUtilWriter utilWriter, int linePosition, int indent, bool skipFirstIndent) {
            WriteUnwrittenConfigDeclarationsRecursive(declarationUpdates, utilWriter, linePosition, indent, skipFirstIndent);
        }

        private void WriteUnwrittenConfigDeclarationsRecursive(SectionUpdates declarationUpdates, XmlUtilWriter utilWriter, int linePosition, int indent, bool skipFirstIndent) {
            string[] unretrievedSectionNames = declarationUpdates.GetUnretrievedSectionNames();
            if (unretrievedSectionNames != null) {
                foreach (string configKey in unretrievedSectionNames) {
                    Debug.Assert(!IsImplicitSection(configKey), "We should never write out an implicit section");
                    if (!skipFirstIndent) {
                        utilWriter.AppendSpacesToLinePosition(linePosition);
                    }
                    skipFirstIndent = false;

                    DeclarationUpdate update = declarationUpdates.GetDeclarationUpdate(configKey);
                    if (update != null && !string.IsNullOrEmpty(update.UpdatedXml)) {
                        utilWriter.Write(update.UpdatedXml);
                        utilWriter.AppendNewLine();
                    }
                }
            }

            string[] unretrievedGroupNames = declarationUpdates.GetUnretrievedGroupNames();
            if (unretrievedGroupNames != null) {
                foreach (string group in unretrievedGroupNames) {
                    if (TargetFramework != null) {
                        ConfigurationSectionGroup g = GetSectionGroup(group);
                        if (g != null && !g.ShouldSerializeSectionGroupInTargetVersion(TargetFramework)){
                            declarationUpdates.MarkGroupAsRetrieved(group);
                            continue;
                        }
                    }
                    if (!skipFirstIndent) {
                        utilWriter.AppendSpacesToLinePosition(linePosition);
                    }
                    skipFirstIndent = false;

                    SectionUpdates declarationUpdatesChild = declarationUpdates.GetSectionUpdatesForGroup(group);
                    DeclarationUpdate groupUpdate = declarationUpdatesChild.GetSectionGroupUpdate();
                    if (groupUpdate == null) {
                        utilWriter.Write("<sectionGroup name=\"" + group + "\">");
                    }
                    else {
                        utilWriter.Write(groupUpdate.UpdatedXml);
                    }
                    utilWriter.AppendNewLine();

                    WriteUnwrittenConfigDeclarationsRecursive(declarationUpdatesChild, utilWriter, linePosition + indent, indent, false);
                    utilWriter.AppendSpacesToLinePosition(linePosition);
                    utilWriter.Write("</sectionGroup>\r\n");
                }
            }
        }

        private void WriteNewConfigDefinitions(ConfigDefinitionUpdates configDefinitionUpdates, XmlUtilWriter utilWriter, int linePosition, int indent) {
            if (configDefinitionUpdates == null)
                return;

            foreach (LocationUpdates locationUpdates in configDefinitionUpdates.LocationUpdatesList) {
                SectionUpdates sectionUpdates = locationUpdates.SectionUpdates;
                if (sectionUpdates.IsEmpty || !sectionUpdates.IsNew)
                    continue;

                configDefinitionUpdates.FlagLocationWritten();
                bool writeLocationTag = _locationSubPath != null || !locationUpdates.IsDefault;
                int recurseLinePosition = linePosition;

                utilWriter.AppendSpacesToLinePosition(linePosition);

                if (writeLocationTag) {
                    // write the <location> start tag
                    if (_locationSubPath == null) {
                        utilWriter.Write(String.Format(CultureInfo.InvariantCulture, FORMAT_LOCATION_NOPATH, locationUpdates.OverrideMode.LocationTagXmlString, BoolToString(locationUpdates.InheritInChildApps)));
                    }
                    else {
                        utilWriter.Write(String.Format(CultureInfo.InvariantCulture, FORMAT_LOCATION_PATH, locationUpdates.OverrideMode.LocationTagXmlString, BoolToString(locationUpdates.InheritInChildApps), _locationSubPath));
                    }

                    recurseLinePosition += indent;
                    utilWriter.AppendSpacesToLinePosition(recurseLinePosition);
                }

                // Invoke the recursive write.
                WriteNewConfigDefinitionsRecursive(utilWriter, locationUpdates.SectionUpdates, recurseLinePosition, indent, true);

                if (writeLocationTag) {
                    // Write the location end tag
                    utilWriter.AppendSpacesToLinePosition(linePosition);
                    utilWriter.Write(FORMAT_LOCATION_ENDELEMENT);
                    utilWriter.AppendNewLine();
                }
            }

            if (configDefinitionUpdates.RequireLocation) {
                Debug.Assert(IsLocationConfig, "IsLocationConfig");

                // If we still require this to be written, then we must write it out now
                configDefinitionUpdates.FlagLocationWritten();

                utilWriter.AppendSpacesToLinePosition(linePosition);

                utilWriter.Write(String.Format(CultureInfo.InvariantCulture, FORMAT_LOCATION_PATH, OverrideModeSetting.LocationDefault.LocationTagXmlString, KEYWORD_TRUE, _locationSubPath));
                utilWriter.AppendSpacesToLinePosition(linePosition);
                utilWriter.Write(FORMAT_LOCATION_ENDELEMENT);
                utilWriter.AppendNewLine();
            }
        }

        // Recursively write new sections for each section group.
        private bool WriteNewConfigDefinitionsRecursive(XmlUtilWriter utilWriter, SectionUpdates sectionUpdates, int linePosition, int indent, bool skipFirstIndent) {
            bool wroteASection = false;

            string[] movedSectionNames = sectionUpdates.GetMovedSectionNames();
            if (movedSectionNames != null) {
                wroteASection = true;
                foreach (string configKey in movedSectionNames) {
                    DefinitionUpdate update = sectionUpdates.GetDefinitionUpdate(configKey);
                    WriteSectionUpdate(utilWriter, update, linePosition, indent, skipFirstIndent);
                    utilWriter.AppendNewLine();
                    skipFirstIndent = false;
                }
            }

            string[] newGroupNames = sectionUpdates.GetNewGroupNames();
            if (newGroupNames != null) {
                foreach (string group in newGroupNames) {

                    if (TargetFramework != null) {
                        ConfigurationSectionGroup g = GetSectionGroup(group);
                        if (g != null && !g.ShouldSerializeSectionGroupInTargetVersion(TargetFramework)){
                            sectionUpdates.MarkGroupAsRetrieved(group);
                            continue;
                        }
                    }

                    if (!skipFirstIndent) {
                        utilWriter.AppendSpacesToLinePosition(linePosition);
                    }
                    skipFirstIndent = false;

                    utilWriter.Write("<" + group + ">\r\n");
                    bool recurseWroteASection = WriteNewConfigDefinitionsRecursive(
                            utilWriter, sectionUpdates.GetSectionUpdatesForGroup(group), linePosition + indent, indent, false);

                    if (recurseWroteASection) {
                        wroteASection = true;
                    }

                    utilWriter.AppendSpacesToLinePosition(linePosition);
                    utilWriter.Write("</" + group + ">\r\n");
                }
            }

            sectionUpdates.IsNew = false;

            return wroteASection;
        }

        private void CheckPreamble(byte[] preamble, XmlUtilWriter utilWriter, byte[] buffer) {
            bool hasByteOrderMark = false;
            using (Stream preambleStream = new MemoryStream(buffer)) {
                byte[] streamStart = new byte[preamble.Length];
                if (preambleStream.Read(streamStart, 0, streamStart.Length) == streamStart.Length) {
                    hasByteOrderMark = true;
                    for (int i = 0; i < streamStart.Length; i++) {
                        if (streamStart[i] != preamble[i]) {
                            hasByteOrderMark = false;
                            break;
                        }
                    }
                }
            }

            if (!hasByteOrderMark) {
                // Force the writer to emit byte order mark, then reset the stream
                // so that it is written over.
                object checkpoint = utilWriter.CreateStreamCheckpoint();
                utilWriter.Write('x');
                utilWriter.RestoreStreamCheckpoint(checkpoint);
            }
        }

        //
        // Calculate a new indent based on the position of the parent element and the current node.
        //
        private int UpdateIndent(int oldIndent, XmlUtil xmlUtil, XmlUtilWriter utilWriter, int parentLinePosition) {
            int indent = oldIndent;
            if (xmlUtil.Reader.NodeType == XmlNodeType.Element && utilWriter.IsLastLineBlank) {
                int childLinePosition = xmlUtil.TrueLinePosition;
                if (parentLinePosition < childLinePosition && childLinePosition <= parentLinePosition + MAX_INDENT) {
                    indent = childLinePosition - parentLinePosition;
                }
            }

            return indent;
        }

        // Copy a config file, replacing sections with updates.
        private void CopyConfig(SectionUpdates declarationUpdates, ConfigDefinitionUpdates definitionUpdates,
                byte[] buffer, string filename, NamespaceChange namespaceChange, XmlUtilWriter utilWriter) {

            CheckPreamble(ConfigStreamInfo.StreamEncoding.GetPreamble(), utilWriter, buffer);

            using (Stream stream = new MemoryStream(buffer)) {
                using (XmlUtil xmlUtil = new XmlUtil(stream, filename, false)) {
                    // copy up to the <configuration> node
                    XmlTextReader reader = xmlUtil.Reader;
                    reader.WhitespaceHandling = WhitespaceHandling.All;
                    reader.Read();
                    xmlUtil.CopyReaderToNextElement(utilWriter, false);

                    Debug.Assert(reader.NodeType == XmlNodeType.Element && reader.Name == KEYWORD_CONFIGURATION,
                                 "reader.NodeType == XmlNodeType.Element && reader.Name == KEYWORD_CONFIGURATION");

                    int indent = DEFAULT_INDENT;
                    int configurationElementLinePosition = xmlUtil.TrueLinePosition;
                    bool isEmptyConfigurationElement = reader.IsEmptyElement;

                    // copy <configuration> node
                    // if the node is an empty element, we may need to open it.
                    string configurationStartElement;
                    if (namespaceChange == NamespaceChange.Add) {
                        configurationStartElement = string.Format(
                            CultureInfo.InvariantCulture, FORMAT_CONFIGURATION_NAMESPACE, KEYWORD_CONFIGURATION_NAMESPACE);
                    }
                    else if (namespaceChange == NamespaceChange.Remove) {
                        configurationStartElement = FORMAT_CONFIGURATION;
                    }
                    else {
                        configurationStartElement = null;
                    }

                    bool needsChildren = (declarationUpdates != null || definitionUpdates  != null);
                    string configurationEndElement = xmlUtil.UpdateStartElement(utilWriter, configurationStartElement, needsChildren, configurationElementLinePosition, indent);

                    bool foundConfigSectionsElement = false;
                    if (!isEmptyConfigurationElement) {
                        // copy up to the first element under <configuration>
                        xmlUtil.CopyReaderToNextElement(utilWriter, true);

                        // updateIndent
                        indent = UpdateIndent(indent, xmlUtil, utilWriter, configurationElementLinePosition);

                        if (reader.NodeType == XmlNodeType.Element && reader.Name == KEYWORD_CONFIGSECTIONS) {
                            foundConfigSectionsElement = true;

                            int configSectionsElementLinePosition = xmlUtil.TrueLinePosition;
                            bool isEmptyConfigSectionsElement = reader.IsEmptyElement;

                            // if no updates, copy the entire <configSections> element
                            if (declarationUpdates == null) {
                                xmlUtil.CopyOuterXmlToNextElement(utilWriter, true);
                            }
                            else {
                                // copy <configSections>, and open it if it is an empty element
                                string configSectionsEndElement = xmlUtil.UpdateStartElement(
                                    utilWriter, null, true, configSectionsElementLinePosition, indent);

                                if (!isEmptyConfigSectionsElement) {
                                    // copy to next element under <configSections>, or up to closing </configSections>
                                    xmlUtil.CopyReaderToNextElement(utilWriter, true);

                                    // copy config declarations
                                    CopyConfigDeclarationsRecursive(declarationUpdates, xmlUtil, utilWriter, string.Empty,
                                            configSectionsElementLinePosition, indent);

                                    Debug.Assert(reader.NodeType == XmlNodeType.EndElement && reader.Name == KEYWORD_CONFIGSECTIONS,
                                                 "reader.NodeType == XmlNodeType.EndElement && reader.Name == \"KEYWORD_CONFIGSECTIONS\"");
                                }

                                // write declarations not written by above copy
                                if (declarationUpdates.HasUnretrievedSections()) {

                                    // determine the line position of the end element
                                    int endElementLinePosition = 0;
                                    if (configSectionsEndElement == null) {
                                        endElementLinePosition = xmlUtil.TrueLinePosition;
                                    }

                                    // indent a new line
                                    if (!utilWriter.IsLastLineBlank) {
                                        utilWriter.AppendNewLine();
                                    }

                                    WriteUnwrittenConfigDeclarations(declarationUpdates, utilWriter, configSectionsElementLinePosition + indent, indent, false);

                                    // restore spaces to end element
                                    if (configSectionsEndElement == null) {
                                        utilWriter.AppendSpacesToLinePosition(endElementLinePosition);
                                    }
                                }

                                // Copy the </configSections> element
                                if (configSectionsEndElement == null) {
                                    xmlUtil.CopyXmlNode(utilWriter);
                                }
                                else {
                                    // note that configSectionsEndElement already contains the proper indenting
                                    utilWriter.Write(configSectionsEndElement);
                                }

                                // copy up to the next element under <configuration>, or up to closing </configSections>
                                xmlUtil.CopyReaderToNextElement(utilWriter, true);
                            }
                        }
                    }

                    // Write new declarations
                    if (!foundConfigSectionsElement && declarationUpdates != null) {
                        bool skipFirstIndent = reader.Depth > 0 && reader.NodeType == XmlNodeType.Element;
                        int newConfigSectionsLinePosition;
                        if (skipFirstIndent) {
                            newConfigSectionsLinePosition = xmlUtil.TrueLinePosition;
                        }
                        else {
                            newConfigSectionsLinePosition = configurationElementLinePosition + indent;
                        }

                        WriteNewConfigDeclarations(declarationUpdates, utilWriter, newConfigSectionsLinePosition, indent, skipFirstIndent);
                    }

                    if (definitionUpdates != null) {
                        //
                        // Copy sections recursively. In the file we copy we start out at
                        //     location path="." allowOverride="true" inheritInChildApps="true"
                        //
                        bool locationPathApplies = false;
                        LocationUpdates locationUpdates = null;
                        SectionUpdates sectionUpdates = null;
                        if (!IsLocationConfig) {
                            locationPathApplies = true;
                            locationUpdates = definitionUpdates.FindLocationUpdates(OverrideModeSetting.LocationDefault, true);
                            if (locationUpdates != null) {
                                sectionUpdates = locationUpdates.SectionUpdates;
                            }
                        }

                        CopyConfigDefinitionsRecursive(definitionUpdates, xmlUtil, utilWriter, locationPathApplies,
                            locationUpdates, sectionUpdates, true, string.Empty, configurationElementLinePosition, indent);

                        // Write new config sections from new groups.
                        WriteNewConfigDefinitions(definitionUpdates, utilWriter, configurationElementLinePosition + indent, indent);

#if DBG
                        Debug.Assert(configurationEndElement != null || (reader.NodeType == XmlNodeType.EndElement && reader.Name == KEYWORD_CONFIGURATION),
                                     "configurationEndElement != null || (reader.NodeType == XmlNodeType.EndElement && reader.Name == KEYWORD_CONFIGURATION)");
#endif



#if DBG
                        {
                            foreach (LocationUpdates l in definitionUpdates.LocationUpdatesList) {
                                Debug.Assert(!l.SectionUpdates.HasUnretrievedSections(), "!l.SectionUpdates.HasUnretrievedSections()");
                            }
                        }
#endif
                    }


                    if (configurationEndElement != null) {
                        // If we have to add closing config tag, then do it now
                        // before copying extra whitespace/comments
                        if (!utilWriter.IsLastLineBlank) {
                            utilWriter.AppendNewLine();
                        }

                        utilWriter.Write(configurationEndElement);
                    }

                    //
                    // Copy the remainder of the file, the closing </configuration> node plus any whitespace
                    // and comments
                    //
                    while (xmlUtil.CopyXmlNode(utilWriter)) {
                    }
                }
            }
        }

        private bool CopyConfigDeclarationsRecursive(
                SectionUpdates declarationUpdates, XmlUtil xmlUtil, XmlUtilWriter utilWriter, string group,
                int parentLinePosition, int parentIndent) {

            bool wroteASection = false;
            XmlTextReader reader = xmlUtil.Reader;
            int linePosition;
            int indent;
            int startingLinePosition;

            indent = UpdateIndent(parentIndent, xmlUtil, utilWriter, parentLinePosition);

            if (reader.NodeType == XmlNodeType.Element) {
                linePosition = xmlUtil.TrueLinePosition;
                startingLinePosition = linePosition;
            }
            else if (reader.NodeType == XmlNodeType.EndElement) {
                linePosition = parentLinePosition + indent;
                if (utilWriter.IsLastLineBlank) {
                    startingLinePosition = xmlUtil.TrueLinePosition;
                }
                else {
                    startingLinePosition = parentLinePosition;
                }
            }
            else {
                linePosition = parentLinePosition + indent;
                startingLinePosition = 0;
            }

            //
            // Write any new section declarations that apply to this group
            //
            if (declarationUpdates != null) {
                string[] movedSectionNames = declarationUpdates.GetMovedSectionNames();
                if (movedSectionNames != null) {
                    if (!utilWriter.IsLastLineBlank) {
                        utilWriter.AppendNewLine();
                    }

                    foreach (string configKey in movedSectionNames) {
                        DeclarationUpdate sectionUpdate = declarationUpdates.GetDeclarationUpdate(configKey);
                        Debug.Assert(!IsImplicitSection(configKey), "We should never write out an implicit section");

                        // Write the one line section declaration.
                        utilWriter.AppendSpacesToLinePosition(linePosition);
                        utilWriter.Write(sectionUpdate.UpdatedXml);
                        utilWriter.AppendNewLine();

                        wroteASection = true;
                    }

                    // Restore the whitespace we used for the first element, which is either a start or an end element.
                    utilWriter.AppendSpacesToLinePosition(startingLinePosition);
                }
            }

            if (reader.NodeType == XmlNodeType.Element) {
                //
                // For each element at this depth, either:
                // - Write the element verbatim and recurse due to a group hierarchy element.
                // - Write the element verbatim because it is unchanged
                // - Write the updated XML for the section.
                // - Skip it because the section has been removed.
                //
                int depth = reader.Depth;
                while (reader.Depth == depth) {
                    bool                recurse = false;
                    DeclarationUpdate   sectionUpdate = null;
                    DeclarationUpdate   groupUpdate = null;
                    SectionUpdates      declarationUpdatesChild = null;
                    SectionUpdates      recurseDeclarationUpdates = declarationUpdates;
                    string              recurseGroup = group;

                    // update the lineposition and indent for each element
                    indent = UpdateIndent(indent, xmlUtil, utilWriter, parentLinePosition);
                    linePosition = xmlUtil.TrueLinePosition;

                    string directive = reader.Name;
                    string name = reader.GetAttribute(KEYWORD_SECTIONGROUP_NAME);
                    string configKey = CombineConfigKey(group, name);
                    if (directive == KEYWORD_SECTIONGROUP) {
                        // it's a group - get the updates for children
                        declarationUpdatesChild = declarationUpdates.GetSectionUpdatesForGroup(name);
                        if (declarationUpdatesChild != null) {
                            // get the group update
                            groupUpdate = declarationUpdatesChild.GetSectionGroupUpdate();

                            // recurse if there are more sections to copy
                            if (declarationUpdatesChild.HasUnretrievedSections()) {
                                recurse = true;
                                recurseGroup = configKey;
                                recurseDeclarationUpdates = declarationUpdatesChild;
                            }
                        }
                    }
                    else {
                        // it is a section - get the update
                        Debug.Assert(!IsImplicitSection(configKey), "We should never write out an implicit section");
                        sectionUpdate = declarationUpdates.GetDeclarationUpdate(configKey);
                    }

                    bool writeGroupUpdate = (groupUpdate != null && groupUpdate.UpdatedXml != null);
                    if (recurse) {
#if DBG
                        string startElementName = reader.Name;
#endif

                        // create a checkpoint that we can revert to if no children are written
                        object checkpoint = utilWriter.CreateStreamCheckpoint();
                        string closingElement = null;

                        // Copy this element node and up to the first subelement
                        if (writeGroupUpdate) {
                            // replace the element with the updated xml
                            utilWriter.Write(groupUpdate.UpdatedXml);

                            // skip over the start element
                            reader.Read();
                        }
                        else {
                            closingElement= xmlUtil.UpdateStartElement(utilWriter, null, true, linePosition, indent);
                        }

                        if (closingElement == null) {
                            // Only if there is a closing element should
                            // we move to it
                            xmlUtil.CopyReaderToNextElement(utilWriter, true);
                        }

                        // Recurse
                        bool recurseWroteASection = CopyConfigDeclarationsRecursive(
                                recurseDeclarationUpdates, xmlUtil, utilWriter, recurseGroup, linePosition, indent);

                        if (closingElement != null) {
                            utilWriter.AppendSpacesToLinePosition(linePosition);
                            utilWriter.Write(closingElement);

                            // Since we already got to </configSections> in reader, lets
                            // indent so we can copy the element in the right place
                            utilWriter.AppendSpacesToLinePosition(parentLinePosition);
                        } else {
                            // Copy the end element
                            xmlUtil.CopyXmlNode(utilWriter);
                        }

                        if (recurseWroteASection || writeGroupUpdate) {
                            wroteASection = true;
                        }
                        else {
                            // back out the change
                            utilWriter.RestoreStreamCheckpoint(checkpoint);
                        }

                        // Copy up to the next element, or exit this level.
                        xmlUtil.CopyReaderToNextElement(utilWriter, true);
                    }
                    else {
                        bool    skip;
                        bool    skipChildElements = false;
                        if (sectionUpdate == null) {
                            skip = true;
                            if (writeGroupUpdate) {
                                // Insert an empty <sectionGroup type="typename" > node, to introduce the type
                                wroteASection = true;
                                utilWriter.Write(groupUpdate.UpdatedXml);
                                utilWriter.AppendNewLine();
                                utilWriter.AppendSpacesToLinePosition(linePosition);
                                utilWriter.Write(FORMAT_SECTIONGROUP_ENDELEMENT);
                                utilWriter.AppendNewLine();
                                utilWriter.AppendSpacesToLinePosition(linePosition);
                            }
                            else if (groupUpdate != null) {
                                // VSWhidbey 522450
                                // If groupUpdate exists, that means we've decided in GetConfigDeclarationUpdates
                                // that the section group should stay in the file.
                                Debug.Assert(groupUpdate.UpdatedXml == null, "groupUpdate.UpdatedXml == null");
                                Debug.Assert(!declarationUpdatesChild.HasUnretrievedSections(),
                                    "If the group has any unretrieved section, we should have chosen the recursive code path above.");

                                wroteASection = true;
                                skip = false;

                                // We should skip all the child sections.  If we indeed need to keep any child
                                // section, we should have chosen the recursive code path above.
                                skipChildElements = true;
                            }
                        }
                        else {
                            wroteASection = true;
                            if (sectionUpdate.UpdatedXml == null) {
                                skip = false;
                            }
                            else {
                                skip = true;

                                // Write the updated XML on a single line
                                utilWriter.Write(sectionUpdate.UpdatedXml);
                            }
                        }

                        if (skip) {
                            //
                            // Skip over the existing element, then
                            // copy up to the next element, or exit this level.
                            //
                            xmlUtil.SkipAndCopyReaderToNextElement(utilWriter, true);
                        }
                        else {
                            if (skipChildElements) {
                                xmlUtil.SkipChildElementsAndCopyOuterXmlToNextElement(utilWriter);
                            }
                            else {
                                // Copy this entire contents of this element and then to the next element, or exit this level.
                                xmlUtil.CopyOuterXmlToNextElement(utilWriter, true);
                            }
                        }
                    }
                }
            }

            return wroteASection;
        }

        // Copy configuration sections from the original configuration file.
        private bool CopyConfigDefinitionsRecursive(
                ConfigDefinitionUpdates configDefinitionUpdates, XmlUtil xmlUtil, XmlUtilWriter utilWriter,
                bool locationPathApplies, LocationUpdates locationUpdates, SectionUpdates sectionUpdates,
                bool addNewSections, string group, int parentLinePosition, int parentIndent) {

            bool wroteASection = false;
            XmlTextReader reader = xmlUtil.Reader;
            int linePosition;
            int indent;
            int startingLinePosition;

            indent = UpdateIndent(parentIndent, xmlUtil, utilWriter, parentLinePosition);

            if (reader.NodeType == XmlNodeType.Element) {
                linePosition = xmlUtil.TrueLinePosition;
                startingLinePosition = linePosition;
            }
            else if (reader.NodeType == XmlNodeType.EndElement) {
                linePosition = parentLinePosition + indent;
                if (utilWriter.IsLastLineBlank) {
                    startingLinePosition = xmlUtil.TrueLinePosition;
                }
                else {
                    startingLinePosition = parentLinePosition;
                }
            }
            else {
                linePosition = parentLinePosition + indent;
                startingLinePosition = 0;
            }

            //
            // Write any new sections that apply to this group
            //
            if (sectionUpdates != null && addNewSections) {
                // Remove newness, so we won't write again
                sectionUpdates.IsNew = false;

                Debug.Assert(locationPathApplies, "locationPathApplies");
                string[] movedSectionNames = sectionUpdates.GetMovedSectionNames();
                if (movedSectionNames != null) {
                    if (!utilWriter.IsLastLineBlank) {
                        utilWriter.AppendNewLine();
                    }

                    utilWriter.AppendSpacesToLinePosition(linePosition);
                    bool skipFirstIndent = true;

                    foreach (string configKey in movedSectionNames) {
                        DefinitionUpdate update = sectionUpdates.GetDefinitionUpdate(configKey);

                        WriteSectionUpdate(utilWriter, update, linePosition, indent, skipFirstIndent);
                        skipFirstIndent = false;
                        utilWriter.AppendNewLine();
                        wroteASection = true;
                    }

                    // Restore the whitespace we used for the first element, which is either a start or an end element.
                    utilWriter.AppendSpacesToLinePosition(startingLinePosition);
                }
            }

            if (reader.NodeType == XmlNodeType.Element) {
                //
                // For each element at this depth, either:
                // - Write the element verbatim and recurse due to a location section or group hierarchy element.
                // - Write the element verbatim because it is unchanged, or because the current location does
                //   not apply.
                // - Write the updated XML for the section.
                // - Skip it because the section has been removed.
                //
                int depth = reader.Depth;
                while (reader.Depth == depth) {
                    bool                recurse = false;
                    DefinitionUpdate    update = null;
                    bool                elementLocationPathApplies = locationPathApplies;
                    LocationUpdates     recurseLocationUpdates = locationUpdates;
                    SectionUpdates      recurseSectionUpdates = sectionUpdates;
                    bool                recurseAddNewSections = addNewSections;
                    string              recurseGroup = group;
                    bool                removedSectionOrGroup = false;

                    // update the lineposition and indent for each element
                    indent = UpdateIndent(indent, xmlUtil, utilWriter, parentLinePosition);
                    linePosition = xmlUtil.TrueLinePosition;

                    string elementName = reader.Name;
                    if (elementName == KEYWORD_LOCATION) {
                        string locationSubPathAttribute = reader.GetAttribute(KEYWORD_LOCATION_PATH);
                        locationSubPathAttribute = NormalizeLocationSubPath(locationSubPathAttribute, xmlUtil);
                        elementLocationPathApplies = false;
                        OverrideModeSetting overrideMode = OverrideModeSetting.LocationDefault;
                        bool inheritInChildApps = true;

                        if (IsLocationConfig) {
                            // For location config we will compare config paths instead of location strings
                            // so that we dont end up comparing "1" with "Default Web Site" and ending up with the wrong result
                            if (locationSubPathAttribute == null) {
                                elementLocationPathApplies = false;
                            }
                            else {
                                elementLocationPathApplies = StringUtil.EqualsIgnoreCase(ConfigPath, Host.GetConfigPathFromLocationSubPath(Parent.ConfigPath, locationSubPathAttribute));
                            }
                        }
                        else {
                            Debug.Assert(LocationSubPath == null);

                            // This is the same as doing StringUtil.EqualsIgnoreCase(_locationSubPath, locationSubPathAttribute)
                            // but remember the first one is null. Also remember locationSubPathAttribute is already normalized
                            elementLocationPathApplies = (locationSubPathAttribute == null);
                        }

                        if (elementLocationPathApplies) {
                            // Retrieve overrideMode and InheritInChildApps

                            string allowOverrideAttribute = reader.GetAttribute(KEYWORD_LOCATION_ALLOWOVERRIDE);
                            if (allowOverrideAttribute != null) {
                                overrideMode = OverrideModeSetting.CreateFromXmlReadValue(Boolean.Parse(allowOverrideAttribute));
                            }

                            string overrideModeAttribute = reader.GetAttribute(KEYWORD_LOCATION_OVERRIDEMODE);
                            if (overrideModeAttribute != null) {
                                overrideMode = OverrideModeSetting.CreateFromXmlReadValue(OverrideModeSetting.ParseOverrideModeXmlValue(overrideModeAttribute, null));

                                Debug.Assert(allowOverrideAttribute == null, "allowOverride and overrideMode both detected in a <location> tag");
                            }

                            string inheritInChildAppsAttribute = reader.GetAttribute(KEYWORD_LOCATION_INHERITINCHILDAPPLICATIONS);
                            if (inheritInChildAppsAttribute != null) {
                                inheritInChildApps = Boolean.Parse(inheritInChildAppsAttribute);
                            }

                            // Flag that we already have one of these locations
                            configDefinitionUpdates.FlagLocationWritten();
                        }

                        if (reader.IsEmptyElement) {
                            if (elementLocationPathApplies &&
                                 (configDefinitionUpdates.FindLocationUpdates(overrideMode,
                                                                              inheritInChildApps) != null)) {
                                // If we are going to make updates here, then
                                // delete the one that is here (so we can update later)
                                elementLocationPathApplies = true;
                            }
                            else {
                                // If not lets leave it
                                elementLocationPathApplies = false;
                            }
                        }
                        else {
                            // recurse if this location applies to us
                            if (elementLocationPathApplies) {
                                if (configDefinitionUpdates != null) {
                                    recurseLocationUpdates = configDefinitionUpdates.FindLocationUpdates(overrideMode, inheritInChildApps);
                                    if (recurseLocationUpdates != null) {
                                        recurse = true;
                                        recurseSectionUpdates = recurseLocationUpdates.SectionUpdates;

                                        // If this is <location path=".">, we don't want to add moved sections
                                        // to it.
                                        if (_locationSubPath == null && recurseLocationUpdates.IsDefault) {
                                            recurseAddNewSections = false;
                                        }
                                    }
                                }
                            }
                            else {
                                // recurse if necessary to remove items in _removedSections and _removedGroups
                                if (HasRemovedSectionsOrGroups && !IsLocationConfig && Host.SupportsLocation) {
                                    recurse = true;
                                    recurseLocationUpdates = null;
                                    recurseSectionUpdates = null;
                                    recurseAddNewSections = false;
                                }
                            }
                        }
                    }
                    else {
                        string configKey = CombineConfigKey(group, elementName);
                        FactoryRecord factoryRecord = FindFactoryRecord(configKey, false);
                        if (factoryRecord == null) {
                            // The factory was deleted, so regardless of whether this is a
                            // section or sectionGroup, it can be skipped.
                            if (!elementLocationPathApplies && !IsLocationConfig) {
                                removedSectionOrGroup = true;
                            }
                        }
                        else if (factoryRecord.IsGroup) {
                            if (reader.IsEmptyElement) {
                                if (!elementLocationPathApplies && !IsLocationConfig) {
                                    removedSectionOrGroup = true;
                                }
                            }
                            else {
                                // if the location path applies, recurse if there are updates
                                if (sectionUpdates != null) {
                                    SectionUpdates sectionUpdatesChild = sectionUpdates.GetSectionUpdatesForGroup(elementName);
                                    if (sectionUpdatesChild != null) {
                                        recurse = true;
                                        recurseGroup = configKey;
                                        recurseSectionUpdates = sectionUpdatesChild;
                                    }
                                }
                                else if (!elementLocationPathApplies && !IsLocationConfig) {
                                    if (_removedSectionGroups != null && _removedSectionGroups.Contains(configKey)) {
                                        removedSectionOrGroup = true;
                                    }
                                    else {
                                        recurse = true;
                                        recurseGroup = configKey;
                                        recurseLocationUpdates = null;
                                        recurseSectionUpdates = null;
                                        recurseAddNewSections = false;
                                    }
                                }
                            }
                        }
                        else {
                            // it is a section - get the update
                            if (sectionUpdates != null) {
                                update = sectionUpdates.GetDefinitionUpdate(configKey);
                            }
                            else if (!elementLocationPathApplies && !IsLocationConfig) {
                                if (_removedSections != null && _removedSections.Contains(configKey)) {
                                    removedSectionOrGroup = true;
                                }
                            }
                        }
                    }

                    if (recurse) {
#if DBG
                        string startElementName = reader.Name;
#endif

                        // flush, and get length of underlying stream
                        object checkpoint = utilWriter.CreateStreamCheckpoint();

                        // Copy this element node and up to the first subelement
                        xmlUtil.CopyXmlNode(utilWriter);
                        xmlUtil.CopyReaderToNextElement(utilWriter, true);

                        // Recurse
                        bool recurseWroteASection = CopyConfigDefinitionsRecursive(
                                configDefinitionUpdates, xmlUtil, utilWriter, elementLocationPathApplies, recurseLocationUpdates, recurseSectionUpdates,
                                recurseAddNewSections, recurseGroup, linePosition, indent);

                        // Copy the end element
                        xmlUtil.CopyXmlNode(utilWriter);

                        if (recurseWroteASection) {
                            wroteASection = true;
                        }
                        else {
                            // back out the change
                            utilWriter.RestoreStreamCheckpoint(checkpoint);
                        }

                        // Copy up to the next element, or exit this level.
                        xmlUtil.CopyReaderToNextElement(utilWriter, true);
                    }
                    else {
                        bool skip;
                        if (update == null) {
                            // remove the section from the file if we're in the correct location,
                            // or if the section or group should be removed from all locations
                            skip = elementLocationPathApplies || removedSectionOrGroup;
                        }
                        else {
                            // replace the section if the xml for it has been updated
                            // if it is a configSource, don't write it unless the configSource parameters have changed
                            skip = false;
                            if (update.UpdatedXml != null) {
                                ConfigurationSection configSection = (ConfigurationSection) update.SectionRecord.Result;
                                if (    String.IsNullOrEmpty(configSection.SectionInformation.ConfigSource) ||
                                        configSection.SectionInformation.ConfigSourceModified) {
                                    skip = true;
                                    WriteSectionUpdate(utilWriter, update, linePosition, indent, true);
                                    wroteASection = true;
                                }
                            }
                        }

                        if (skip) {
                            //
                            // Skip over the existing element, then
                            // copy up to the next element, or exit this level.
                            //
                            xmlUtil.SkipAndCopyReaderToNextElement(utilWriter, true);
                        }
                        else {
                            // Copy this entire contents of this element and then to the next element, or exit this level.
                            xmlUtil.CopyOuterXmlToNextElement(utilWriter, true);
                            wroteASection = true;
                        }
                    }
                }
            }

            //
            // Write new section groups
            //
            if (sectionUpdates != null && addNewSections && sectionUpdates.HasNewSectionGroups()) {
                // Add whitespace to align us with the other elements in this group
                linePosition = parentLinePosition + indent;
                if (reader.NodeType == XmlNodeType.EndElement) {
                    if (utilWriter.IsLastLineBlank) {
                        startingLinePosition = xmlUtil.TrueLinePosition;
                    }
                    else {
                        startingLinePosition = parentLinePosition;
                    }
                }
                else {
                    startingLinePosition = 0;
                }

                utilWriter.AppendSpacesToLinePosition(linePosition);

                bool wroteNewSection = WriteNewConfigDefinitionsRecursive(utilWriter, sectionUpdates, linePosition, indent, true);
                if (wroteNewSection) {
                    wroteASection = true;
                }

                // Restore the whitespace of the end element
                utilWriter.AppendSpacesToLinePosition(startingLinePosition);
            }

            return wroteASection;
        }

        private void WriteSectionUpdate(XmlUtilWriter utilWriter, DefinitionUpdate update, int linePosition, int indent, bool skipFirstIndent) {
            ConfigurationSection configSection = (ConfigurationSection) update.SectionRecord.Result;
            string updatedXml;

            if (!String.IsNullOrEmpty(configSection.SectionInformation.ConfigSource)) {
                updatedXml = string.Format(CultureInfo.InvariantCulture, FORMAT_SECTION_CONFIGSOURCE, configSection.SectionInformation.Name, configSection.SectionInformation.ConfigSource);
            }
            else {
                updatedXml = update.UpdatedXml;
            }

            string formattedXml = XmlUtil.FormatXmlElement(updatedXml, linePosition, indent, skipFirstIndent);
            utilWriter.Write(formattedXml);
        }

        //
        // SaveConfigSource
        //
        private void SaveConfigSource(DefinitionUpdate update) {

            string configSourceStreamName;

            if (update.SectionRecord.HasResult) {
                ConfigurationSection configSection = (ConfigurationSection) update.SectionRecord.Result;
                configSourceStreamName = configSection.SectionInformation.ConfigSourceStreamName;
            }
            else {
                Debug.Assert(update.SectionRecord.HasFileInput, "update.SectionRecord.HasFileInput");
                SectionInput fileInput = update.SectionRecord.FileInput;
                configSourceStreamName = fileInput.SectionXmlInfo.ConfigSourceStreamName;
            }

            // Copy the input stream before opening the output stream.
            byte[] readBuffer = null;
            using (Stream streamRead = Host.OpenStreamForRead(configSourceStreamName)) {
                if (streamRead != null) {
                    readBuffer = new byte[streamRead.Length];
                    int count = streamRead.Read(readBuffer, 0, (int) streamRead.Length);
                    if (count != streamRead.Length) {
                        throw new ConfigurationErrorsException();
                    }
                }
            }

            // Write the changes to the output stream.
            bool hasFile = (readBuffer != null);
            object writeContext = null;
            bool streamOpened = false;

            try {
                try {
                    string templateStreamName;

                    if (Host.IsRemote) {
                        // templateStreamName is used by OpenStreamForWrite for copying file attributes during saving.
                        // (for details, see WriteFileContext.Complete.)
                        //
                        // If we're using a remote host, then ConfigStreamInfo.StreamName is actually pointing to a
                        // full filepath on a remote machine.  In this case, it's impossible to copy the attributes
                        // over, and thus we won't do it.
                        templateStreamName = null;
                    }
                    else {
                        templateStreamName = ConfigStreamInfo.StreamName;
                    }

                    using (Stream streamWrite = Host.OpenStreamForWrite(configSourceStreamName, templateStreamName, ref writeContext)) {
                        streamOpened = true;
                        if (update.UpdatedXml == null) {
                            Debug.Assert(hasFile, "hasFile");
                            if (hasFile) {
                                streamWrite.Write(readBuffer, 0, readBuffer.Length);
                            }
                        }
                        else {
                            using (StreamWriter streamWriter = new StreamWriter(streamWrite)) {
                                XmlUtilWriter utilWriter = new XmlUtilWriter(streamWriter, true);
                                if (hasFile) {
                                    CopyConfigSource(utilWriter, update.UpdatedXml, configSourceStreamName, readBuffer);
                                }
                                else {
                                    CreateNewConfigSource(utilWriter, update.UpdatedXml, DEFAULT_INDENT);
                                }
                            }
                        }
                    }
                }
                catch {
                    if (streamOpened) {
                        Host.WriteCompleted(configSourceStreamName, false, writeContext);
                    }

                    throw;
                }
            }
            //
            // Guarantee that exceptions contain at least the name of the stream by wrapping them
            // in a ConfigurationException.
            //
            catch (Exception e) {
                throw ExceptionUtil.WrapAsConfigException(SR.GetString(SR.Config_error_loading_XML_file), e, configSourceStreamName, 0);
            }

            Host.WriteCompleted(configSourceStreamName, true, writeContext);
        }

        private void CopyConfigSource(XmlUtilWriter utilWriter, string updatedXml, string configSourceStreamName, byte[] buffer) {
            // only copy the byte order mark if it exists in the current web.config
            byte[] preamble;
            using (Stream stream = new MemoryStream(buffer)) {
                using (XmlUtil xmlUtil = new XmlUtil(stream, configSourceStreamName, true)) {
                    preamble = ConfigStreamInfo.StreamEncoding.GetPreamble();
                }
            }

            CheckPreamble(preamble, utilWriter, buffer);

            using (Stream stream = new MemoryStream(buffer)) {
                using (XmlUtil xmlUtil = new XmlUtil(stream, configSourceStreamName, false)) {
                    XmlTextReader reader = xmlUtil.Reader;

                    // copy up to the first element
                    reader.WhitespaceHandling = WhitespaceHandling.All;
                    reader.Read();

                    // determine the indent to use for the element
                    int indent = DEFAULT_INDENT;
                    int linePosition = 1;
                    bool hasElement = xmlUtil.CopyReaderToNextElement(utilWriter, false);
                    if (hasElement) {
                        // find the indent of the first attribute, if any
                        int lineNumber = reader.LineNumber;
                        linePosition = reader.LinePosition - 1;
                        int attributeIndent = 0;
                        while (reader.MoveToNextAttribute()) {
                            if (reader.LineNumber > lineNumber) {
                                attributeIndent =   reader.LinePosition - linePosition;
                                break;
                            }
                        }

                        // find the indent of the first sub element, if any
                        int elementIndent = 0;
                        reader.Read();
                        while (reader.Depth >= 1) {
                            if (reader.NodeType == XmlNodeType.Element) {
                                elementIndent = (reader.LinePosition - 1) - linePosition;
                                break;
                            }

                            reader.Read();
                        }

                        if (elementIndent > 0) {
                            indent = elementIndent;
                        }
                        else if (attributeIndent > 0) {
                            indent = attributeIndent;
                        }
                    }

                    // Write the config source
                    string formattedXml = XmlUtil.FormatXmlElement(updatedXml, linePosition, indent, true);
                    utilWriter.Write(formattedXml);

                    // Copy remaining contents
                    if (hasElement) {
                        // Skip over the existing element
                        while (reader.Depth > 0) {
                            reader.Read();
                        }

                        if (reader.IsEmptyElement || reader.NodeType == XmlNodeType.EndElement) {
                            reader.Read();
                        }

                        // Copy remainder of file
                        while (xmlUtil.CopyXmlNode(utilWriter)) {
                        }
                    }
                }
            }
        }


        private void CreateNewConfigSource(XmlUtilWriter utilWriter, string updatedXml, int indent) {
            string formattedXml = XmlUtil.FormatXmlElement(updatedXml, 0, indent, true);
            utilWriter.Write(string.Format(CultureInfo.InvariantCulture, FORMAT_CONFIGSOURCE_FILE, ConfigStreamInfo.StreamEncoding.WebName));
            utilWriter.Write(formattedXml + NL);
        }

        private static string BoolToString(bool v) {
            return v ? KEYWORD_TRUE : KEYWORD_FALSE;
        }

        // RemoveLocationWriteRequirement
        //
        // It is possible that we have set the flag to force this location
        // to be written out.  Allow a way to remove that
        //
        internal void RemoveLocationWriteRequirement() {
            if (IsLocationConfig) {
                _flags[ ForceLocationWritten ] = false;
                _flags[ SuggestLocationRemoval ] = true;
            }
        }

        // NamespacePresent
        //
        // Is the namespace present in the file or not?  ...and do you
        // want it to be?
        //
        internal bool NamespacePresent {
            get {
                return _flags[ NamespacePresentCurrent ];
            }
            set {
                _flags[ NamespacePresentCurrent ] = value;
            }
        }

        // NamespaceChangeNeeded
        //
        // On Update, do we need to add the namespace, remove it, or do nothing?
        //
        private NamespaceChange NamespaceChangeNeeded {
            get {
                if (_flags[ NamespacePresentCurrent ] ==
                        _flags[ NamespacePresentInFile ]) {
                    return NamespaceChange.None;
                }

                if (_flags[ NamespacePresentCurrent ]) {
                    return NamespaceChange.Add;
                }

                return NamespaceChange.Remove;
            }
        }

        // RecordItselfRequiresUpdates
        //
        // Outside the scope of the sections and there definitions, does
        // the record itself require an update.
        //
        private bool RecordItselfRequiresUpdates {
            get {
                return (NamespaceChangeNeeded != NamespaceChange.None);
            }
        }
    }
}