MarkupCompiler.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / Orcas / NetFXw7 / wpf / src / BuildTasks / MS / Internal / MarkupCompiler / MarkupCompiler.cs / 2 / MarkupCompiler.cs

                            //---------------------------------------------------------------------------- 
//
// File: MarkupCompiler.cs
//
// Description: 
//   Markup Compiler class that compiles the markup in a Xaml file into a
//   binary stream (Baml) and\or code (IL) in an assembly. 
// 
//
// History: 
//    10/29/01:    sramani        Created
//    6/13/03:     sramani        Ported to WPP
//    3/11/04:     sramani        Removed CAML support
// 
// Copyright (C) 2001 by Microsoft Corporation.  All rights reserved.
// 
//--------------------------------------------------------------------------- 

#pragma warning disable 1634, 1691 

using System;
using System.Xml;
using System.IO; 
using System.Text;
using System.Reflection; 
using System.Globalization; 
using System.ComponentModel;
using System.Security.Permissions; 
using System.Security.Cryptography;

using System.CodeDom;
using System.CodeDom.Compiler; 
using System.Collections;
using System.Collections.Generic; 
using System.ComponentModel.Design.Serialization; 

using System.Diagnostics; 
using System.Diagnostics.CodeAnalysis;

using System.Threading;
using MS.Internal.Markup; 
using MS.Internal.Tasks;
using MS.Utility;   // for SR 
 
namespace MS.Internal
{ 
    internal sealed class MarkupCompiler
    {
#region ExternalAPI
 
#region Public Properties
 
        ///String that specifies the directory to place the generated files into 
        public string TargetPath
        { 
            get { return _targetPath; }
            set { _targetPath = value; }
        }
 
        /// 
        /// The version of the assembly 
        ///  
        public string AssemblyVersion
        { 
            get { return _assemblyVersion; }
            set { _assemblyVersion = value; }
        }
 
        /// 
        /// The public key token of the assembly 
        ///  
        public string AssemblyPublicKeyToken
        { 
            get { return _assemblyPublicKeyToken; }
            set { _assemblyPublicKeyToken = value; }
        }
 
        ///Array of loose files associated with this assembly
        public string [] ContentList 
        { 
            get { return _contentList; }
            set { _contentList = value; } 
        }

        /// 
        /// Splash screen image to be displayed before application init 
        /// 
        public string SplashImage 
        { 
            set { _splashImage = value; }
        } 

        /// Array of local xaml page files to be compiled at pass2 
        public string[] LocalXamlPages
        { 
            get { return _localXamlPages; }
        } 
 
        /// Local Application xaml file to be compiled at pass2 
        public string LocalXamlApplication 
        {
            get { return _localXamlApplication; }
        }
 
        /// 
        /// ReferenceAssemblyList. every item is an instance of ReferenceAssembly. 
        ///  
        /// 
        public ArrayList ReferenceAssemblyList 
        {
            get { return _referenceAssemblyList; }
            set { _referenceAssemblyList = value; }
        } 

        ///The language source file extension set in a project or the registered default. 
        public string LanguageSourceExtension 
        {
            get { return _languageSourceExtension; } 
            set { _languageSourceExtension = value; }
        }

        ///Allows to hook a custom parser during compilation. 
        public ParserHooks ParserHooks
        { 
            get { return _parserHooks; } 
            set { _parserHooks = value; }
        } 

        ///If true code for supporting hosting in Browser is generated
        public bool HostInBrowser
        { 
            get { return _hostInBrowser; }
            set { _hostInBrowser = value; } 
        } 

        ///Generate Debug information in the BAML file. 
        public bool XamlDebuggingInformation
        {
            get { return _xamlDebuggingInformation; }
            set { _xamlDebuggingInformation = value; } 
        }
 
        ///  
        /// Get/Sets the TaskFileService which is used for abstracting simple
        /// files services provided by CLR and the HostObject (IVsMsBuildTaskFileManager) 
        /// 
        internal ITaskFileService TaskFileService
        {
            get { return _taskFileService; } 
            set { _taskFileService = value; }
        } 
 
        // If the xaml has local references, then it could have internal element & properties
        // but there is no way to determine this until MCPass2. Yet, GeneratedInternalTypeHelper, 
        // which is the class that allows access to legitimate internals, needs to be generated
        // in MCPass1. So, to determine if GeneratedInternalTypeHelper.cs needs to be kept or not,
        // MCPass1 & MCPass2 task will use the HasInternals property as indicated below:
 
        // In pass1, if this property returns true, it will be due to friend internals & so
        // MCPass1 will just decide to keep the file & this property will be ignored in MCPass2 
        // if that task is executed as well. 

        // In pass1, if this property returns false, MCPass2 will look at this property again after 
        // the Xaml Compiler has been called to compile all the local markup files. Now if this
        // property still returns false, the file will be removed, else it will be kept, because
        // this property was true as the xaml compiler encountered local or friend internals
        // during MCPass2. 

        // The above will apply only for a clean build, not incremental build. 
        public static bool HasInternals 
        {
            get { return XamlTypeMapper.HasInternals; } 
        }

        /// 
        /// Given an assembly name, resets it in the assembly cache and marks it for being 
        /// loaded from a memory buffer instead of a file in disk.
        ///  
        public static void InitializeAssemblyState(string assemblyName) 
        {
            ReflectionHelper.ResetCacheForAssembly(assemblyName); 
            ReflectionHelper.SetContentLoadForAssembly(assemblyName);
        }

#endregion Public Properties 

#region Public Events 
 
        /// 
        /// The Error event is fired when an error is encountered while compiling a xaml file. 
        /// 
        public event MarkupErrorEventHandler Error;

        ///  
        /// The SourceFileResolve event is fired when it starts to compile one xaml file or handle
        /// resource file. The event handler will resolve the original filepath to a new 
        /// SourcePath and RelativeSourceFilePath. 
        /// 
        public event SourceFileResolveEventHandler SourceFileResolve; 

#endregion Public Events

#region Public Methods 

        ///Complies list of file items comprising an Application. 
        public void Compile(CompilationUnit cu) 
        {
            try 
            {
                AssemblyName = cu.AssemblyName;
                InitCompilerState();
 
                DefaultNamespace = cu.DefaultNamespace;
                _compilationUnitSourcePath = cu.SourcePath; 
 
                if (!IsLanguageSupported(cu.Language))
                { 
                    OnError(new Exception(SR.Get(SRID.UnknownLanguage, cu.Language)));
                    return;
                }
 
                if (!cu.Pass2)
                { 
                    EnsureLanguageSourceExtension(); 
                }
 
                if (cu.ApplicationFile != null && cu.ApplicationFile.Length > 0)
                {
                    Initialize(cu.ApplicationFile);
                    ApplicationFile = SourceFileInfo.RelativeSourceFilePath; 

                    if (ApplicationFile.Length > 0) 
                    { 
                        IsCompilingEntryPointClass = true;
                        _Compile(cu.ApplicationFile, cu.Pass2); 
                        IsCompilingEntryPointClass = false;

                        if (_pendingLocalFiles != null && _pendingLocalFiles.Count == 1)
                        { 
                            Debug.Assert(!cu.Pass2);
                            _localXamlApplication = (string)_pendingLocalFiles[0]; 
                            _pendingLocalFiles.Clear(); 
                        }
                    } 
                }

                if (cu.FileList != null)
                { 
                    for (int i = 0; i < cu.FileList.Length; i++)
                    { 
                        string sourceFile = cu.FileList[i]; 

                        Initialize(sourceFile); 
                        if (SourceFileInfo.RelativeSourceFilePath.Length > 0)
                        {
                            _Compile(sourceFile, cu.Pass2);
                        } 
                    }
 
                    if (_pendingLocalFiles != null && _pendingLocalFiles.Count > 0) 
                    {
                        Debug.Assert(!cu.Pass2); 
                        _localXamlPages = (string[])_pendingLocalFiles.ToArray(typeof(string));
                        _pendingLocalFiles.Clear();
                    }
                } 

                if (!cu.Pass2 && ContentList != null && ContentList.Length > 0) 
                { 
                    GenerateLooseContentAttributes();
                } 

                Debug.Assert(!cu.Pass2 || _pendingLocalFiles == null);
                Debug.Assert(_pendingLocalFiles == null || _pendingLocalFiles.Count == 0);
                _pendingLocalFiles = null; 

                if (cu.Pass2) 
                { 
                    _localAssembly = null;
                    _localXamlApplication = null; 
                    _localXamlPages = null;
                }
            }
            finally 
            {
                if (_typeMapper != null) 
                { 
                    _typeMapper.ClearReflectionOnlyAssemblyResolver();
                } 

                if (s_md5HashAlgorithm != null)
                {
                    s_md5HashAlgorithm.Clear(); 
                    s_md5HashAlgorithm = null;
                } 
            } 
        }
 
#endregion Public Methods

#endregion ExternalAPI
 
#region Implementation
 
#region Properties 

        private CompilerInfo CompilerInfo 
        {
            get { return _ci; }
            set
            { 
                _ci = value;
                if (value == null) 
                { 
                    _codeProvider = null;
                } 
            }
        }

        private string ApplicationFile 
        {
            get { return _applicationFile; } 
            set { _applicationFile = value; } 
        }
 
        private string DefaultNamespace
        {
            get { return _defaultNamespace; }
            set 
            {
                IsValidCLRNamespace(value, true); 
                _defaultNamespace = value; 
            }
        } 

        private bool IsCodeNeeded
        {
            get { return _isCodeNeeded; } 
            set { _isCodeNeeded = value; }
        } 
 
        internal bool IsBamlNeeded
        { 
            get { return IsCompilingEntryPointClass ? _isBamlNeeded : true; }
            set { _isBamlNeeded = value; }
        }
 
        internal bool IsRootPublic
        { 
            get { return _ccRoot != null && _ccRoot.CodeClass.TypeAttributes == TypeAttributes.Public; } 
        }
 
        internal bool ProcessingRootContext
        {
            get { return _ccRoot == null; }
        } 

        internal bool IsRootNameScope 
        { 
            get
            { 
                CodeContext cc = (CodeContext)_codeContexts.Peek();
                return cc.IsAllowedNameScope;
            }
        } 

        internal bool HasLocalEvent 
        { 
            get { return _hasLocalEvent; }
            set { _hasLocalEvent = value; } 
        }

        internal static bool HasLocalReference
        { 
            get { return XamlTypeMapper.HasLocalReference; }
        } 
 
        internal Assembly LocalAssembly
        { 
            get
            {
                if (_localAssembly == null)
                { 
                    if (LocalAssemblyFile != null)
                    { 
                        _localAssembly = ReflectionHelper.LoadAssembly(LocalAssemblyFile.AssemblyName, LocalAssemblyFile.Path); 
                    }
                } 

                return _localAssembly;
            }
        } 

        internal ReferenceAssembly LocalAssemblyFile 
        { 
            get { return _localAssemblyFile;  }
            set { _localAssemblyFile = value; } 
        }

        internal string AssemblyName
        { 
            get { return _assemblyName; }
            set { _assemblyName = value; } 
        } 

        internal SourceFileInfo SourceFileInfo 
        {
            get { return _sourceFileInfo; }
            set { _sourceFileInfo = value; }
        } 

        internal bool IsCompilingEntryPointClass 
        { 
            get { return _isCompilingEntryPointClass; }
            set { _isCompilingEntryPointClass = value; _isBamlNeeded = !value; } 
        }

        internal static string DefinitionNSPrefix
        { 
            get { return _definitionNSPrefix; }
            set { _definitionNSPrefix = value; } 
        } 

        internal string Language 
        {
            get { return _language; }
        }
 
#endregion Properties
 
#region CompileUnit 

        private void InitCompilerState() 
        {
            _hasGeneratedInternalTypeHelper = false;
            CompilerInfo = null;
            InitializeTypeMapper(); 
        }
 
        // 
        // Generate the SourceFileInfo for the source file.
        // Do the appropriate initiallization work and file checking. 
        //
        private void Initialize(string sourceFile)
        {
            try 
            {
                // Keep the SourceFileInfo for the passed source file. 
                SourceFileInfo = OnSourceFileResolve(sourceFile); 

                // Process the input file 
                if (sourceFile == null || !SourceFileInfo.IsXamlFile)
                {
                    ThrowCompilerException(SRID.InvalidMarkupFile);
                } 

                if (!TaskFileService.Exists(sourceFile)) 
                { 
                    ThrowCompilerException(SRID.FileNotFound, sourceFile);
                } 

                // Prime the output directory
                if (TargetPath.Length > 0)
                { 
                    // check for ending '\'
                    if (!TargetPath.EndsWith(ESCAPED_BACKSLASH, StringComparison.Ordinal)) 
                    { 
                        TargetPath += ESCAPED_BACKSLASH;
                    } 
                }

                int pathEndIndex = SourceFileInfo.RelativeSourceFilePath.LastIndexOf(ESCAPED_BACKSLASH, StringComparison.Ordinal);
                string targetPath = TargetPath + SourceFileInfo.RelativeSourceFilePath.Substring(0, pathEndIndex + 1); 

                // Create if not already exists 
                if (targetPath.Length > 0 && !Directory.Exists(targetPath)) 
                {
                    Directory.CreateDirectory(targetPath); 
                }
            }
            // All exceptions including NullRef & SEH need to be caught by the markupcompiler
            // since it is an app and not a component. 
            #pragma warning suppress 6500
            catch (Exception e) 
            { 
                OnError(e);
            } 
        }

        private void _Compile(string relativeSourceFile, bool pass2)
        { 
            bool error = false;
            Stream bamlStream = null; 
            XamlParser xamlParser = null; 

            try 
            {
                DefinitionNSPrefix = DEFINITION_PREFIX;
                IsCodeNeeded = false;
 
                _ccRoot = null;
                _hasLocalEvent = false; 
                _codeContexts = new Stack(); 
                _parserContext = new ParserContext();
                _parserContext.XamlTypeMapper = _typeMapper; 

                bamlStream = new MemoryStream();
                BamlRecordWriter bamlWriter = new BamlRecordWriter(bamlStream, _parserContext, true);
                bamlWriter.DebugBamlStream = XamlDebuggingInformation; 

                xamlParser = new ParserExtension(this, _parserContext, bamlWriter, SourceFileInfo.Stream, pass2); 
 
                xamlParser.ParserHooks = ParserHooks;
 
                try
                {
                    xamlParser.Parse();
                } 
                finally
                { 
                    _typeMapper.ResetMapper(); 
                }
            } 
            catch (XamlParseException e)
            {
                OnError(e);
                error = true; 
            }
            // All exceptions including NullRef & SEH need to be caught by the markupcompiler 
            // since it is an app and not a component. 
#pragma warning suppress 6500
            catch (Exception e) 
            {
                OnError(e);
                error = true;
            } 
            finally
            { 
                if (!error && 
                    xamlParser.BamlRecordWriter == null &&
                    IsBamlNeeded) 
                {
                    if (_pendingLocalFiles == null)
                    {
                        _pendingLocalFiles = new ArrayList(10); 
                    }
 
                    _pendingLocalFiles.Add(relativeSourceFile); 
                }
 
                if (_codeContexts != null)
                {
                    _codeContexts.Clear();
                    _codeContexts = null; 
                }
 
 
                if (SourceFileInfo != null)
                { 
                    SourceFileInfo.CloseStream();
                }

                if (bamlStream != null) 
                {
                    bamlStream.Close(); 
                    bamlStream = null; 
                }
            } 
        }

        private void GenerateSource()
        { 
            Debug.Assert(_codeContexts.Count == 0);
 
            CodeNamespace cnsImports = IsLanguageCSharp ? new CodeNamespace() : _ccRoot.CodeNS; 

            if (IsCodeNeeded) 
            {
                cnsImports.Imports.Add(new CodeNamespaceImport("System"));

                if (_usingNS != null) 
                {
                    foreach (string u in _usingNS) 
                    { 
                        cnsImports.Imports.Add(new CodeNamespaceImport(u));
                    } 

                    _usingNS.Clear();
                    _usingNS = null;
                } 

                //  } end SubClass 
                _ccRoot.CodeNS.Types.Add(_ccRoot.CodeClass); 
            }
 
            if (IsCompilingEntryPointClass)
            {
                GenerateAppEntryPoint();
            } 

            if (IsCodeNeeded) 
            { 
                MemoryStream codeMemStream = new MemoryStream();
 
                // using Disposes the StreamWriter when it ends.  Disposing the StreamWriter
                // also closes the underlying MemoryStream.  Furthermore, don't add BOM here since
                // TaskFileService.WriteFile adds it.
                using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false))) 
                {
                    CodeGeneratorOptions o = new CodeGeneratorOptions(); 
 
                    // } end namespace
                    CodeCompileUnit ccu = new CodeCompileUnit(); 

                    // generate pragma checksum data
                    if (s_md5HashAlgorithm == null)
                    { 
                        s_md5HashAlgorithm = new MD5CryptoServiceProvider();
                        s_hashMD5Guid = new Guid(0x406ea660, 0x64cf, 0x4c82, 0xb6, 0xf0, 0x42, 0xd4, 0x81, 0x72, 0xa7, 0x99); 
                    } 

                    CodeChecksumPragma csPragma = new CodeChecksumPragma(); 
                    csPragma.FileName = ParentFolderPrefix + SourceFileInfo.RelativeSourceFilePath + XAML;
                    csPragma.ChecksumAlgorithmId = s_hashMD5Guid;
                    csPragma.ChecksumData = TaskFileService.GetChecksum(SourceFileInfo.OriginalFilePath, s_hashMD5Guid);
                    ccu.StartDirectives.Add(csPragma); 

                    if (cnsImports != _ccRoot.CodeNS) 
                    { 
                        ccu.Namespaces.Add(cnsImports);
                    } 

                    ccu.Namespaces.Add(_ccRoot.CodeNS);

                    CodeDomProvider codeProvider = EnsureCodeProvider(); 

                    if (codeProvider.Supports(GeneratorSupport.PartialTypes) && _ccRoot.SubClass.Length == 0) 
                    { 
                        _ccRoot.CodeClass.IsPartial = true;
                    } 

                    codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o);

                    codeStreamWriter.Flush(); 
                    TaskFileService.WriteFile(codeMemStream.ToArray(),
                        TargetPath + SourceFileInfo.RelativeSourceFilePath 
                        + (TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension) 
                        + LanguageSourceExtension);
                } 
            }

            // Generate the InternalTypeHelper class in a separate code file only once and on an as
            // needed basis for the current assembly being built. This class provides support for 
            // accessing legitimate internal types and properties that are present in the same (local)
            // or a friend assembly and it is generated only when any such internals are actually 
            // encountered in any of the xaml files in the project. 
            GenerateInternalTypeHelperImplementation();
        } 

        //
        // Return FileInfo for the given source file.
        // 
        private SourceFileInfo OnSourceFileResolve(string filePath)
        { 
            SourceFileInfo sourceFileInfo; 

            if (SourceFileResolve != null) 
            {
                //
                // If SourceFileResolve event handler is registered,  the handler
                // is responsible for generating the SourceFileInfo. 
                // This is for MSBUILD tasks.
                // 
                SourceFileResolveEventArgs scea = new SourceFileResolveEventArgs(filePath); 

                SourceFileResolve(this, scea); 

                sourceFileInfo = scea.SourceFileInfo;
            }
            else 
            {
                // If SourceFileResolve event handler is not registered,  generate 
                // the default SourceFileInfo for this file. 
                //
                sourceFileInfo = new SourceFileInfo(filePath); 

                sourceFileInfo.SourcePath = _compilationUnitSourcePath;

                if (sourceFileInfo.IsXamlFile) 
                {
                    int fileExtIndex = filePath.LastIndexOf(DOT, StringComparison.Ordinal); 
 
                    sourceFileInfo.RelativeSourceFilePath = filePath.Substring(0, fileExtIndex);
                } 
            }

            return sourceFileInfo;
        } 

#endregion CompileUnit 
 
#region ErrorHandling
 
        static void ThrowCompilerException(string id)
        {
            string message = SR.Get(id);
            ThrowCompilerExceptionImpl(message); 
        }
 
        internal static void ThrowCompilerException(string id, string value) 
        {
            string message = SR.Get(id, value); 
            ThrowCompilerExceptionImpl(message);
        }

        internal static void ThrowCompilerException(string id, string value1, string value2) 
        {
            string message = SR.Get(id, value1, value2); 
            ThrowCompilerExceptionImpl(message); 
        }
 
        internal static void ThrowCompilerException(string id, string value1, string value2, string value3)
        {
            string message = SR.Get(id, value1, value2, value3);
            ThrowCompilerExceptionImpl(message); 
        }
 
        static void ThrowCompilerException(string id, string value1, string value2, string value3, string value4) 
        {
            string message = SR.Get(id, value1, value2, value3, value4); 
            ThrowCompilerExceptionImpl(message);
        }

        static void ThrowCompilerExceptionImpl(string message) 
        {
            Exception compilerException = new Exception(message); 
            throw compilerException; 
        }
 
        internal void OnError(Exception e)
        {
            if (Error != null)
            { 
                XamlParseException xe = e as XamlParseException;
                int lineNum = xe != null ? xe.LineNumber : 0; 
                int linePos = xe != null ? xe.LinePosition : 0; 
                string filename = SourceFileInfo.OriginalFilePath;
 
                MarkupErrorEventArgs eea = new MarkupErrorEventArgs(e, lineNum, linePos, filename);
                Error(this, eea);
            }
        } 

#endregion ErrorHandling 
 
#region Definition Namespace processing
 
        internal void ProcessDefinitionNamespace(XamlDefTagNode xamlDefTagNode)
        {
            bool exitLoop = false;
            XmlReader xmlReader = xamlDefTagNode.XmlReader; 
            string LocalName = xmlReader.LocalName;
            bool isEmptyElement = xamlDefTagNode.IsEmptyElement; 
            bool isProcessingCodeTag = false; 

            do 
            {
                XmlNodeType currNodeType = xmlReader.NodeType;
                switch (currNodeType)
                { 
                    case XmlNodeType.Element:
                    { 
                        if (isProcessingCodeTag) 
                        {
                            ThrowCompilerException(SRID.DefnTagsCannotBeNested, DefinitionNSPrefix, LocalName, xmlReader.LocalName); 
                        }

                        switch (LocalName)
                        { 
                            case CODETAG:
                                isProcessingCodeTag = true; 
                                if (!IsCodeNeeded) 
                                {
                                    ThrowCompilerException(SRID.MissingClassDefinitionForCodeTag, 
                                                           _ccRoot.ElementName,
                                                           DefinitionNSPrefix,
                                                           SourceFileInfo.RelativeSourceFilePath + XAML);
                                } 

                                bool moreAttributes = xmlReader.MoveToFirstAttribute(); 
                                while (moreAttributes) 
                                {
                                    string attributeNamespaceUri = xmlReader.LookupNamespace(xmlReader.Prefix); 
                                    if (!attributeNamespaceUri.Equals(XamlReaderHelper.DefinitionNamespaceURI) ||
                                        !xmlReader.LocalName.Equals(XamlReaderHelper.DefinitionUid))
                                    {
                                        ThrowCompilerException(SRID.AttributeNotAllowedOnCodeTag, 
                                                               xmlReader.Name,
                                                               DefinitionNSPrefix, 
                                                               CODETAG); 
                                    }
 
                                    moreAttributes = xmlReader.MoveToNextAttribute();
                                }

                                break; 

                            default: 
                                ThrowCompilerException(SRID.UnknownDefinitionTag, DefinitionNSPrefix, LocalName); 
                                break;
                        } 

                        // if an empty element do a Reader to
                        // get to the next node and then exit
                        if (isEmptyElement) 
                        {
                            xmlReader.Read(); 
                            exitLoop = true; 
                        }
 
                        break;
                    }

                    case XmlNodeType.EndElement: 
                    {
                        xmlReader.Read(); 
                        exitLoop = true; 
                        break;
                    } 

                    case XmlNodeType.CDATA:
                    case XmlNodeType.Text:
                    { 
                        IXmlLineInfo xmlLineInfo = xmlReader as IXmlLineInfo;
                        int lineNumber = 0; 
 
                        if (null != xmlLineInfo)
                        { 
                            lineNumber = xmlLineInfo.LineNumber;
                        }

                        if (LocalName.Equals(CODETAG)) 
                        {
                            AddCodeSnippet(xmlReader.Value, lineNumber); 
                        } 
                        else
                        { 
                            ThrowCompilerException(SRID.IllegalCDataTextScoping, DefinitionNSPrefix, LocalName, (currNodeType == XmlNodeType.CDATA ? "a CDATA section" : "text content"));
                        }

                        break; 
                    }
                } 
            } 
            while (!exitLoop && xmlReader.Read());
        } 

#endregion Definition Namespace processing

#region Baml Hookup Functions 

        private CodeMemberMethod EnsureStyleConnector() 
        { 
            if (_ccRoot.StyleConnectorFn == null)
            { 
                _ccRoot.StyleConnectorFn = new CodeMemberMethod();
                _ccRoot.StyleConnectorFn.Name = CONNECT;
                _ccRoot.StyleConnectorFn.Attributes = MemberAttributes.Public | MemberAttributes.Final;
                _ccRoot.StyleConnectorFn.PrivateImplementationType = new CodeTypeReference(KnownTypes.Types[(int)KnownElements.IStyleConnector]); 

                // void IStyleConnector.Connect(int connectionId, object target) { 
                // 
                CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(int), CONNECTIONID);
                CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(object), TARGET); 
                _ccRoot.StyleConnectorFn.Parameters.Add(param1);
                _ccRoot.StyleConnectorFn.Parameters.Add(param2);

                AddDebuggerNonUserCodeAttribute(_ccRoot.StyleConnectorFn); 
                AddEditorBrowsableAttribute(_ccRoot.StyleConnectorFn);
                AddSuppressMessageAttribute(_ccRoot.StyleConnectorFn, "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes"); 
 
                if (SwitchStatementSupported())
                { 
                    // switch (connectionId) -- Start Switch
                    // {
                    CodeSnippetStatement css = new CodeSnippetStatement(SWITCH_STATEMENT);
                    _ccRoot.StyleConnectorFn.Statements.Add(css); 
                }
            } 
 
            return _ccRoot.StyleConnectorFn;
        } 

        internal void ConnectStyleEvent(XamlClrEventNode xamlClrEventNode)
        {
            CodeConditionStatement ccsConnector = null; 

            // validate the event handler name per C# grammar for identifiers 
            ValidateEventHandlerName(xamlClrEventNode.EventName, xamlClrEventNode.Value); 

            EnsureStyleConnector(); 

            if (!xamlClrEventNode.IsSameScope)
            {
                int connectionId = xamlClrEventNode.ConnectionId; 
                if (SwitchStatementSupported())
                { 
                    // break any previous case staements as we are starting a new connection scope. 
                    if (_ccRoot.StyleConnectorFn.Statements.Count > 1)
                    { 
                        CodeSnippetStatement cssBreak = new CodeSnippetStatement(BREAK_STATEMENT);
                        _ccRoot.StyleConnectorFn.Statements.Add(cssBreak);
                    }
 
                    // case 1:
                    // 
                    CodeSnippetStatement cssCase = new CodeSnippetStatement(CASE_STATEMENT + connectionId + COLON); 
                    _ccRoot.StyleConnectorFn.Statements.Add(cssCase);
                } 
                else
                {
                    // if (connectionId == 1)
                    // 
                    ccsConnector = new CodeConditionStatement();
                    ccsConnector.Condition = new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression(CONNECTIONID), 
                                                                              CodeBinaryOperatorType.ValueEquality, 
                                                                              new CodePrimitiveExpression(connectionId));
                } 
            }
            else if (!SwitchStatementSupported())
            {
                // if in the same scope then use the if statement that was last generated 
                // at the start of the scope
                Debug.Assert(_ccRoot.StyleConnectorFn.Statements.Count > 0); 
                ccsConnector = _ccRoot.StyleConnectorFn.Statements[_ccRoot.StyleConnectorFn.Statements.Count - 1] as CodeConditionStatement; 
                Debug.Assert(ccsConnector != null);
            } 

            CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);

            if (xamlClrEventNode.IsStyleSetterEvent) 
            {
                // EventSetter declaration only once to avoid warning! 
                if (_ccRoot.StyleConnectorFn.Statements.Count == 0 || _ccRoot.StyleConnectorFn.Statements[0] is CodeSnippetStatement) 
                {
                    // EventSetter eventSetter; 
                    //
                    CodeVariableDeclarationStatement cvdsES = new CodeVariableDeclarationStatement(KnownTypes.Types[(int)KnownElements.EventSetter], EVENTSETTER);
                    _ccRoot.StyleConnectorFn.Statements.Insert(0, cvdsES);
                } 

 
                // eventSetter = new EventSetter(); 
                //
                CodeExpression[] esParams = {}; 
                CodeVariableReferenceExpression cvreES = new CodeVariableReferenceExpression(EVENTSETTER);
                CodeAssignStatement casES = new CodeAssignStatement(cvreES,
                                                                    new CodeObjectCreateExpression(KnownTypes.Types[(int)KnownElements.EventSetter],
                                                                                                   esParams)); 

                // eventSetter.Event = Button.ClickEvent; 
                // 
                CodePropertyReferenceExpression cpreEvent = new CodePropertyReferenceExpression(cvreES, EVENT);
                CodeAssignStatement casEvent = new CodeAssignStatement(cpreEvent, 
                                                                       GetEvent(xamlClrEventNode.EventMember,
                                                                                xamlClrEventNode.EventName,
                                                                                xamlClrEventNode.Value));
 
                // eventSetter.Handler = new RoutedEventHandler(OnClick);
                // 
                CodePropertyReferenceExpression cpreHandler = new CodePropertyReferenceExpression(cvreES, HANDLER); 
                CodeAssignStatement casHandler = new CodeAssignStatement(cpreHandler,
                                                                         GetEventDelegate(null, 
                                                                                          xamlClrEventNode.EventMember,
                                                                                          xamlClrEventNode.EventName,
                                                                                          xamlClrEventNode.Value));
 
                AddLinePragma(casHandler, xamlClrEventNode.LineNumber);
 
                // ((Style)target).Setters.Add(eventSetter); 
                //
                CodeCastExpression cceTarget = new CodeCastExpression(KnownTypes.Types[(int)KnownElements.Style], careTarget); 
                CodePropertyReferenceExpression cpreSetters = new CodePropertyReferenceExpression(cceTarget, SETTERS);
                CodeMethodInvokeExpression cmieAdd = new CodeMethodInvokeExpression(cpreSetters, ADD, cvreES);

                if (SwitchStatementSupported()) 
                {
                    _ccRoot.StyleConnectorFn.Statements.Add(casES); 
                    _ccRoot.StyleConnectorFn.Statements.Add(casEvent); 
                    _ccRoot.StyleConnectorFn.Statements.Add(casHandler);
                    _ccRoot.StyleConnectorFn.Statements.Add(new CodeExpressionStatement(cmieAdd)); 
                }
                else
                {
                    ccsConnector.TrueStatements.Add(casES); 
                    ccsConnector.TrueStatements.Add(casEvent);
                    ccsConnector.TrueStatements.Add(casHandler); 
                    ccsConnector.TrueStatements.Add(new CodeExpressionStatement(cmieAdd)); 
                    // Only add if statement at start of new scope
                    if (!xamlClrEventNode.IsSameScope) 
                    {
                        _ccRoot.StyleConnectorFn.Statements.Add(ccsConnector);
                    }
                } 
            }
            else 
            { 

                // 
                // ((Foo)target).Bar += new BarEventHandler(OnBar);
                //
                // *or*
                // 
                // ((Foo)target).AddHandler( Baz.BarEvent, new BarEventHandler(OnBar));
                // 
 
                CodeCastExpression cceTarget;
                Type eventTarget; 


                // Create the markup event information
 
                MarkupEventInfo mei = new MarkupEventInfo( xamlClrEventNode.Value,          // Event handler string
                                                           xamlClrEventNode.EventName,      // Event name string 
                                                           xamlClrEventNode.EventMember,    // MemberInfo 
                                                           xamlClrEventNode.LineNumber);    // LineNumber
 

                // Get the type that defines the event (e.g. typeof(Button) for Button.Clicked or typeof(Mouse) for Mouse.MouseMove)

                eventTarget = xamlClrEventNode.ListenerType; 

 
                // Create the type cast expression "(Foo)target" 

                cceTarget = new CodeCastExpression( eventTarget, careTarget); 


                // Create the whole code statement (either in += form or in AddHandler form)
 
                CodeStatement csAddCLREvent = AddCLREvent( eventTarget, null, cceTarget, mei );
 
                if (SwitchStatementSupported()) 
                {
                    _ccRoot.StyleConnectorFn.Statements.Add( csAddCLREvent ); 
                }
                else
                {
                    ccsConnector.TrueStatements.Add( csAddCLREvent ); 

                    // Only add if statement at start of new scope 
                    if (!xamlClrEventNode.IsSameScope) 
                    {
                        _ccRoot.StyleConnectorFn.Statements.Add(ccsConnector); 
                    }
                }
            }
        } 

        private void EndStyleEventConnection() 
        { 
            if (_ccRoot.StyleConnectorFn != null)
            { 
                _ccRoot.CodeClass.BaseTypes.Add(KnownTypes.Types[(int)KnownElements.IStyleConnector].FullName);

                if (SwitchStatementSupported())
                { 
                    // break any last case staement as we are done with style event connections.
                    if (_ccRoot.StyleConnectorFn.Statements.Count > 1) 
                    { 
                        CodeSnippetStatement cssBreak = new CodeSnippetStatement(BREAK_STATEMENT);
                        _ccRoot.StyleConnectorFn.Statements.Add(cssBreak); 
                    }

                    // switch (connectionId)
                    // { 
                    // } -- End Switch
                    CodeSnippetStatement css = new CodeSnippetStatement(INDENT12 + ENDCURLY); 
                    _ccRoot.StyleConnectorFn.Statements.Add(css); 
                }
 
                _ccRoot.CodeClass.Members.Add(_ccRoot.StyleConnectorFn);
                _ccRoot.StyleConnectorFn = null;
            }
        } 

        private void EnsureHookupFn() 
        { 
            // void IComponentConnector.Connect
            // 
            if (_ccRoot.HookupFn == null)
            {
                _ccRoot.HookupFn = new CodeMemberMethod();
                _ccRoot.HookupFn.Name = CONNECT; 
                _ccRoot.HookupFn.Attributes = MemberAttributes.Public | MemberAttributes.Final;
                _ccRoot.HookupFn.PrivateImplementationType = new CodeTypeReference(KnownTypes.Types[(int)KnownElements.IComponentConnector]); 
 
                // void IComponentConnector.Connect(int connectionId, object target) {
                // 
                CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(int), CONNECTIONID);
                CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(object), TARGET);
                _ccRoot.HookupFn.Parameters.Add(param1);
                _ccRoot.HookupFn.Parameters.Add(param2); 

                AddDebuggerNonUserCodeAttribute(_ccRoot.HookupFn); 
                AddEditorBrowsableAttribute(_ccRoot.HookupFn); 
                AddSuppressMessageAttribute(_ccRoot.HookupFn, "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes");
 
                if (SwitchStatementSupported())
                {
                    // switch (connectionId) -- Start Switch
                    // { 
                    CodeSnippetStatement css = new CodeSnippetStatement(SWITCH_STATEMENT);
                    _ccRoot.HookupFn.Statements.Add(css); 
                } 
            }
        } 

        internal void ConnectNameAndEvents(string elementName, ArrayList events, int connectionId)
        {
            CodeContext cc = (CodeContext)_codeContexts.Peek(); 
            bool isAllowedNameScope = cc.IsAllowedNameScope;
 
            if (_codeContexts.Count > 1 && KnownTypes.Types[(int)KnownElements.INameScope].IsAssignableFrom(cc.ElementType)) 
            {
                cc.IsAllowedNameScope = false; 
            }

            if ((elementName == null || !isAllowedNameScope) && (events == null || events.Count == 0))
            { 
                _typeArgsList = null;
                return; 
            } 

            EnsureHookupFn(); 

            CodeConditionStatement ccsConnector = null;

            if (SwitchStatementSupported()) 
            {
                // case 1: 
                // 
                CodeSnippetStatement cssCase = new CodeSnippetStatement(CASE_STATEMENT + connectionId + COLON);
                _ccRoot.HookupFn.Statements.Add(cssCase); 
            }
            else
            {
                // if (connectionId == 1) 
                //
                ccsConnector = new CodeConditionStatement(); 
                ccsConnector.Condition = new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression(CONNECTIONID), 
                                                                          CodeBinaryOperatorType.ValueEquality,
                                                                          new CodePrimitiveExpression(connectionId)); 
            }


            // (System.Windows.Controls.Footype)target; 
            CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);
            CodeCastExpression cceTarget = new CodeCastExpression(cc.ElementTypeReference, careTarget); 
            CodeExpression ceEvent = cceTarget; 

            // Names in nested Name scopes not be hooked up via ICC.Connect() as no fields are generated in this case. 
            if (elementName != null && isAllowedNameScope)
            {
                // this.fooId = (System.Windows.Controls.Footype)target;
                // 
                ceEvent = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), elementName);
                CodeAssignStatement casName = new CodeAssignStatement(ceEvent, cceTarget); 
                if (SwitchStatementSupported()) 
                {
                    _ccRoot.HookupFn.Statements.Add(casName); 
                }
                else
                {
                    ccsConnector.TrueStatements.Add(casName); 
                }
            } 
 
            if (events != null)
            { 
                foreach (MarkupEventInfo mei in events)
                {
                    CodeStatement csEvent = AddCLREvent(cc, ceEvent, mei);
 
                    if (SwitchStatementSupported())
                    { 
                        _ccRoot.HookupFn.Statements.Add(csEvent); 
                    }
                    else 
                    {
                        ccsConnector.TrueStatements.Add(csEvent);
                    }
                } 
            }
 
            // return; 
            //
            if (SwitchStatementSupported()) 
            {
                _ccRoot.HookupFn.Statements.Add(new CodeMethodReturnStatement());
            }
            else 
            {
                ccsConnector.TrueStatements.Add(new CodeMethodReturnStatement()); 
                _ccRoot.HookupFn.Statements.Add(ccsConnector); 
            }
 
            _typeArgsList = null;
        }

        private void EndHookups() 
        {
            if (_ccRoot.HookupFn != null) 
            { 
                _ccRoot.CodeClass.BaseTypes.Add(KnownTypes.Types[(int)KnownElements.IComponentConnector].FullName);
 
                if (SwitchStatementSupported())
                {
                    // Don't generate an empty Switch block!
                    if (_ccRoot.HookupFn.Statements.Count == 1 && 
                        _ccRoot.HookupFn.Statements[0] is CodeSnippetStatement)
                    { 
                        _ccRoot.HookupFn.Statements.Clear(); 
                    }
                    else 
                    {
                        // switch (connectionId)
                        // {
                        // } -- End Switch 
                        CodeSnippetStatement css = new CodeSnippetStatement(INDENT12 + ENDCURLY);
                        _ccRoot.HookupFn.Statements.Add(css); 
                    } 
                }
 
                // _contentLoaded = true;
                //
                CodeFieldReferenceExpression cfreContentLoaded = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), CONTENT_LOADED);
                CodeAssignStatement casContentLoaded = new CodeAssignStatement(cfreContentLoaded, new CodePrimitiveExpression(true)); 
                _ccRoot.HookupFn.Statements.Add(casContentLoaded);
 
                _ccRoot.CodeClass.Members.Add(_ccRoot.HookupFn); 
                _ccRoot.HookupFn = null;
            } 
        }

        internal void GenerateBamlFile(MemoryStream bamlMemStream)
        { 
            // write baml file only if we're not doing intellisense build
            if ((IsBamlNeeded) && (TaskFileService.IsRealBuild)) 
            { 
                string filepath = TargetPath + SourceFileInfo.RelativeSourceFilePath + BAML;
                using (FileStream bamlFileStream = new FileStream(filepath, FileMode.Create, FileAccess.Write)) 
                {
                    bamlMemStream.WriteTo(bamlFileStream);
                }
            } 
        }
 
#endregion Baml Hookup Functions 

#region Helpers 

        private void InitializeTypeMapper()
        {
            _typeMapper = XamlTypeMapper.DefaultMapper; 
            ReflectionHelper.LocalAssemblyName = AssemblyName;
            _typeMapper.SetReflectionOnlyAssemblyResolver(); 
 
            if (ReferenceAssemblyList != null && ReferenceAssemblyList.Count > 0)
            { 
                for (int i = 0; i < ReferenceAssemblyList.Count; i++)
                {
                    ReferenceAssembly refasm = ReferenceAssemblyList[i] as ReferenceAssembly;
 
                    if (refasm != null && refasm.Path.Length > 0)
                    { 
                        _typeMapper.SetAssemblyPath(refasm.AssemblyName, refasm.Path); 
                    }
                } 
            }

            string asmMissing = string.Empty;
            if (XamlTypeMapper.AssemblyWB == null) 
            {
                asmMissing = "WindowsBase"; 
            } 
            if (XamlTypeMapper.AssemblyPC == null)
            { 
                asmMissing += (asmMissing.Length > 0 ? ", " : string.Empty) + "PresentationCore";
            }
            if (XamlTypeMapper.AssemblyPF == null)
            { 
                asmMissing += (asmMissing.Length > 0 ? ", " : string.Empty) + "PresentationFramework";
            } 
 
            if (asmMissing.Length > 0)
            { 
                string message = SR.Get(SRID.WinFXAssemblyMissing, asmMissing);
                ApplicationException aeAssemblyMissing = new ApplicationException(message);
                throw aeAssemblyMissing;
            } 

            KnownTypes.InitializeKnownTypes(XamlTypeMapper.AssemblyPF, XamlTypeMapper.AssemblyPC, XamlTypeMapper.AssemblyWB); 
            _typeMapper.InitializeReferenceXmlnsCache(); 
        }
 
        private bool SwitchStatementSupported()
        {
            return (IsLanguageCSharp || (CompilerInfo != null && (string.Compare(CompilerInfo.GetLanguages()[0], JSCRIPT, StringComparison.OrdinalIgnoreCase) == 0)));
        } 

        private bool IsInternalAccessSupported 
        { 
            get
            { 
                return (CompilerInfo == null || (string.Compare(CompilerInfo.GetLanguages()[0], JSHARP, StringComparison.OrdinalIgnoreCase) != 0));
            }
        }
 
        private bool IsLanguageCaseSensitive()
        { 
            CodeDomProvider cdp = EnsureCodeProvider(); 
            return cdp.LanguageOptions != LanguageOptions.CaseInsensitive;
        } 

        private bool IsLanguageCSharp
        {
            get { return _isLangCSharp; } 
        }
 
        private bool IsLanguageVB 
        {
            get { return _isLangVB; } 
        }

        // Combine namespace and className
        private string GetFullClassName(string ns, string className) 
        {
            string fullClass = className; 
 
            if (ns != null && ns.Length > 0)
            { 
                fullClass = ns + DOT + className;
            }

            return fullClass; 
        }
 
        internal void ValidateFullSubClassName(ref string subClassFullName) 
        {
            bool isValid = false; 
            int index = subClassFullName.LastIndexOf(DOT, StringComparison.Ordinal);

            if (index > 0)
            { 
                string subClassName = subClassFullName.Substring(index + 1);
                isValid = IsValidCLRNamespace(subClassFullName.Substring(0, index), false) && 
                          IsValidClassName(subClassName); 
            }
            else 
            {
                isValid = IsValidClassName(subClassFullName);
            }
 
            if (!isValid)
            { 
                // flag error. Can't throw here as we are pre-scanning and parser context doesn't 
                // have customized linenum\linepos yet.
                subClassFullName = DOT; 
            }
        }

        private bool CrackClassName(ref string className, out string ns) 
        {
            bool isValid = true; 
            ns = string.Empty; 

            if (className.Length > 0) 
            {
                // Split the Namespace
                int index = className.LastIndexOf(DOT, StringComparison.Ordinal);
 
                if (index > 0)
                { 
                    ns = className.Substring(0, index); 
                    className = className.Substring(index + 1);
                    isValid = IsValidCLRNamespace(ns, false); 
                }

                isValid = isValid && IsValidClassName(className);
            } 

            return isValid; 
        } 

        internal string GetGenericTypeName(string typeName, string typeArgs) 
        {
            if (typeArgs.Length == 0)
            {
                ThrowCompilerException(SRID.UnknownGenericType, 
                                       DefinitionNSPrefix,
                                       typeArgs, 
                                       typeName); 
            }
 
            StringBuilder sb = new StringBuilder(typeName, 20);
            sb.Append(GENERIC_DELIMITER);

            _typeArgsList = typeArgs.Split(new Char[] { COMMA }); 

            sb.Append(_typeArgsList.Length); 
 
            return sb.ToString();
        } 

        private static void AddEditorBrowsableAttribute(CodeTypeMember ctmTarget)
        {
            CodeFieldReferenceExpression cfre = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(EditorBrowsableState)), "Never"); 
            CodeAttributeArgument caa = new CodeAttributeArgument(cfre);
            ctmTarget.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(EditorBrowsableAttribute).FullName, caa)); 
        } 

        private static void AddSuppressMessageAttribute(CodeTypeMember ctmTarget, string category, string rule) 
        {
            CodeAttributeDeclaration cad = new CodeAttributeDeclaration(
                         new CodeTypeReference(typeof(SuppressMessageAttribute)),
                         new CodeAttributeArgument(new CodePrimitiveExpression(category)), 
                         new CodeAttributeArgument(new CodePrimitiveExpression(rule)));
 
            ctmTarget.CustomAttributes.Add(cad); 
        }
 
        private static void AddDebuggerNonUserCodeAttribute(CodeTypeMember ctmTarget)
        {
            CodeAttributeDeclaration cad = new CodeAttributeDeclaration(
                         new CodeTypeReference(typeof(DebuggerNonUserCodeAttribute))); 

            ctmTarget.CustomAttributes.Add(cad); 
        } 

        internal static void GenerateXmlComments(CodeTypeMember ctm, string comment) 
        {
            // generate xml comments

            // ///  
            // /// 
            CodeCommentStatement ccs = new CodeCommentStatement(SummaryStartTag, true); 
            ctm.Comments.Add(ccs); 
            ccs = new CodeCommentStatement(comment, true);
            ctm.Comments.Add(ccs); 
            ccs = new CodeCommentStatement(SummaryEndTag, true);
            ctm.Comments.Add(ccs);
        }
 
        private bool IsValidClassName(string className)
        { 
            if (className.Length == 0 ||!NameValidationHelper.IsValidIdentifierName(className)) 
            {
                return false; 
            }

            return true;
        } 

        private bool IsValidCLRNamespace(string ns, bool shouldThrow) 
        { 
            if (ns.Length > 0)
            { 
                string[] nsParts = ns.Split(new char[] { DOTCHAR });

                foreach (string nsPart in nsParts)
                { 
                    if (!NameValidationHelper.IsValidIdentifierName(nsPart.Trim()))
                    { 
                        if (shouldThrow) 
                        {
                            ThrowCompilerException(SRID.InvalidDefaultCLRNamespace, nsPart, ns); 
                        }
                        else
                        {
                            return false; 
                        }
                    } 
                } 
            }
 
            return true;
        }

        internal void ValidateEventHandlerName(string eventName, string handlerName) 
        {
            if (!IsCodeNeeded) 
            { 
                ThrowCompilerException(SRID.MissingClassDefinitionForEvent, _ccRoot.ElementName, DefinitionNSPrefix, eventName);
            } 

            string handler = handlerName.Trim();
            if (handler.Length == 0)
            { 
                ThrowCompilerException(SRID.EmptyEventStringNotAllowed, eventName, handlerName);
            } 
            else if (!NameValidationHelper.IsValidIdentifierName(handler)) 
            {
                ThrowCompilerException(SRID.InvalidEventHandlerName, eventName, handlerName); 
            }
        }

        private string ParentFolderPrefix 
        {
            get 
            { 
                string parentFolderPrefix = string.Empty;
                if (TargetPath.StartsWith(SourceFileInfo.SourcePath, StringComparison.OrdinalIgnoreCase)) 
                {
                    string relPath = TargetPath.Substring(SourceFileInfo.SourcePath.Length);
                    relPath += SourceFileInfo.RelativeSourceFilePath;
                    string[] dirs = relPath.Split(new Char[] { ESCAPED_BACKSLASH_CHAR }); 
                    for (int i = 1; i < dirs.Length; i++)
                    { 
                        parentFolderPrefix += PARENTFOLDER; 
                    }
                } 

                return parentFolderPrefix;
            }
        } 

        private void AddLinePragma(CodeTypeMember ctm, int lineNumber) 
        { 
            CodeLinePragma clp = new CodeLinePragma(ParentFolderPrefix + SourceFileInfo.RelativeSourceFilePath + XAML, lineNumber);
            ctm.LinePragma = clp; 
        }

        private void AddLinePragma(CodeStatement cs, int lineNumber)
        { 
            CodeLinePragma clp = new CodeLinePragma(ParentFolderPrefix + SourceFileInfo.RelativeSourceFilePath + XAML, lineNumber);
            cs.LinePragma = clp; 
        } 

        internal MemberAttributes GetMemberAttributes(string modifier) 
        {
            if (!IsCodeNeeded)
            {
                ThrowCompilerException(SRID.MissingClassWithFieldModifier, DefinitionNSPrefix); 
            }
 
            if (_private.Length == 0) 
            {
                bool converted = false; 
                CodeDomProvider codeProvider = EnsureCodeProvider();
                TypeConverter converter = codeProvider.GetConverter(typeof(MemberAttributes));
                if (converter != null)
                { 
                    if (converter.CanConvertTo(typeof(string)))
                    { 
                        try 
                        {
                            _private = converter.ConvertToInvariantString(MemberAttributes.Private).ToLowerInvariant(); 
                            _public = converter.ConvertToInvariantString(MemberAttributes.Public).ToLowerInvariant();
                            _protected = converter.ConvertToInvariantString(MemberAttributes.Family).ToLowerInvariant();
                            _internal = converter.ConvertToInvariantString(MemberAttributes.Assembly).ToLowerInvariant();
                            _protectedInternal = converter.ConvertToInvariantString(MemberAttributes.FamilyOrAssembly).ToLowerInvariant(); 
                            converted = true;
                        } 
                        catch (NotSupportedException) 
                        {
                        } 
                    }
                }

                if (!converted) 
                {
                    ThrowCompilerException(SRID.UnknownFieldModifier, MarkupCompiler.DefinitionNSPrefix, modifier, _language); 
                } 
            }
 
            string normalizedModifier = modifier;
            if (!IsLanguageCaseSensitive())
            {
                normalizedModifier = modifier.ToLowerInvariant(); 
            }
 
            if (normalizedModifier.Equals(_private)) 
            {
                return MemberAttributes.Private; 
            }
            else if (normalizedModifier.Equals(_public))
            {
                return MemberAttributes.Public; 
            }
            else if (normalizedModifier.Equals(_protected)) 
            { 
                return MemberAttributes.Family;
            } 
            else if (normalizedModifier.Equals(_internal))
            {
                return MemberAttributes.Assembly;
            } 
            else if (normalizedModifier.Equals(_protectedInternal))
            { 
                return MemberAttributes.FamilyOrAssembly; 
            }
            else 
            {
                ThrowCompilerException(SRID.UnknownFieldModifier, MarkupCompiler.DefinitionNSPrefix, modifier, _language);
            }
 
            return MemberAttributes.Assembly;
        } 
 
        private TypeAttributes GetTypeAttributes(ref string modifier)
        { 
            if (modifier.Length > 0)
            {
                if (_privateClass.Length == 0)
                { 
                    bool converted = false;
                    CodeDomProvider codeProvider = EnsureCodeProvider(); 
                    TypeConverter converter = codeProvider.GetConverter(typeof(TypeAttributes)); 
                    if (converter != null)
                    { 
                        if (converter.CanConvertTo(typeof(string)))
                        {
                            try
                            { 
                                _privateClass = converter.ConvertToInvariantString(TypeAttributes.NotPublic).ToLowerInvariant();
                                _publicClass = converter.ConvertToInvariantString(TypeAttributes.Public).ToLowerInvariant(); 
                                converted = true; 
                            }
                            catch (NotSupportedException) 
                            {
                            }
                        }
                    } 

                    if (!converted) 
                    { 
                        ThrowCompilerException(SRID.UnknownClassModifier, MarkupCompiler.DefinitionNSPrefix, modifier, _language);
                    } 
                }

                string normalizedModifier = modifier;
                if (!IsLanguageCaseSensitive()) 
                {
                    normalizedModifier = modifier.ToLowerInvariant(); 
                } 

                if (normalizedModifier.Equals(_privateClass)) 
                {
                    return TypeAttributes.NotPublic;
                }
                else if (normalizedModifier.Equals(_publicClass)) 
                {
                    return TypeAttributes.Public; 
                } 
                else
                { 
                    // flag error. Can't throw here as we are pre-scanning and parser context doesn't
                    // have customized linenum\linepos yet.
                    modifier = DOT;
                } 
            }
 
            return TypeAttributes.Public; 
        }
 
        internal void CheckForNestedNameScope()
        {
            CodeContext cc = (CodeContext)_codeContexts.Peek();
            if (_codeContexts.Count > 1 && KnownTypes.Types[(int)KnownElements.INameScope].IsAssignableFrom(cc.ElementType)) 
            {
                cc.IsAllowedNameScope = false; 
            } 
        }
 
#endregion Helpers

#region Property
 
        private CodeExpression GetPropertyValueExpression(ITypeDescriptorContext ctx, Type typeToConvertTo, Object value, string attributeValue)
        { 
            CodeExpression ce = null; 
            InstanceDescriptor desc = null;
            TypeConverter converter = null; 

            if (value != null && (typeToConvertTo == typeof(String) || typeToConvertTo.IsPrimitive))
            {
                ce = new CodePrimitiveExpression(value); 
            }
            else if (typeToConvertTo == typeof(Uri)) 
            { 
                converter = new UriTypeConverter();
                if (!UriParser.IsKnownScheme(URISCHEME_PACK)) 
                {
                    UriParser.Register(new GenericUriParser(GenericUriParserOptions.GenericAuthority), URISCHEME_PACK, -1);
                }
            } 
            else if (typeToConvertTo.IsEnum)
            { 
                converter = new EnumConverter(typeToConvertTo); 
            }
 
            if (converter != null)
            {
                if (value == null)
                { 
                    if (attributeValue != null)
                    { 
                        value = converter.ConvertFromString(ctx, TypeConverterHelper.EnglishUSCulture, attributeValue); 

                        if (value == null) 
                        {
                            return null;
                        }
                    } 
                    else
                    { 
                        ce = new CodePrimitiveExpression(null); 
                        return ce;
                    } 
                }

                if (converter.CanConvertTo(ctx, typeof(InstanceDescriptor)))
                { 
                    desc = (InstanceDescriptor)converter.ConvertTo(ctx, TypeConverterHelper.EnglishUSCulture, value, typeof(InstanceDescriptor));
 
                    Debug.Assert(desc != null); 

                    // static field ref... 
                    if (desc.MemberInfo is FieldInfo || desc.MemberInfo is PropertyInfo)
                    {
                        CodeFieldReferenceExpression cfre = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
                        ce = cfre; 
                    }
                    else  // static method invoke 
                    { 
                        object[] args = new object[desc.Arguments.Count];
                        desc.Arguments.CopyTo(args, 0); 
                        CodeExpression[] expressions = new CodeExpression[args.Length];

                        if (desc.MemberInfo is MethodInfo)
                        { 
                            MethodInfo mi = (MethodInfo)desc.MemberInfo;
                            ParameterInfo[] parameters = mi.GetParameters(); 
 
                            for (int i = 0; i < args.Length; i++)
                            { 
                                expressions[i] = GetPropertyValueExpression(ctx, parameters[i].ParameterType, args[i], null);
                            }

                            CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name); 
                            foreach (CodeExpression e in expressions)
                            { 
                                cmie.Parameters.Add(e); 
                            }
 
                            ce = cmie;
                        }
                        else if (desc.MemberInfo is ConstructorInfo)  // instance ctor invoke
                        { 
                            ConstructorInfo ci = (ConstructorInfo)desc.MemberInfo;
                            ParameterInfo[] parameters = ci.GetParameters(); 
 
                            for (int i = 0; i < args.Length; i++)
                            { 
                                expressions[i] = GetPropertyValueExpression(ctx, parameters[i].ParameterType, args[i], null);
                            }

                            CodeObjectCreateExpression coce = new CodeObjectCreateExpression(desc.MemberInfo.DeclaringType.FullName); 
                            foreach (CodeExpression e in expressions)
                            { 
                                coce.Parameters.Add(e); 
                            }
 
                            ce = coce;
                        }
                    }
                } 
            }
 
            return ce; 
        }
 
#endregion Property

#region Event
 
        // The given MemberInfo could either be an EventInfo for a Clr event or a
        // MethodInfo for a static Add{EventName}Handler helper for an attached event 
        private Type GetEventHandlerType(MemberInfo memberInfo) 
        {
            Type eventHandlerType = null; 
            if (memberInfo is EventInfo)
            {
                EventInfo ei = (EventInfo)memberInfo;
                eventHandlerType = ei.EventHandlerType; 
            }
            else 
            { 
                MethodInfo mi = (MethodInfo)memberInfo;
                ParameterInfo[] pis = mi.GetParameters(); 
                Debug.Assert(pis != null && pis.Length == 2 && KnownTypes.Types[(int)KnownElements.DependencyObject].IsAssignableFrom(pis[0].ParameterType));
                eventHandlerType = pis[1].ParameterType;
            }
 
            return eventHandlerType;
        } 
 
        private CodeFieldReferenceExpression GetEvent(MemberInfo miEvent, string eventName, string eventHandler)
        { 
            FieldInfo fiEvent = miEvent.DeclaringType.GetField(eventName + EVENT, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
            if (fiEvent == null || fiEvent.FieldType != KnownTypes.Types[(int)KnownElements.RoutedEvent])
            {
                ThrowCompilerException(SRID.RoutedEventNotRegistered, miEvent.DeclaringType.FullName, eventName, eventHandler); 
            }
 
            CodeTypeReferenceExpression ctreEvent = new CodeTypeReferenceExpression(miEvent.DeclaringType.FullName); 
            CodeFieldReferenceExpression cfreEvent = new CodeFieldReferenceExpression(ctreEvent, fiEvent.Name);
            return cfreEvent; 
        }


        private CodeExpression GetEventDelegate(CodeContext cc, MemberInfo miEvent, string eventName, string eventHandler) 
        {
            Type eventTarget = cc != null ? cc.ElementType : miEvent.DeclaringType; 
            string eventTargetName = eventTarget != null ? eventTarget.FullName : cc.LocalElementFullName; 

            bool subClassed = _ccRoot.SubClass.Length > 0; 
            CodeDelegateCreateExpression cdce = new CodeDelegateCreateExpression();

            // Fetch the EventHandlerType from either the EventInfo or the MethodInfo
            // for the Add{Propertyname}Handler method's MethodInfo 
            Type eventHandlerType = GetEventHandlerType(miEvent);
            string [] typeArgsList = cc != null ? cc.GenericTypeArgs : null; 
 
            cdce.DelegateType = GenerateConstructedTypeReference(eventHandlerType, typeArgsList, eventTarget, eventTargetName, eventName);
            cdce.MethodName = eventHandler.Trim() + (subClassed ? HELPER : string.Empty); 
            cdce.TargetObject = new CodeThisReferenceExpression();
            CodeExpression cDelExp = cdce;

            // NOTE: workaround for VB CodeDom bug which does not produce correct Delegate expression code 
            if (IsLanguageVB)
            { 
                CodeExpression[] delParams = { cdce }; 
                CodeObjectCreateExpression coce = new CodeObjectCreateExpression(eventHandlerType, delParams);
                cDelExp = coce; 
            }

//            The bug that this chunk of code works around (VS#542946) was fixed but
//            exposes a different bug (VS#572060)   To work around the second bug, we 
//            remove the workaround for the first one.  (RogerCh 20020918)
 
//            Note that #542946 was not fixed for VB, so the code block above remains. 

//            else if (Language == CompilerLanguage.JScript) 
//            {
//                CodeCastExpression cce = new CodeCastExpression(mei.ei.EventHandlerType, cdce);
//                cDelExp = cce;
//            } 

            return cDelExp; 
        } 

 
        private CodeStatement AddCLREvent(CodeContext cc, CodeExpression ce, MarkupEventInfo mei)
        {
            // Infer the event target's (aka the listener) type from the current code context
            return AddCLREvent( cc.ElementType, cc, ce, mei ); 
        }
 
        private CodeStatement AddCLREvent(Type eventTarget, CodeContext cc, CodeExpression ce, MarkupEventInfo mei) 
        {
 
            bool subClassed = _ccRoot.SubClass.Length > 0;
            CodeStatement csEvent = null;
            // param2: 
            CodeExpression cDelExp = GetEventDelegate(cc, mei.mi, mei.eventName, mei.eventHandler); 

            if (mei.mi.DeclaringType.IsAssignableFrom(eventTarget)) 
            { 
                // _element.FooEvent += new FooEventHandlerDelegate(OnFoo);
                csEvent = new CodeAttachEventStatement(ce, mei.eventName, cDelExp); 
            }
            else if (eventTarget == null || // for known attached events on unknown local tags
                     KnownTypes.Types[(int)KnownElements.UIElement].IsAssignableFrom(eventTarget) ||
                     KnownTypes.Types[(int)KnownElements.ContentElement].IsAssignableFrom(eventTarget)) 
            {
                // _element.AddHandler(FooEvent, new FooEventHandlerDelegate(OnFoo)); 
                CodeFieldReferenceExpression cfreEvent = GetEvent(mei.mi, mei.eventName, mei.eventHandler); 
                CodeMethodInvokeExpression cmieAddHandler = new CodeMethodInvokeExpression(ce, ADDHANDLER, cfreEvent, cDelExp);
                csEvent = new CodeExpressionStatement(cmieAddHandler); 
            }
            else
            {
                string eventTargetName = eventTarget != null ? eventTarget.FullName : cc.LocalElementFullName; 
                ThrowCompilerException(SRID.UnknownEventAttribute, mei.eventName, mei.eventHandler, eventTargetName);
            } 
 
            // When x:SubClass is used, event handlers can be specified in a code-behind file, under this sub class.
            // But these handler methods need to be accessible from the intermediary generated sub class. So an empty 
            // internal virtual method with the same signature as the handler method is generated in this intermediary
            // sub class (in the generated file):
            //
            //      internal virtual void OnFooEvent(object sender, FooEventArgs ea) 
            //      {
            //      } 
            // 
            // Since a delegate cannot take the address of a virtual function, a non-virtual helper function
            // with the same signature as the above function & which calls the above function is also generated: 
            //
            //      private void OnFooEventHelper(object sender, FooEventArgs ea)
            //      {
            //          OnFooEvent(sender, ea); 
            //      }
            // 
            // All this is done only if x:Subclass is specified, since this means that this sub class would need to be 
            // defined in a code-behind file. This also means that inline events (in ) will not be supported.
 
            if (subClassed)
            {
                GenerateProtectedEventHandlerMethod(mei);
            } 

            AddLinePragma(csEvent, mei.lineNumber); 
            return csEvent; 
        }
 
        private void GenerateProtectedEventHandlerMethod(MarkupEventInfo mei)
        {
            Debug.Assert(_ccRoot != null && _ccRoot.SubClass.Length > 0);
 
            // Fetch the EventHandlerType from either the EventInfo or the MethodInfo
            // for the Add{Propertyname}Handler method's MethodInfo 
            Type eventHandlerType = GetEventHandlerType(mei.mi); 

            MethodInfo methodInvoke = eventHandlerType.GetMethod("Invoke"); 
            ParameterInfo[] pars = methodInvoke.GetParameters();

            CodeMemberMethod cmmEventHandler = new CodeMemberMethod();
            CodeMemberMethod cmmEventHandlerHelper = new CodeMemberMethod(); 

            AddDebuggerNonUserCodeAttribute(cmmEventHandlerHelper); 
 
            cmmEventHandler.Attributes = MemberAttributes.Assembly | MemberAttributes.Overloaded;
            cmmEventHandler.ReturnType = new CodeTypeReference(typeof(void)); 
            cmmEventHandler.Name = mei.eventHandler.Trim();

            CodeMethodInvokeExpression cmieOnEvent = new CodeMethodInvokeExpression(null, cmmEventHandler.Name);
 
            for (int i = 0; i < pars.Length; i++)
            { 
                CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(pars[i].ParameterType, pars[i].Name); 
                cmmEventHandler.Parameters.Add(param);
                cmmEventHandlerHelper.Parameters.Add(param); 
                cmieOnEvent.Parameters.Add(new CodeArgumentReferenceExpression(pars[i].Name));
            }

            // 
            // internal virtual void OnFooEvent(object sender, FooEventArgs ea)
            // { 
            // } 
            //
            _ccRoot.CodeClass.Members.Add(cmmEventHandler); 

            cmmEventHandlerHelper.Name = cmmEventHandler.Name + HELPER;
            cmmEventHandlerHelper.ReturnType = new CodeTypeReference(typeof(void));
            cmmEventHandlerHelper.Statements.Add(new CodeExpressionStatement(cmieOnEvent)); 

            // 
            // private void OnFooEventHelper(object sender, FooEventArgs ea) 
            // {
            //     OnFooEvent(sender, ea); 
            // }
            //
            _ccRoot.CodeClass.Members.Add(cmmEventHandlerHelper);
        } 

        internal struct MarkupEventInfo 
        { 
            internal MarkupEventInfo(string eh, string en, MemberInfo mi, int ln)
            { 
                eventHandler = eh;
                eventName = en;
                this.mi = mi;
                lineNumber = ln; 
            }
 
            internal string eventHandler; 
            internal string eventName;
            internal MemberInfo mi; 
            internal int lineNumber;
        }

#endregion Event 

#region Language 
 
        private CodeDomProvider EnsureCodeProvider()
        { 
            if (_codeProvider == null)
            {
                Debug.Assert(CompilerInfo != null && CompilerInfo.IsCodeDomProviderTypeValid);
                _codeProvider = CompilerInfo.CreateProvider(); 
            }
 
            return _codeProvider; 
        }
 
        private bool IsLanguageSupported(string language)
        {
            _language = language;
            _isLangCSharp = string.Compare(language, CSHARP, StringComparison.OrdinalIgnoreCase) == 0; 

            if (IsLanguageCSharp) 
            { 
                _codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
                return true; 
            }
            else
            {
                _isLangVB = string.Compare(language, VB, StringComparison.OrdinalIgnoreCase) == 0; 
                if (IsLanguageVB)
                { 
                    _codeProvider = new Microsoft.VisualBasic.VBCodeProvider(); 
                    return true;
                } 
            }

            if (CodeDomProvider.IsDefinedLanguage(language))
            { 
                CompilerInfo = CodeDomProvider.GetCompilerInfo(language);
                return (CompilerInfo != null); 
            } 

            return false; 
        }

        //
        private void EnsureLanguageSourceExtension() 
        {
            // If empty string is passed, use the default language source extension. 
            if (String.IsNullOrEmpty(LanguageSourceExtension)) 
            {
                if (CompilerInfo != null) 
                {
                    string[] listExtensions = CompilerInfo.GetExtensions();
                    LanguageSourceExtension = listExtensions[0];
                } 
                else if (IsLanguageCSharp)
                { 
                    LanguageSourceExtension = ".cs"; 
                }
                else if (IsLanguageVB) 
                {
                    LanguageSourceExtension = ".vb";
                }
            } 
        }
 
#endregion Language 

#region CorePageGen 

        internal CodeMemberField AddNameField(string name, int lineNumber)
        {
            CodeMemberField cmField = AddNameField(name); 
            if (cmField != null)
            { 
                AddLinePragma(cmField, lineNumber); 
            }
            return cmField; 
        }

        internal CodeMemberField AddNameField(string name)
        { 
            // Names in nested Name scopes should not have Name fields
            CodeContext cc = (CodeContext)_codeContexts.Peek(); 
            if (!cc.IsAllowedNameScope) 
            {
                return null; 
            }

            CodeMemberField field = new CodeMemberField();
            field.Name = name; 
            field.Attributes = MemberAttributes.Assembly;
            field.Type = cc.ElementTypeReference; 
 
            // Generate WithEvents ID fields in VB for objects supporting events
            field.UserData["WithEvents"] = true; 

            _ccRoot.CodeClass.Members.Add(field);
            return field;
        } 

        private void AddCodeSnippet(string codeText, int lineNum) 
        { 
            if (codeText == null || codeText.Trim().Length == 0)
                return; 

            CodeSnippetTypeMember snippet = new CodeSnippetTypeMember();
            AddLinePragma(snippet, lineNum);
            snippet.Text = codeText; 
            _ccRoot.CodeClass.Members.Add(snippet);
        } 
 
        internal void AddGenericArguments(ParserContext parserContext, string typeArgs)
        { 
            if (_typeArgsList != null)
            {
                string localTypeArgNamespace = string.Empty;
                string localTypeArgClassName = string.Empty; 

                // for each generic param in this Type ... 
                for (int i = 0; i < _typeArgsList.Length; i++) 
                {
                    Type currTypeArg = parserContext.XamlTypeMapper.GetTypeArgsType(_typeArgsList[i].Trim(), 
                                                                                    parserContext,
                                                                                    out localTypeArgClassName,
                                                                                    out localTypeArgNamespace);
 
                    if (currTypeArg == null)
                    { 
                        bool error = false; 
                        if (localTypeArgNamespace.Length == 0 && localTypeArgClassName.Length == 0)
                        { 
                            error = true;
                        }
                        else
                        { 
                            error = !IsValidClassName(localTypeArgClassName) ||
                                    !IsValidCLRNamespace(localTypeArgNamespace, false); 
                        } 

                        if (error) 
                        {
                            ThrowCompilerException(SRID.InvalidTypeName,
                                                   MarkupCompiler.DefinitionNSPrefix,
                                                   typeArgs, 
                                                   _typeArgsList[i].Trim(),
                                                   (i + 1).ToString(CultureInfo.CurrentCulture)); 
                        } 
                        else
                        { 
                            _typeArgsList[i] = GetFullClassName(localTypeArgNamespace, localTypeArgClassName);
                        }
                    }
                    else 
                    {
                        _typeArgsList[i] = currTypeArg.FullName; 
                    } 

                    // construct the type args list for the base class type to be generated 
                    _ccRoot.CodeClass.BaseTypes[0].TypeArguments.Add(new CodeTypeReference(_typeArgsList[i]));
                }
            }
        } 

        private static CodeTypeReference GenerateConstructedTypeReference(Type t, string [] typeArgsList, string genericName) 
        { 
            CodeTypeReference ctrConstructedType = null;
 
            // If the type has generic parameters, then need to add TypeArguments to the CodeTypeReference of this Type
            if (genericName.Length > 0 || t.IsGenericType)
            {
                Debug.Assert(genericName.Length > 0 || t.IsGenericTypeDefinition); 

                if (t != null) 
                { 
                    Debug.Assert(genericName.Length == 0 && typeArgsList != null);
 
                    // NOTE: Remove when CodeDom is fixed to understand mangled generic names.
                    genericName = t.FullName;
                    int bang = genericName.IndexOf(GENERIC_DELIMITER, StringComparison.Ordinal);
                    if (bang > 0) 
                    {
                        genericName = genericName.Substring(0, bang); 
                    } 
#if DBG
                    Type[] typeParams = t.GetGenericArguments(); 

                    // TypeArgument count must match TypeParameter count on generic type.
                    Debug.Assert(typeArgsList != null && typeArgsList.Length == typeParams.Length);
 
                    // for each generic param in this Type ...
                    for (int i = 0; i < typeArgsList.Length; i++) 
                    { 
                        // Type params should always be unbound
                        Debug.Assert(typeParams[i].IsGenericParameter); 
                    }
#endif
                }
 
                ctrConstructedType = new CodeTypeReference(genericName);
            } 
            else 
            {
                ctrConstructedType = new CodeTypeReference(t.FullName); 
            }

            return ctrConstructedType;
        } 

        private static CodeTypeReference GenerateConstructedTypeReference(Type t, string [] typeArgsList, Type refType, string refTypeFullName, string eventName) 
        { 
            CodeTypeReference ctrConstructedType = null;
 
            // If the type has generic parameters, then need to add TypeArguments to the CodeTypeReference of this Type
            if (t.IsGenericType)
            {
                Type[] refTypeParams = null; 
                CodeTypeReference ctrTypeArg = null;
                Type[] typeParams = t.GetGenericArguments(); 
 
                // NOTE: Remove when CodeDom is fixed to understand mangled generic names.
                string genericName = t.Namespace + DOT + t.Name; 
                int bang = genericName.IndexOf(GENERIC_DELIMITER, StringComparison.Ordinal);
                if (bang > 0)
                {
                    genericName = genericName.Substring(0, bang); 
                }
 
                ctrConstructedType = new CodeTypeReference(genericName); 

                // NOTE: For certain types like EventHandler delegate types, CodeDom seems 
                // to add bogus CodeTypeReferences as TypeArguments, so it needs to be cleared explicitly.
                ctrConstructedType.TypeArguments.Clear();

                // for each generic param in this Type ... 
                foreach (Type typeParam in typeParams)
                { 
                    // if the param is unbound 
                    if (typeParam.IsGenericParameter)
                    { 
                        // get the generic params of the containing\reference Type, only once
                        if (refTypeParams == null)
                        {
                            if (refType == null || !refType.IsGenericType || !refType.IsGenericTypeDefinition || typeArgsList == null) 
                            {
                                ThrowCompilerException(SRID.ContainingTagNotGeneric, eventName, ctrConstructedType.BaseType, refTypeFullName); 
                            } 

                            refTypeParams = refType.GetGenericArguments(); 
                        }

                        ctrTypeArg = null;
 
                        // for each reference generic param
                        for (int i = 0; i < refTypeParams.Length; i++) 
                        { 
                            // if it matches the current generic param of this Type
                            if (refTypeParams[i] == typeParam) 
                            {
                                // The TypeArgumentList must have already been populated with full Type names &
                                // the TypeArgument count must match TypeParameter count on generic reference type.
                                Debug.Assert(typeArgsList != null && typeArgsList.Length == refTypeParams.Length); 

                                // Find the Type argument from the list that is in the same position as generic Type param 
                                string currTypeArg = typeArgsList[i]; 

                                // and create a CodeTypeReference from it 
                                ctrTypeArg = new CodeTypeReference(currTypeArg);
                                break;
                            }
                        } 

                        // no match! 
                        if (ctrTypeArg == null) 
                        {
                            ThrowCompilerException(SRID.MatchingTypeArgsNotFoundInRefType, 
                                                   eventName,
                                                   ctrConstructedType.BaseType,
                                                   typeParam.FullName,
                                                   refTypeFullName + "<" + string.Join(",", typeArgsList) + ">"); 
                        }
                    } 
                    else 
                    {
                        ctrTypeArg = new CodeTypeReference(typeParam); 
                    }

                    // construct the type args list for the base class type to be generated
                    ctrConstructedType.TypeArguments.Add(ctrTypeArg); 
                }
            } 
            else 
            {
                ctrConstructedType = new CodeTypeReference(t.FullName); 
            }

            return ctrConstructedType;
        } 

        private CodeTypeDeclaration GenerateClass(string className, ref string modifier, Type baseClass, string baseClassFullName) 
        { 
            // public class MyClass : BaseClass {
            // 
            CodeTypeReference ctrBaseClass = null;
            CodeTypeDeclaration ctdClass = new CodeTypeDeclaration();
            ctdClass.Name = className;
            if (baseClass != null) 
            {
                // At this point, we should only have fully open generic types if there is a typeargs list. 
                Debug.Assert(_typeArgsList == null || (baseClass.IsGenericType && baseClass.IsGenericTypeDefinition)); 
                Debug.Assert(_typeArgsList != null || !baseClass.IsGenericType);
 
                ctrBaseClass = GenerateConstructedTypeReference(baseClass, _typeArgsList, string.Empty);

                // Add the type reference for the normal or fully constructed generic base class
                ctdClass.BaseTypes.Add(ctrBaseClass); 
            }
            else if (baseClassFullName.Length > 0) 
            { 
                ctrBaseClass = GenerateConstructedTypeReference(null, _typeArgsList, baseClassFullName);
 
                // Add the type reference for the local base class
                ctdClass.BaseTypes.Add(ctrBaseClass);
            }
 
            ctdClass.TypeAttributes = GetTypeAttributes(ref modifier);
            ctdClass.Members.Clear(); 
 
            if (TypeAttributes.Public == ctdClass.TypeAttributes)
            { 
                GenerateXmlComments(ctdClass, className);
            }

            // VBNOTE: The VB compiler will generate a ctor with an InitializeComponent call if not explicitly specified 
            // by the user if this Attribute is set on the class.
            if (IsLanguageVB && !IsCompilingEntryPointClass) 
            { 
                ctdClass.CustomAttributes.Add(new CodeAttributeDeclaration("Microsoft.VisualBasic.CompilerServices.DesignerGenerated"));
            } 

            return ctdClass;
        }
 
        private CodeContext GenerateSubClass(ref string className, ref string modifier, Type baseClass, string baseClassFullName)
        { 
            string ns = string.Empty; 
            string baseClassName = string.Empty;
            bool isValidClassName = CrackClassName(ref className, out ns); 

            if (!string.IsNullOrEmpty(baseClassFullName))
            {
                int dotIndex = baseClassFullName.LastIndexOf(DOTCHAR); 
                if (dotIndex != -1)
                { 
                    baseClassName = baseClassFullName.Substring(dotIndex + 1); 
                    if (!IsValidClassName(baseClassName))
                    { 
                        ThrowCompilerException(SRID.InvalidBaseClassName, baseClassName);
                    }
                    string bns = baseClassFullName.Substring(0, dotIndex);
                    if (!IsValidCLRNamespace(bns, false)) 
                    {
                        ThrowCompilerException(SRID.InvalidBaseClassNamespace, bns, baseClassName); 
                    } 
                }
            } 

            if (!isValidClassName)
            {
                // flag error. Can't throw here as we are pre-scanning and parser context doesn't 
                // have customized linenum\linepos yet.
                className = DOT; 
            } 
            else if (IsCompilingEntryPointClass && className.Length == 0)
            { 
                string baseName = baseClass != null ? baseClass.Name : baseClassName;
                className = ANONYMOUS_ENTRYCLASS_PREFIX + baseName;
                Debug.Assert(!string.IsNullOrEmpty(baseName));
                ns = XamlTypeMapper.GeneratedNamespace; 
            }
 
            // namespace MyNamespace 
            // {
            Debug.Assert(_ccRoot == null); 
            Debug.Assert(_codeContexts == null || _codeContexts.Count == 0, "mismatched CodeContexts");
            CodeNamespace cns = new CodeNamespace();
            cns.Name = ns;
            cns.Types.Clear(); 

            CodeTypeDeclaration ctdClass = GenerateClass(className, ref modifier, baseClass, baseClassFullName); 
            CodeContext cc = new CodeContextRoot(ctdClass, cns, baseClass, _typeArgsList, baseClassFullName); 
            cc.ElementTypeReference = new CodeTypeReference(GetFullClassName(ns, className));
 
            return cc;
        }

        private void GenerateCreateDelegateHelper() 
        {
            if (!IsInternalAccessSupported || !HasLocalEvent) 
            { 
                return;
            } 

            Debug.Assert(HasLocalReference, "if we have a local event, there should be a local mapping PI for it");

            // internal Delegate _CreateDelegate(Type delegateType, string handler) 
            // {
            //     return Delegate.CreateDelegate(delegateType, this, handler); 
            // } 
            //
            CodeMemberMethod cmmCD = new CodeMemberMethod(); 
            cmmCD.Name = CREATEDELEGATEHELPER;
            cmmCD.ReturnType = new CodeTypeReference(typeof(Delegate));
            cmmCD.Attributes = MemberAttributes.Assembly | MemberAttributes.Final;
            AddDebuggerNonUserCodeAttribute(cmmCD); 
            AddSuppressMessageAttribute(cmmCD, "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode");
 
            CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(Type), DELEGATETYPE); 
            CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(string), HANDLERARG);
            cmmCD.Parameters.Add(param1); 
            cmmCD.Parameters.Add(param2);

            CodeMethodReferenceExpression cmreCD = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Delegate)), "CreateDelegate");
            CodeMethodInvokeExpression cmieCD = new CodeMethodInvokeExpression(); 
            cmieCD.Method = cmreCD;
            cmieCD.Parameters.Add(new CodeArgumentReferenceExpression(DELEGATETYPE)); 
            cmieCD.Parameters.Add(new CodeThisReferenceExpression()); 
            cmieCD.Parameters.Add(new CodeArgumentReferenceExpression(HANDLERARG));
 
            cmmCD.Statements.Add(new CodeMethodReturnStatement(cmieCD));
            _ccRoot.CodeClass.Members.Add(cmmCD);
        }
 
        private void GenerateInitializeComponent(bool isApp)
        { 
            // public void InitializeComponent() 
            // {
            // 
            CodeMemberMethod cmmLC = _ccRoot.InitializeComponentFn;

            if (cmmLC == null)
            { 
                cmmLC = _ccRoot.EnsureInitializeComponentFn;
                if (!isApp) 
                { 
                    cmmLC.ImplementationTypes.Add(new CodeTypeReference(KnownTypes.Types[(int)KnownElements.IComponentConnector]));
                } 
            }

            //     if (_contentLoaded)
            //     { 
            //         return;
            //     } 
            // 
            CodeConditionStatement ccsCL = new CodeConditionStatement();
            ccsCL.Condition = new CodeFieldReferenceExpression(null, CONTENT_LOADED); 
            ccsCL.TrueStatements.Add(new CodeMethodReturnStatement());
            if (!isApp)
            {
                cmmLC.Statements.Add(ccsCL); 
            }
            else 
            { 
                cmmLC.Statements.Insert(0, ccsCL);
            } 

            //     _contentLoaded = true;
            //
            CodeAssignStatement casCL = new CodeAssignStatement(new CodeFieldReferenceExpression(null, CONTENT_LOADED), 
                                                                new CodePrimitiveExpression(true));
            if (!isApp) 
            { 
                cmmLC.Statements.Add(casCL);
            } 
            else
            {
                cmmLC.Statements.Insert(1, casCL);
            } 

            // Generate canonicalized string as resource id. 
            string resourceID = ResourceIDHelper.GetResourceIDFromRelativePath(SourceFileInfo.RelativeSourceFilePath + XAML); 
            string uriPart = string.Empty;
 
            string version = String.IsNullOrEmpty(AssemblyVersion) ? String.Empty : COMPONENT_DELIMITER + VER + AssemblyVersion;
            string token = String.IsNullOrEmpty(AssemblyPublicKeyToken) ? String.Empty : COMPONENT_DELIMITER + AssemblyPublicKeyToken;
            uriPart = FORWARDSLASH + AssemblyName + version + token + COMPONENT_DELIMITER + COMPONENT + FORWARDSLASH + resourceID;
 
            //
            //  Uri resourceLocator = new Uri(uriPart, UriKind.Relative); 
            // 
            string resVarname = RESOURCE_LOCATER;
 
            CodeFieldReferenceExpression cfreRelUri = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(System.UriKind)), "Relative");

            CodeExpression[] uriParams = { new CodePrimitiveExpression(uriPart), cfreRelUri };
            CodeObjectCreateExpression coceResourceLocator = new CodeObjectCreateExpression(typeof(System.Uri), uriParams); 
            CodeVariableDeclarationStatement cvdsresLocator = new CodeVariableDeclarationStatement(typeof(System.Uri), resVarname, coceResourceLocator);
 
            cmmLC.Statements.Add(cvdsresLocator); 

            // 
            //  System.Windows.Application.LoadComponent(this, resourceLocator);
            //
            CodeMethodReferenceExpression cmreLoadContent = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(KnownTypes.Types[(int)KnownElements.Application]), LOADCOMPONENT);
            CodeMethodInvokeExpression cmieLoadContent = new CodeMethodInvokeExpression(); 

            cmieLoadContent.Method = cmreLoadContent; 
 
            CodeVariableReferenceExpression cvreMemStm = new CodeVariableReferenceExpression(resVarname);
 
            cmieLoadContent.Parameters.Add(new CodeThisReferenceExpression());
            cmieLoadContent.Parameters.Add(cvreMemStm);

            CodeExpressionStatement cesLC = new CodeExpressionStatement(cmieLoadContent); 
            AddLinePragma(cesLC, 1);
            cmmLC.Statements.Add(cesLC); 
 
            // private bool _contentLoaded;
            // 
            CodeMemberField cmfCL = new CodeMemberField();
            cmfCL.Name = CONTENT_LOADED;
            cmfCL.Attributes = MemberAttributes.Private;
            cmfCL.Type = new CodeTypeReference(typeof(bool)); 
            _ccRoot.CodeClass.Members.Add(cmfCL);
 
            if (!isApp) 
            {
                // Make sure that ICC.Connect is generated to avoid compilation errors 
                EnsureHookupFn();
            }
        }
 
        private void GenerateInternalTypeHelperImplementation()
        { 
            if (!IsInternalAccessSupported || 
                !(HasInternals || HasLocalReference) ||
                _hasGeneratedInternalTypeHelper) 
            {
                return;
            }
 
            _hasGeneratedInternalTypeHelper = true;
 
            // namespace XamlGeneratedNamespace 
            // {
            // 
            CodeNamespace cns = new CodeNamespace();
            cns.Name = XamlTypeMapper.GeneratedNamespace;

            //     [EditorBrowsable(EditorBrowsableState.Never)] 
            //     public sealed class GeneratedInternalTypeHelper : InternalTypeHelper
            //     { 
            // 
            CodeTypeDeclaration ctdClass = new CodeTypeDeclaration();
            ctdClass.Name = XamlTypeMapper.GeneratedInternalTypeHelperClassName; 
            ctdClass.BaseTypes.Add(new CodeTypeReference("System.Windows.Markup.InternalTypeHelper"));
            ctdClass.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
            AddDebuggerNonUserCodeAttribute(ctdClass);
            AddEditorBrowsableAttribute(ctdClass); 
            GenerateXmlComments(ctdClass, ctdClass.Name);
 
            //         protected override object CreateInstance(Type type, CultureInfo culture) 
            //         {
            //             return Activator.CreateInstance(type, 
            //                                             BindingFlags.Public |
            //                                             BindingFlags.NonPublic |
            //                                             BindingFlags.Instance |
            //                                             BindingFlags.CreateInstance, 
            //                                             null,
            //                                             null, 
            //                                             culture); 
            //         }
            // 
            CodeMemberMethod cmmCI = new CodeMemberMethod();
            cmmCI.Name = "CreateInstance";
            cmmCI.Attributes = MemberAttributes.Family | MemberAttributes.Override;
            cmmCI.ReturnType = new CodeTypeReference(typeof(Object)); 

            CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(Type), TYPE); 
            CodeParameterDeclarationExpression param4 = new CodeParameterDeclarationExpression(typeof(CultureInfo), CULTURE); 
            cmmCI.Parameters.Add(param1);
            cmmCI.Parameters.Add(param4); 

            CodeMethodReferenceExpression cmreCI = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Activator)), "CreateInstance");
            CodeMethodInvokeExpression cmieCI = new CodeMethodInvokeExpression();
            cmieCI.Method = cmreCI; 
            cmieCI.Parameters.Add(new CodeArgumentReferenceExpression(TYPE));
            CodeFieldReferenceExpression cfre1 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Public"); 
            CodeFieldReferenceExpression cfre2 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "NonPublic"); 
            CodeFieldReferenceExpression cfre3 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Instance");
            CodeFieldReferenceExpression cfre4 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "CreateInstance"); 
            CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(cfre1, CodeBinaryOperatorType.BitwiseOr, cfre2);
            CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(cfre3, CodeBinaryOperatorType.BitwiseOr, cfre4);
            CodeBinaryOperatorExpression cboeCI = new CodeBinaryOperatorExpression(cboe1, CodeBinaryOperatorType.BitwiseOr, cboe2);
            cmieCI.Parameters.Add(cboeCI); 
            cmieCI.Parameters.Add(new CodePrimitiveExpression(null));
            cmieCI.Parameters.Add(new CodePrimitiveExpression(null)); 
            cmieCI.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE)); 

            cmmCI.Statements.Add(new CodeMethodReturnStatement(cmieCI)); 
            GenerateXmlComments(cmmCI, cmmCI.Name);
            ctdClass.Members.Add(cmmCI);

            //         protected override object GetPropertyValue(PropertyInfo propertyInfo, object target, CultureInfo culture) 
            //         {
            //             return propertyInfo.GetValue(target, BindingFlags.Default, null, null, culture); 
            //         } 
            //
            CodeMemberMethod cmmGPV = new CodeMemberMethod(); 
            cmmGPV.Name = "GetPropertyValue";
            cmmGPV.Attributes = MemberAttributes.Family | MemberAttributes.Override;
            cmmGPV.ReturnType = new CodeTypeReference(typeof(Object));
 
            param1 = new CodeParameterDeclarationExpression(typeof(PropertyInfo), PROPINFO);
            CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(object), TARGET); 
            cmmGPV.Parameters.Add(param1); 
            cmmGPV.Parameters.Add(param2);
            cmmGPV.Parameters.Add(param4); 

            CodeMethodReferenceExpression cmreGPV = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(PROPINFO), "GetValue");
            CodeMethodInvokeExpression cmieGPV = new CodeMethodInvokeExpression();
            cmieGPV.Method = cmreGPV; 
            cmieGPV.Parameters.Add(new CodeArgumentReferenceExpression(TARGET));
            cmieGPV.Parameters.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), DEFAULT)); 
            cmieGPV.Parameters.Add(new CodePrimitiveExpression(null)); 
            cmieGPV.Parameters.Add(new CodePrimitiveExpression(null));
            cmieGPV.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE)); 

            cmmGPV.Statements.Add(new CodeMethodReturnStatement(cmieGPV));
            GenerateXmlComments(cmmGPV, cmmGPV.Name);
            ctdClass.Members.Add(cmmGPV); 

            //         protected override void SetPropertyValue(PropertyInfo propertyInfo, object target, object value, CultureInfo culture) 
            //         { 
            //             propertyInfo.SetValue(target, value, BindingFlags.Default, null, null, culture);
            //         } 
            //
            CodeMemberMethod cmmSPV = new CodeMemberMethod();
            cmmSPV.Name = "SetPropertyValue";
            cmmSPV.Attributes = MemberAttributes.Family | MemberAttributes.Override; 

            CodeParameterDeclarationExpression param3 = new CodeParameterDeclarationExpression(typeof(object), VALUE); 
            cmmSPV.Parameters.Add(param1); 
            cmmSPV.Parameters.Add(param2);
            cmmSPV.Parameters.Add(param3); 
            cmmSPV.Parameters.Add(param4);

            CodeMethodReferenceExpression cmreSPV = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(PROPINFO), "SetValue");
            CodeMethodInvokeExpression cmieSPV = new CodeMethodInvokeExpression(); 
            cmieSPV.Method = cmreSPV;
            cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(TARGET)); 
            cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(VALUE)); 
            cmieSPV.Parameters.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), DEFAULT));
            cmieSPV.Parameters.Add(new CodePrimitiveExpression(null)); 
            cmieSPV.Parameters.Add(new CodePrimitiveExpression(null));
            cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE));

            cmmSPV.Statements.Add(new CodeExpressionStatement(cmieSPV)); 
            GenerateXmlComments(cmmSPV, cmmSPV.Name);
            ctdClass.Members.Add(cmmSPV); 
 
            //         protected override Delegate CreateDelegate(Type delegateType, object target, string handler)
            //         { 
            //             return (Delegate)target.GetType().InvokeMember("_CreateDelegate",
            //                                                            BindingFlags.Instance |
            //                                                            BindingFlags.NonPublic |
            //                                                            BindingFlags.InvokeMethod, 
            //                                                            null,
            //                                                            target, 
            //                                                            new object[] { delegateType, handler }); 
            //         }
            // 
            CodeMemberMethod cmmCD = new CodeMemberMethod();
            cmmCD.Name = "CreateDelegate";
            cmmCD.Attributes = MemberAttributes.Family | MemberAttributes.Override;
            cmmCD.ReturnType = new CodeTypeReference(typeof(Delegate)); 

            param1 = new CodeParameterDeclarationExpression(typeof(Type), DELEGATETYPE); 
            param3 = new CodeParameterDeclarationExpression(typeof(string), HANDLERARG); 
            cmmCD.Parameters.Add(param1);
            cmmCD.Parameters.Add(param2); 
            cmmCD.Parameters.Add(param3);

            CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);
            CodeMethodReferenceExpression cmreGetType = new CodeMethodReferenceExpression(careTarget, "GetType"); 
            CodeMethodInvokeExpression cmieGetType = new CodeMethodInvokeExpression();
            cmieGetType.Method = cmreGetType; 
 
            CodeMethodReferenceExpression cmreCD = new CodeMethodReferenceExpression(cmieGetType, "InvokeMember");
            CodeMethodInvokeExpression cmieCD = new CodeMethodInvokeExpression(); 
            cmieCD.Method = cmreCD;
            cmieCD.Parameters.Add(new CodePrimitiveExpression(CREATEDELEGATEHELPER));

            CodeFieldReferenceExpression cfre5 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "InvokeMethod"); 
            CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(cfre2, CodeBinaryOperatorType.BitwiseOr, cfre3);
            CodeBinaryOperatorExpression cboeCD = new CodeBinaryOperatorExpression(cfre5, CodeBinaryOperatorType.BitwiseOr, cboe); 
            cmieCD.Parameters.Add(cboeCD); 

            cmieCD.Parameters.Add(new CodePrimitiveExpression(null)); 
            cmieCD.Parameters.Add(careTarget);

            CodeArrayCreateExpression caceCD = new CodeArrayCreateExpression(typeof(object));
            CodeArgumentReferenceExpression careDelType = new CodeArgumentReferenceExpression(DELEGATETYPE); 
            CodeArgumentReferenceExpression careHandler = new CodeArgumentReferenceExpression(HANDLERARG);
            caceCD.Initializers.Add(careDelType); 
            caceCD.Initializers.Add(careHandler); 
            cmieCD.Parameters.Add(caceCD);
            cmieCD.Parameters.Add(new CodePrimitiveExpression(null)); 

            CodeCastExpression cceCD = new CodeCastExpression(typeof(Delegate), cmieCD);
            cmmCD.Statements.Add(new CodeMethodReturnStatement(cceCD));
            GenerateXmlComments(cmmCD, cmmCD.Name); 
            ctdClass.Members.Add(cmmCD);
 
            //         protected override void AddEventHandler(EventInfo eventInfo, object target, Delegate handler); 
            //         {
            //             eventInfo.AddEventHandler(target, handler); 
            //         }
            //
            CodeMemberMethod cmmAEH = new CodeMemberMethod();
            cmmAEH.Name = "AddEventHandler"; 
            cmmAEH.Attributes = MemberAttributes.Family | MemberAttributes.Override;
 
            param1 = new CodeParameterDeclarationExpression(typeof(EventInfo), EVENTINFO); 
            param3 = new CodeParameterDeclarationExpression(typeof(Delegate), HANDLERARG);
            cmmAEH.Parameters.Add(param1); 
            cmmAEH.Parameters.Add(param2);
            cmmAEH.Parameters.Add(param3);

            CodeMethodReferenceExpression cmreAEH = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(EVENTINFO), "AddEventHandler"); 
            CodeMethodInvokeExpression cmieAEH = new CodeMethodInvokeExpression();
            cmieAEH.Method = cmreAEH; 
            cmieAEH.Parameters.Add(new CodeArgumentReferenceExpression(TARGET)); 
            cmieAEH.Parameters.Add(new CodeArgumentReferenceExpression(HANDLERARG));
 
            cmmAEH.Statements.Add(new CodeExpressionStatement(cmieAEH));
            GenerateXmlComments(cmmAEH, cmmAEH.Name);
            ctdClass.Members.Add(cmmAEH);
 
            //     }
            // 
            cns.Types.Add(ctdClass); 

            // } 
            //
            CodeCompileUnit ccu = new CodeCompileUnit();
            ccu.Namespaces.Add(cns);
 
            // For VB only we need to let the parser know about the RootNamespace value
            // in order to look for the XamlGeneratedNamespace.GeneratedInternalTypeHelper 
            // type whose full type name would have been implicitly by the VB comopiler to 
            // RootNS.XamlGeneratedNamespace.GeneratedInternalTypeHelper
 
            if (IsLanguageVB && !string.IsNullOrEmpty(DefaultNamespace))
            {
                // [assembly: RootNamespaceAttribute("RootNS")]
                CodeAttributeDeclaration cad = new CodeAttributeDeclaration( 
                             "System.Windows.Markup.RootNamespaceAttribute",
                             new CodeAttributeArgument(new CodePrimitiveExpression(DefaultNamespace))); 
 
                ccu.AssemblyCustomAttributes.Add(cad);
            } 

            string generatedInternalTypeHelperFileName = TargetPath + SharedStrings.GeneratedInternalTypeHelperFileName
                + (TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension)
                + LanguageSourceExtension; 

            MemoryStream codeMemStream = new MemoryStream(); 
 
            // using Disposes the StreamWriter when it ends.  Disposing the StreamWriter
            // also closes the underlying MemoryStream.  Furthermore, don't add BOM here since 
            // TaskFileService.WriteFile adds it.
            using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false)))
            {
                CodeGeneratorOptions o = new CodeGeneratorOptions(); 
                CodeDomProvider codeProvider = EnsureCodeProvider();
                codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o); 
 
                codeStreamWriter.Flush();
                TaskFileService.WriteFile(codeMemStream.ToArray(), generatedInternalTypeHelperFileName); 
            }
        }

        internal string StartElement(ref string className, string subClassFullName, ref string modifier, Type elementType, string baseClassFullName) 
        {
            string classFullName = null; 
            CodeContext cc = null; 

            if (_ccRoot == null) 
            {
                if (className.Length > 0)
                {
                    IsCodeNeeded = true; 
                }
                else if (subClassFullName.Length > 0) 
                { 
                    ThrowCompilerException(SRID.MissingClassWithSubClass, DefinitionNSPrefix);
                } 
                else if (modifier.Length > 0)
                {
                    ThrowCompilerException(SRID.MissingClassWithModifier, DefinitionNSPrefix);
                } 
                else if (_typeArgsList != null)
                { 
                    string rootClassName = elementType != null ? elementType.Name : baseClassFullName.Substring(baseClassFullName.LastIndexOf(DOT, StringComparison.Ordinal)+1); 
                    ThrowCompilerException(SRID.MissingClassDefinitionForTypeArgs, rootClassName, DefinitionNSPrefix);
                } 

                // Don't allow subclassing further from markup-subclasses with content
                if (elementType != null && KnownTypes.Types[(int)KnownElements.IComponentConnector].IsAssignableFrom(elementType))
                { 
                    ThrowCompilerException(SRID.SubSubClassingNotAllowed, elementType.FullName);
                } 
 
                cc = GenerateSubClass(ref className, ref modifier, elementType, baseClassFullName);
                Debug.Assert(_codeContexts.Count == 0, "mismatched codecontext"); 
                _ccRoot = cc as CodeContextRoot;
                Debug.Assert(_ccRoot != null);

                if (IsCodeNeeded) 
                {
                    if (subClassFullName.Length > 0) 
                    { 
                        classFullName = subClassFullName;
                        _ccRoot.SubClass = classFullName; 
                    }
                    else
                    {
                        classFullName = GetFullClassName(_ccRoot.CodeNS.Name, _ccRoot.CodeClass.Name); 
                    }
 
                    if (IsLanguageVB) 
                    {
                        // This classFullName is going to be used to write Root Start Element. 
                        // If it is for VB, and DefaultClrName is set, we need to put DefaultClrName
                        // as prefix to any existing full class name.
                        //
                        // if this x:Class is set to "MyNS.MyPage, and RootNamespace (DefaultNamespace) 
                        // is set to MyRoot, the finally generated class by VBC would be MyRoot.MyNS.MyPage.
                        // so in the Baml record, it should keep MyRoot.MyNS.MyPage. 
                        // 

                        classFullName = GetFullClassName(DefaultNamespace, classFullName); 
                    }
                }

                if (IsCompilingEntryPointClass) 
                {
                    cc.IsAllowedNameScope = false; 
                } 
            }
            else 
            {
                cc = new CodeContext(elementType, null, baseClassFullName);
                CodeContext ccParent = (CodeContext)_codeContexts.Peek();
                cc.IsAllowedNameScope = ccParent.IsAllowedNameScope; 
            }
 
            _codeContexts.Push(cc); 

            return classFullName; 
        }

        internal void EndElement(bool pass2)
        { 
            CodeContext cc = (CodeContext)_codeContexts.Pop();
            Debug.Assert(cc != null); 
 
            if (_codeContexts.Count == 0)
            { 
                Debug.Assert(_ccRoot == (cc as CodeContextRoot));
                Debug.Assert(_ccRoot.CodeClass != null);

                if (!pass2) 
                {
                    // For entry point class, a sub-class is always needed 
                    // even if if wasn't otherwise needed by other markup 
                    // like x:Code or events etc. upto this point.
                    if (IsCompilingEntryPointClass) 
                    {
                        IsCodeNeeded = true;
                    }
 
                    if (IsCodeNeeded)
                    { 
                        if (IsBamlNeeded) 
                        {
                            GenerateInitializeComponent(IsCompilingEntryPointClass); 
                            if (!IsCompilingEntryPointClass)
                            {
                                GenerateCreateDelegateHelper();
                            } 
                        }
                        else 
                        { 
                            Debug.Assert(_ccRoot.HookupFn == null);
                        } 

                        EndHookups();
                        EndStyleEventConnection();
                    } 

                    GenerateSource(); 
                } 
            }
        } 

        internal void AddUsing(string clrNS)
        {
            if (String.IsNullOrEmpty(clrNS)) 
            {
                return; 
            } 

            if (_usingNS == null) 
            {
                _usingNS = new ArrayList();
            }
 
            _usingNS.Add(clrNS);
        } 
 
#endregion CorePageGen
 
#region App Entry Point

        // This code block is shared by regular Application and HostInBrowser Application
        private CodeVariableReferenceExpression GenerateAppInstance(CodeMemberMethod cmmMain) 
        {
            string appClassName = _ccRoot.SubClass.Length > 0 ? _ccRoot.SubClass 
                                               : GetFullClassName(_ccRoot.CodeNS.Name, _ccRoot.CodeClass.Name); 

            //  MyNS.MyApplication app = new MyNS.MyApplication(); 
            //
            CodeObjectCreateExpression coce;
            CodeVariableReferenceExpression cvre = new CodeVariableReferenceExpression(APPVAR);
            CodeExpression[] ctorParams = {}; 

            coce = new CodeObjectCreateExpression(appClassName, ctorParams); 
 
            CodeVariableDeclarationStatement cvds = new CodeVariableDeclarationStatement(appClassName, APPVAR, coce);
 
            cmmMain.Statements.Add(cvds);

            return cvre;
        } 

        internal void AddApplicationProperty(MemberInfo memberInfo, string attributeValue, int lineNumber) 
        { 
            Debug.Assert(_ccRoot == (_codeContexts.Peek() as CodeContextRoot));
            Debug.Assert(_ccRoot.ElementType == null || 
                         (memberInfo.DeclaringType.IsAssignableFrom(_ccRoot.ElementType) && (memberInfo is PropertyInfo)));

            TypeConvertContext ctx = new TypeConvertContext(_parserContext, attributeValue);
            CodeExpression ceValue = GetPropertyValueExpression(ctx, typeof(Uri), null, attributeValue); 
            CodeThisReferenceExpression ctreTag = new CodeThisReferenceExpression();
            CodePropertyReferenceExpression cprePropSet = new CodePropertyReferenceExpression(ctreTag, memberInfo.Name); 
 
            CodeStatement csPropSet = new CodeAssignStatement(cprePropSet, ceValue);
 
            AddLinePragma(csPropSet, lineNumber);

            _ccRoot.EnsureInitializeComponentFn.Statements.Add(csPropSet);
        } 

        internal void AddApplicationEvent(MarkupEventInfo mei) 
        { 
            // validate the event handler name per C# grammar for identifiers
            ValidateEventHandlerName(mei.eventName, mei.eventHandler); 

            // this.FooEvent += new FooEventHandlerDelegate(this.OnFoo);
            CodeThisReferenceExpression ctre = new CodeThisReferenceExpression();
            CodeStatement csEvent = AddCLREvent(_ccRoot, ctre, mei); 

            Debug.Assert(_ccRoot == (_codeContexts.Peek() as CodeContextRoot)); 
            _ccRoot.EnsureInitializeComponentFn.Statements.Add(csEvent); 
        }
 
        private CodeMemberMethod GenerateEntryPointMethod()
        {
            CodeMemberMethod cmmMain = null;
            CodeDomProvider codeProvider = EnsureCodeProvider(); 

            if (codeProvider.Supports(GeneratorSupport.EntryPointMethod)) 
            { 
                //
                // [STAThread] 
                // public static void Main () {
                //

                cmmMain = new CodeEntryPointMethod(); 
                cmmMain.Attributes = MemberAttributes.Public | MemberAttributes.Static;
                cmmMain.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(STAThreadAttribute).FullName)); 
                AddDebuggerNonUserCodeAttribute(cmmMain); 
                GenerateXmlComments(cmmMain, "Application Entry Point.");
                cmmMain.ReturnType = new CodeTypeReference(typeof(void)); 
            }

            return cmmMain;
        } 

        private void GenerateAppEntryPoint() 
        { 
            if (ApplicationFile.Length > 0)
            { 

                // [STAThread]
                // public static void Main () {
                // 
                CodeMemberMethod cmmMain = GenerateEntryPointMethod();
 
                if (cmmMain != null) 
                {
                    CodeVariableReferenceExpression cvreSplashScreen = null; 
                    if (!string.IsNullOrEmpty(_splashImage) && !HostInBrowser)
                    {
                        cvreSplashScreen = GenerateSplashScreenInstance(cmmMain);
                    } 

                    //   MyApplication app = new MyApplication(); 
                    // 
                    CodeVariableReferenceExpression cvreApp = GenerateAppInstance(cmmMain);
 
                    if (_ccRoot.InitializeComponentFn != null)
                    {
                        //   app.InitializeComponent();
                        // 
                        CodeMethodInvokeExpression cmieIT = new CodeMethodInvokeExpression();
                        cmieIT.Method = new CodeMethodReferenceExpression(cvreApp, INITIALIZE_COMPONENT); 
                        cmmMain.Statements.Add(new CodeExpressionStatement(cmieIT)); 
                    }
 
                    if (!HostInBrowser)
                    {
                        //   app.Run();
                        // 
                        CodeMethodReferenceExpression cmreRun = new CodeMethodReferenceExpression(cvreApp, "Run");
                        CodeMethodInvokeExpression cmieRun = new CodeMethodInvokeExpression(); 
                        cmieRun.Method = cmreRun; 

                        CodeStatement csRun = new CodeExpressionStatement(cmieRun); 
                        cmmMain.Statements.Add(csRun);
                    }

                    _ccRoot.CodeClass.Members.Add(cmmMain); 
                }
            } 
        } 

        private void GenerateLooseContentAttributes() 
        {
            CodeDomProvider codeProvider = EnsureCodeProvider();

            if (codeProvider.Supports(GeneratorSupport.AssemblyAttributes)) 
            {
                CodeCompileUnit ccu = new CodeCompileUnit(); 
 
                foreach (string file in ContentList)
                { 
                    // [assembly: AssemblyAssociatedContentFileAttribute("file")]

                    string normalized = ResourceIDHelper.GetResourceIDFromRelativePath(file);
                    CodeAttributeDeclaration cad = new CodeAttributeDeclaration( 
                                 "System.Windows.Resources.AssemblyAssociatedContentFileAttribute",
                                 new CodeAttributeArgument(new CodePrimitiveExpression(normalized))); 
 
                    ccu.AssemblyCustomAttributes.Add(cad);
                } 

                string contentCodeFileName = TargetPath + AssemblyName + SharedStrings.ContentFile
                    + (TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension)
                    + LanguageSourceExtension; 

 
                MemoryStream codeMemStream = new MemoryStream(); 

                // using Disposes the StreamWriter when it ends.  Disposing the StreamWriter 
                // also closes the underlying MemoryStream.  Furthermore, don't add BOM here since
                // TaskFileService.WriteFile adds it.
                using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false)))
                { 
                    CodeGeneratorOptions o = new CodeGeneratorOptions();
                    codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o); 
 
                    codeStreamWriter.Flush();
                    TaskFileService.WriteFile(codeMemStream.ToArray(), contentCodeFileName); 
                }
            }
        }
 
#endregion App Entry Point
 
#region Splash Screen Code Generation 

        private CodeVariableReferenceExpression GenerateSplashScreenInstance(CodeMemberMethod cmmMain) 
        {
            // SplashScreen splashScreen = new SplashScreen(Assembly.GetExecutingAssembly(), "splash.png");
            CodeObjectCreateExpression coceApplicationSplashScreen = new CodeObjectCreateExpression(SPLASHCLASSNAME, new CodePrimitiveExpression(GetSplashResourceId()));
            // ApplicationSplashScreen splashScreen = ... 
            CodeVariableDeclarationStatement cvdsAppSplash = new CodeVariableDeclarationStatement(SPLASHCLASSNAME, SPLASHVAR, coceApplicationSplashScreen);
            cmmMain.Statements.Add(cvdsAppSplash); 
 
            // splashScreen.Show(true);
            CodeVariableReferenceExpression cvreAppSplash = new CodeVariableReferenceExpression(SPLASHVAR); 
            CodeMethodInvokeExpression cmieShowSplashScreen = new CodeMethodInvokeExpression(cvreAppSplash, "Show", new CodePrimitiveExpression(true));
            cmmMain.Statements.Add(cmieShowSplashScreen);

            return cvreAppSplash; 
        }
 
        private string GetSplashResourceId() 
        {
            // Perform the same resouce string mangle that is done in ResourceGenerator 
            string resourceId;
            string fullFilePath = Path.GetFullPath(_splashImage);
            string relPath = TaskHelper.GetRootRelativePath(TargetPath, fullFilePath);
 
            //
            // If the resFile is relative to the StagingDir (OutputPath here) 
            // take the relative path as resource id. 
            // If the resFile is not relative to StagingDir, but relative
            // to the project directory, take this relative path as resource id. 
            // Otherwise, just take the file name as resource id.
            //

            if (string.IsNullOrEmpty(relPath)) 
            {
                relPath = TaskHelper.GetRootRelativePath(Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar, fullFilePath); 
            } 

            if (string.IsNullOrEmpty(relPath) == false) 
            {
                resourceId = relPath;
            }
            else 
            {
                resourceId = Path.GetFileName(fullFilePath); 
            } 

            // Modify resource ID to correspond to canonicalized Uri format 
            // i.e. - all lower case, use "/" as separator
            // ' ' is converted to escaped version %20
            //
 
            resourceId = ResourceIDHelper.GetResourceIDFromRelativePath(resourceId);
 
            return resourceId; 
        }
 
#endregion

#region CodeContext
 
        private class CodeContext
        { 
            internal CodeContext(Type elementType, string [] typeArgsList, string localElementFullName) 
            {
                _elementType = elementType; 
                _typeArgsList = typeArgsList;
                _localElementFullName = localElementFullName;
            }
 
            internal Type ElementType
            { 
                get { return _elementType; } 
            }
 
            internal string ElementName
            {
                get { return _elementType != null ? _elementType.Name : _localElementFullName.Substring(_localElementFullName.LastIndexOf(DOT, StringComparison.Ordinal) + 1); }
            } 

            internal string [] GenericTypeArgs 
            { 
                get { return _typeArgsList; }
            } 

            internal string LocalElementFullName
            {
                get { return _localElementFullName; } 
            }
 
            internal bool IsAllowedNameScope 
            {
                get { return _isAllowedNameScope; } 
                set { _isAllowedNameScope = value; }
            }

            internal CodeTypeReference ElementTypeReference 
            {
                get 
                { 
                    if (_ctrElemTypeRef == null)
                    { 
                        _ctrElemTypeRef = MarkupCompiler.GenerateConstructedTypeReference(_elementType, _typeArgsList, _localElementFullName);
                    }

                    return _ctrElemTypeRef; 
                }
 
                set { _ctrElemTypeRef = value; } 
            }
 
            private bool _isAllowedNameScope = true;
            private Type _elementType = null;
            private string [] _typeArgsList = null;
            private string _localElementFullName = string.Empty; 
            protected CodeTypeReference _ctrElemTypeRef = null;
        } 
 
        private class CodeContextRoot : CodeContext
        { 
            internal CodeContextRoot(CodeTypeDeclaration codeClass,
                                     CodeNamespace codeNS,
                                     Type elementType,
                                     string [] typeArgsList, 
                                     string localElementFullName) : base (elementType, typeArgsList, localElementFullName)
            { 
                _codeNS = codeNS; 
                _codeClass = codeClass;
                _ctrElemTypeRef = codeClass.BaseTypes[0]; 
            }

            internal CodeMemberMethod HookupFn
            { 
                get { return _hookupFn; }
                set { _hookupFn = value; } 
            } 

            internal CodeMemberMethod StyleConnectorFn 
            {
                get { return _styleConnectorFn; }
                set { _styleConnectorFn = value; }
            } 

            internal CodeMemberMethod InitializeComponentFn 
            { 
                get { return _initializeComponentFn; }
            } 

            internal CodeMemberMethod EnsureInitializeComponentFn
            {
                get 
                {
                    if (_initializeComponentFn == null) 
                    { 
                        _initializeComponentFn = new CodeMemberMethod();
                        _initializeComponentFn.Name = INITIALIZE_COMPONENT; 
                        _initializeComponentFn.Attributes = MemberAttributes.Public | MemberAttributes.Final;
                        AddDebuggerNonUserCodeAttribute(_initializeComponentFn);
                        MarkupCompiler.GenerateXmlComments(_initializeComponentFn, INITIALIZE_COMPONENT);
                        _codeClass.Members.Add(_initializeComponentFn); 
                    }
 
                    return _initializeComponentFn; 
                }
            } 

            internal CodeTypeDeclaration CodeClass
            {
                get { return _codeClass; } 
            }
 
            internal CodeNamespace CodeNS 
            {
                get { return _codeNS; } 
            }

            // This is used as the class to instantiate when a language does not support partial
            // classes. A code-behind file needs to derive this class from the generated sub-class 
            // that is normally specified by the x:Class attribute.
            internal string SubClass 
            { 
                get { return _subClass; }
                set { _subClass = value; } 
            }

            private CodeTypeDeclaration _codeClass;
            private CodeNamespace _codeNS; 
            private CodeMemberMethod _initializeComponentFn = null;
            private CodeMemberMethod _hookupFn = null; 
            private CodeMemberMethod _styleConnectorFn = null; 
            private string _subClass = string.Empty;
        } 

#endregion CodeContext

#endregion Implementation 

#region Private Data 
 
        private string                  _targetPath = string.Empty; // Current Dir is default
        private string[]                _contentList = null; 
        private ArrayList               _referenceAssemblyList = null;
        private string                  _localXamlApplication = null;
        private string[]                _localXamlPages = null;
        private string []               _typeArgsList = null; 
        private ArrayList               _pendingLocalFiles = null;
        private bool                    _hostInBrowser = false; 
        private bool                    _xamlDebuggingInformation = false; 
        private string                  _splashImage = null;
 
        private bool                    _isLangCSharp = false;
        private bool                    _isLangVB = false;
        private string                  _language = string.Empty;
        private string                  _languageSourceExtension = string.Empty; 
        private static string           _definitionNSPrefix = DEFINITION_PREFIX;
        private CompilerInfo            _ci = null; 
        private CodeDomProvider         _codeProvider = null; 
        private XamlTypeMapper          _typeMapper = null;
 
        private bool                    _isCompilingEntryPointClass = false;
        private bool                    _isBamlNeeded = false;
        private bool                    _isCodeNeeded = false;
        private bool                    _hasLocalEvent = false; 
        private bool                    _hasGeneratedInternalTypeHelper = false;
        private string                  _assemblyName = string.Empty; 
        private string                  _assemblyVersion = string.Empty; 
        private string                  _assemblyPublicKeyToken = string.Empty;
        private string                  _applicationFile = string.Empty; 
        private string                  _defaultNamespace = string.Empty;
        private ParserHooks             _parserHooks;

        private SourceFileInfo          _sourceFileInfo = null; 
        private string                  _compilationUnitSourcePath = string.Empty;
        private ArrayList               _usingNS = null; 
        private Assembly                _localAssembly = null; 
        private ReferenceAssembly       _localAssemblyFile = null;
        private ParserContext           _parserContext = null; 
        private CodeContextRoot         _ccRoot = null;
        private Stack                   _codeContexts = null;
        private ITaskFileService        _taskFileService = null;
 
        // Per language sccess Modfiers
        private string                  _private = string.Empty; 
        private string                  _public = string.Empty; 
        private string                  _protected = string.Empty;
        private string                  _internal = string.Empty; 
        private string                  _protectedInternal = string.Empty;
        private string                  _privateClass = string.Empty;
        private string                  _publicClass = string.Empty;
 
        // Prefixes & Tags
        private const string            INDENT12 = "            "; 
        private const string            ANONYMOUS_ENTRYCLASS_PREFIX = "Generated"; 
        private const string            DEFINITION_PREFIX = "x";
        private const char              COMMA = ','; 
        private const string            GENERIC_DELIMITER = "`";
        internal const char             DOTCHAR = '.';
        internal const string           DOT = ".";
        internal const string           CODETAG = "Code"; 

        // Language support 
        private const string            XAML = ".xaml"; 
        private const string            BAML = ".baml";
        private const string            VB = "vb"; 
        private const string            CSHARP = "c#";
        private const string            JSHARP = "vj#";
        private const string            JSCRIPT = "js";
 
        // Generated identifiers
        private const string            CREATEDELEGATEHELPER = "_CreateDelegate"; 
        private const string            CONTENT_LOADED = "_contentLoaded"; 
        private const string            CONNECT = "Connect";
        private const string            CONNECTIONID = "connectionId"; 
        private const string            TARGET = "target";
        private const string            EVENTSETTER = "eventSetter";
        private const string            EVENT = "Event";
        private const string            ADDHANDLER = "AddHandler"; 
        private const string            HELPER = "Helper";
        private const string            HANDLERARG = "handler"; 
        private const string            TYPE = "type"; 
        private const string            CULTURE = "culture";
        private const string            DEFAULT = "Default"; 
        private const string            VALUE = "value";
        private const string            DELEGATETYPE = "delegateType";
        private const string            PROPINFO = "propertyInfo";
        private const string            EVENTINFO = "eventInfo"; 
        private const string            APPVAR = "app";
        private const string            SPLASHVAR = "splashScreen"; 
        private const string            SPLASHCLASSNAME = "SplashScreen"; 
        private const string            ARGS = "args";
        private const string            INITIALIZE_COMPONENT = "InitializeComponent"; 
        private const string            SWITCH_STATEMENT = INDENT12 + "switch (" + CONNECTIONID + ")\r\n" + INDENT12 + "{";
        private const string            BREAK_STATEMENT = INDENT12 + "break;";
        private const string            CASE_STATEMENT = INDENT12 + "case ";
        private const string            ENDCURLY = "}"; 
        private const string            COLON = ":";
        private const string            RESOURCE_LOCATER = "resourceLocater"; 
        private const string            LOADCOMPONENT = "LoadComponent"; 
        private const string            SETTERS = "Setters";
        private const string            SummaryStartTag = @""; 
        private const string            SummaryEndTag = @"";
        internal const string           ADD = "Add";
        internal const string           HANDLER = "Handler";
 
        // Delimiters & Uri processing
        private const string            VER = "V"; 
        private const string            COMPONENT = "component"; 
        private const char              COMPONENT_DELIMITER = ';';
        private const string            ESCAPED_BACKSLASH = "\\"; 
        private const char              ESCAPED_BACKSLASH_CHAR = '\\';
        private const string            FORWARDSLASH = "/";
        private const string            URISCHEME_PACK = "pack";
        private const string            PARENTFOLDER = @"..\"; 

        // For generating pragma checksum data 
        private static HashAlgorithm s_md5HashAlgorithm; 
        private static Guid s_hashMD5Guid;
 
#endregion Private Data
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//---------------------------------------------------------------------------- 
//
// File: MarkupCompiler.cs
//
// Description: 
//   Markup Compiler class that compiles the markup in a Xaml file into a
//   binary stream (Baml) and\or code (IL) in an assembly. 
// 
//
// History: 
//    10/29/01:    sramani        Created
//    6/13/03:     sramani        Ported to WPP
//    3/11/04:     sramani        Removed CAML support
// 
// Copyright (C) 2001 by Microsoft Corporation.  All rights reserved.
// 
//--------------------------------------------------------------------------- 

#pragma warning disable 1634, 1691 

using System;
using System.Xml;
using System.IO; 
using System.Text;
using System.Reflection; 
using System.Globalization; 
using System.ComponentModel;
using System.Security.Permissions; 
using System.Security.Cryptography;

using System.CodeDom;
using System.CodeDom.Compiler; 
using System.Collections;
using System.Collections.Generic; 
using System.ComponentModel.Design.Serialization; 

using System.Diagnostics; 
using System.Diagnostics.CodeAnalysis;

using System.Threading;
using MS.Internal.Markup; 
using MS.Internal.Tasks;
using MS.Utility;   // for SR 
 
namespace MS.Internal
{ 
    internal sealed class MarkupCompiler
    {
#region ExternalAPI
 
#region Public Properties
 
        ///String that specifies the directory to place the generated files into 
        public string TargetPath
        { 
            get { return _targetPath; }
            set { _targetPath = value; }
        }
 
        /// 
        /// The version of the assembly 
        ///  
        public string AssemblyVersion
        { 
            get { return _assemblyVersion; }
            set { _assemblyVersion = value; }
        }
 
        /// 
        /// The public key token of the assembly 
        ///  
        public string AssemblyPublicKeyToken
        { 
            get { return _assemblyPublicKeyToken; }
            set { _assemblyPublicKeyToken = value; }
        }
 
        ///Array of loose files associated with this assembly
        public string [] ContentList 
        { 
            get { return _contentList; }
            set { _contentList = value; } 
        }

        /// 
        /// Splash screen image to be displayed before application init 
        /// 
        public string SplashImage 
        { 
            set { _splashImage = value; }
        } 

        /// Array of local xaml page files to be compiled at pass2 
        public string[] LocalXamlPages
        { 
            get { return _localXamlPages; }
        } 
 
        /// Local Application xaml file to be compiled at pass2 
        public string LocalXamlApplication 
        {
            get { return _localXamlApplication; }
        }
 
        /// 
        /// ReferenceAssemblyList. every item is an instance of ReferenceAssembly. 
        ///  
        /// 
        public ArrayList ReferenceAssemblyList 
        {
            get { return _referenceAssemblyList; }
            set { _referenceAssemblyList = value; }
        } 

        ///The language source file extension set in a project or the registered default. 
        public string LanguageSourceExtension 
        {
            get { return _languageSourceExtension; } 
            set { _languageSourceExtension = value; }
        }

        ///Allows to hook a custom parser during compilation. 
        public ParserHooks ParserHooks
        { 
            get { return _parserHooks; } 
            set { _parserHooks = value; }
        } 

        ///If true code for supporting hosting in Browser is generated
        public bool HostInBrowser
        { 
            get { return _hostInBrowser; }
            set { _hostInBrowser = value; } 
        } 

        ///Generate Debug information in the BAML file. 
        public bool XamlDebuggingInformation
        {
            get { return _xamlDebuggingInformation; }
            set { _xamlDebuggingInformation = value; } 
        }
 
        ///  
        /// Get/Sets the TaskFileService which is used for abstracting simple
        /// files services provided by CLR and the HostObject (IVsMsBuildTaskFileManager) 
        /// 
        internal ITaskFileService TaskFileService
        {
            get { return _taskFileService; } 
            set { _taskFileService = value; }
        } 
 
        // If the xaml has local references, then it could have internal element & properties
        // but there is no way to determine this until MCPass2. Yet, GeneratedInternalTypeHelper, 
        // which is the class that allows access to legitimate internals, needs to be generated
        // in MCPass1. So, to determine if GeneratedInternalTypeHelper.cs needs to be kept or not,
        // MCPass1 & MCPass2 task will use the HasInternals property as indicated below:
 
        // In pass1, if this property returns true, it will be due to friend internals & so
        // MCPass1 will just decide to keep the file & this property will be ignored in MCPass2 
        // if that task is executed as well. 

        // In pass1, if this property returns false, MCPass2 will look at this property again after 
        // the Xaml Compiler has been called to compile all the local markup files. Now if this
        // property still returns false, the file will be removed, else it will be kept, because
        // this property was true as the xaml compiler encountered local or friend internals
        // during MCPass2. 

        // The above will apply only for a clean build, not incremental build. 
        public static bool HasInternals 
        {
            get { return XamlTypeMapper.HasInternals; } 
        }

        /// 
        /// Given an assembly name, resets it in the assembly cache and marks it for being 
        /// loaded from a memory buffer instead of a file in disk.
        ///  
        public static void InitializeAssemblyState(string assemblyName) 
        {
            ReflectionHelper.ResetCacheForAssembly(assemblyName); 
            ReflectionHelper.SetContentLoadForAssembly(assemblyName);
        }

#endregion Public Properties 

#region Public Events 
 
        /// 
        /// The Error event is fired when an error is encountered while compiling a xaml file. 
        /// 
        public event MarkupErrorEventHandler Error;

        ///  
        /// The SourceFileResolve event is fired when it starts to compile one xaml file or handle
        /// resource file. The event handler will resolve the original filepath to a new 
        /// SourcePath and RelativeSourceFilePath. 
        /// 
        public event SourceFileResolveEventHandler SourceFileResolve; 

#endregion Public Events

#region Public Methods 

        ///Complies list of file items comprising an Application. 
        public void Compile(CompilationUnit cu) 
        {
            try 
            {
                AssemblyName = cu.AssemblyName;
                InitCompilerState();
 
                DefaultNamespace = cu.DefaultNamespace;
                _compilationUnitSourcePath = cu.SourcePath; 
 
                if (!IsLanguageSupported(cu.Language))
                { 
                    OnError(new Exception(SR.Get(SRID.UnknownLanguage, cu.Language)));
                    return;
                }
 
                if (!cu.Pass2)
                { 
                    EnsureLanguageSourceExtension(); 
                }
 
                if (cu.ApplicationFile != null && cu.ApplicationFile.Length > 0)
                {
                    Initialize(cu.ApplicationFile);
                    ApplicationFile = SourceFileInfo.RelativeSourceFilePath; 

                    if (ApplicationFile.Length > 0) 
                    { 
                        IsCompilingEntryPointClass = true;
                        _Compile(cu.ApplicationFile, cu.Pass2); 
                        IsCompilingEntryPointClass = false;

                        if (_pendingLocalFiles != null && _pendingLocalFiles.Count == 1)
                        { 
                            Debug.Assert(!cu.Pass2);
                            _localXamlApplication = (string)_pendingLocalFiles[0]; 
                            _pendingLocalFiles.Clear(); 
                        }
                    } 
                }

                if (cu.FileList != null)
                { 
                    for (int i = 0; i < cu.FileList.Length; i++)
                    { 
                        string sourceFile = cu.FileList[i]; 

                        Initialize(sourceFile); 
                        if (SourceFileInfo.RelativeSourceFilePath.Length > 0)
                        {
                            _Compile(sourceFile, cu.Pass2);
                        } 
                    }
 
                    if (_pendingLocalFiles != null && _pendingLocalFiles.Count > 0) 
                    {
                        Debug.Assert(!cu.Pass2); 
                        _localXamlPages = (string[])_pendingLocalFiles.ToArray(typeof(string));
                        _pendingLocalFiles.Clear();
                    }
                } 

                if (!cu.Pass2 && ContentList != null && ContentList.Length > 0) 
                { 
                    GenerateLooseContentAttributes();
                } 

                Debug.Assert(!cu.Pass2 || _pendingLocalFiles == null);
                Debug.Assert(_pendingLocalFiles == null || _pendingLocalFiles.Count == 0);
                _pendingLocalFiles = null; 

                if (cu.Pass2) 
                { 
                    _localAssembly = null;
                    _localXamlApplication = null; 
                    _localXamlPages = null;
                }
            }
            finally 
            {
                if (_typeMapper != null) 
                { 
                    _typeMapper.ClearReflectionOnlyAssemblyResolver();
                } 

                if (s_md5HashAlgorithm != null)
                {
                    s_md5HashAlgorithm.Clear(); 
                    s_md5HashAlgorithm = null;
                } 
            } 
        }
 
#endregion Public Methods

#endregion ExternalAPI
 
#region Implementation
 
#region Properties 

        private CompilerInfo CompilerInfo 
        {
            get { return _ci; }
            set
            { 
                _ci = value;
                if (value == null) 
                { 
                    _codeProvider = null;
                } 
            }
        }

        private string ApplicationFile 
        {
            get { return _applicationFile; } 
            set { _applicationFile = value; } 
        }
 
        private string DefaultNamespace
        {
            get { return _defaultNamespace; }
            set 
            {
                IsValidCLRNamespace(value, true); 
                _defaultNamespace = value; 
            }
        } 

        private bool IsCodeNeeded
        {
            get { return _isCodeNeeded; } 
            set { _isCodeNeeded = value; }
        } 
 
        internal bool IsBamlNeeded
        { 
            get { return IsCompilingEntryPointClass ? _isBamlNeeded : true; }
            set { _isBamlNeeded = value; }
        }
 
        internal bool IsRootPublic
        { 
            get { return _ccRoot != null && _ccRoot.CodeClass.TypeAttributes == TypeAttributes.Public; } 
        }
 
        internal bool ProcessingRootContext
        {
            get { return _ccRoot == null; }
        } 

        internal bool IsRootNameScope 
        { 
            get
            { 
                CodeContext cc = (CodeContext)_codeContexts.Peek();
                return cc.IsAllowedNameScope;
            }
        } 

        internal bool HasLocalEvent 
        { 
            get { return _hasLocalEvent; }
            set { _hasLocalEvent = value; } 
        }

        internal static bool HasLocalReference
        { 
            get { return XamlTypeMapper.HasLocalReference; }
        } 
 
        internal Assembly LocalAssembly
        { 
            get
            {
                if (_localAssembly == null)
                { 
                    if (LocalAssemblyFile != null)
                    { 
                        _localAssembly = ReflectionHelper.LoadAssembly(LocalAssemblyFile.AssemblyName, LocalAssemblyFile.Path); 
                    }
                } 

                return _localAssembly;
            }
        } 

        internal ReferenceAssembly LocalAssemblyFile 
        { 
            get { return _localAssemblyFile;  }
            set { _localAssemblyFile = value; } 
        }

        internal string AssemblyName
        { 
            get { return _assemblyName; }
            set { _assemblyName = value; } 
        } 

        internal SourceFileInfo SourceFileInfo 
        {
            get { return _sourceFileInfo; }
            set { _sourceFileInfo = value; }
        } 

        internal bool IsCompilingEntryPointClass 
        { 
            get { return _isCompilingEntryPointClass; }
            set { _isCompilingEntryPointClass = value; _isBamlNeeded = !value; } 
        }

        internal static string DefinitionNSPrefix
        { 
            get { return _definitionNSPrefix; }
            set { _definitionNSPrefix = value; } 
        } 

        internal string Language 
        {
            get { return _language; }
        }
 
#endregion Properties
 
#region CompileUnit 

        private void InitCompilerState() 
        {
            _hasGeneratedInternalTypeHelper = false;
            CompilerInfo = null;
            InitializeTypeMapper(); 
        }
 
        // 
        // Generate the SourceFileInfo for the source file.
        // Do the appropriate initiallization work and file checking. 
        //
        private void Initialize(string sourceFile)
        {
            try 
            {
                // Keep the SourceFileInfo for the passed source file. 
                SourceFileInfo = OnSourceFileResolve(sourceFile); 

                // Process the input file 
                if (sourceFile == null || !SourceFileInfo.IsXamlFile)
                {
                    ThrowCompilerException(SRID.InvalidMarkupFile);
                } 

                if (!TaskFileService.Exists(sourceFile)) 
                { 
                    ThrowCompilerException(SRID.FileNotFound, sourceFile);
                } 

                // Prime the output directory
                if (TargetPath.Length > 0)
                { 
                    // check for ending '\'
                    if (!TargetPath.EndsWith(ESCAPED_BACKSLASH, StringComparison.Ordinal)) 
                    { 
                        TargetPath += ESCAPED_BACKSLASH;
                    } 
                }

                int pathEndIndex = SourceFileInfo.RelativeSourceFilePath.LastIndexOf(ESCAPED_BACKSLASH, StringComparison.Ordinal);
                string targetPath = TargetPath + SourceFileInfo.RelativeSourceFilePath.Substring(0, pathEndIndex + 1); 

                // Create if not already exists 
                if (targetPath.Length > 0 && !Directory.Exists(targetPath)) 
                {
                    Directory.CreateDirectory(targetPath); 
                }
            }
            // All exceptions including NullRef & SEH need to be caught by the markupcompiler
            // since it is an app and not a component. 
            #pragma warning suppress 6500
            catch (Exception e) 
            { 
                OnError(e);
            } 
        }

        private void _Compile(string relativeSourceFile, bool pass2)
        { 
            bool error = false;
            Stream bamlStream = null; 
            XamlParser xamlParser = null; 

            try 
            {
                DefinitionNSPrefix = DEFINITION_PREFIX;
                IsCodeNeeded = false;
 
                _ccRoot = null;
                _hasLocalEvent = false; 
                _codeContexts = new Stack(); 
                _parserContext = new ParserContext();
                _parserContext.XamlTypeMapper = _typeMapper; 

                bamlStream = new MemoryStream();
                BamlRecordWriter bamlWriter = new BamlRecordWriter(bamlStream, _parserContext, true);
                bamlWriter.DebugBamlStream = XamlDebuggingInformation; 

                xamlParser = new ParserExtension(this, _parserContext, bamlWriter, SourceFileInfo.Stream, pass2); 
 
                xamlParser.ParserHooks = ParserHooks;
 
                try
                {
                    xamlParser.Parse();
                } 
                finally
                { 
                    _typeMapper.ResetMapper(); 
                }
            } 
            catch (XamlParseException e)
            {
                OnError(e);
                error = true; 
            }
            // All exceptions including NullRef & SEH need to be caught by the markupcompiler 
            // since it is an app and not a component. 
#pragma warning suppress 6500
            catch (Exception e) 
            {
                OnError(e);
                error = true;
            } 
            finally
            { 
                if (!error && 
                    xamlParser.BamlRecordWriter == null &&
                    IsBamlNeeded) 
                {
                    if (_pendingLocalFiles == null)
                    {
                        _pendingLocalFiles = new ArrayList(10); 
                    }
 
                    _pendingLocalFiles.Add(relativeSourceFile); 
                }
 
                if (_codeContexts != null)
                {
                    _codeContexts.Clear();
                    _codeContexts = null; 
                }
 
 
                if (SourceFileInfo != null)
                { 
                    SourceFileInfo.CloseStream();
                }

                if (bamlStream != null) 
                {
                    bamlStream.Close(); 
                    bamlStream = null; 
                }
            } 
        }

        private void GenerateSource()
        { 
            Debug.Assert(_codeContexts.Count == 0);
 
            CodeNamespace cnsImports = IsLanguageCSharp ? new CodeNamespace() : _ccRoot.CodeNS; 

            if (IsCodeNeeded) 
            {
                cnsImports.Imports.Add(new CodeNamespaceImport("System"));

                if (_usingNS != null) 
                {
                    foreach (string u in _usingNS) 
                    { 
                        cnsImports.Imports.Add(new CodeNamespaceImport(u));
                    } 

                    _usingNS.Clear();
                    _usingNS = null;
                } 

                //  } end SubClass 
                _ccRoot.CodeNS.Types.Add(_ccRoot.CodeClass); 
            }
 
            if (IsCompilingEntryPointClass)
            {
                GenerateAppEntryPoint();
            } 

            if (IsCodeNeeded) 
            { 
                MemoryStream codeMemStream = new MemoryStream();
 
                // using Disposes the StreamWriter when it ends.  Disposing the StreamWriter
                // also closes the underlying MemoryStream.  Furthermore, don't add BOM here since
                // TaskFileService.WriteFile adds it.
                using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false))) 
                {
                    CodeGeneratorOptions o = new CodeGeneratorOptions(); 
 
                    // } end namespace
                    CodeCompileUnit ccu = new CodeCompileUnit(); 

                    // generate pragma checksum data
                    if (s_md5HashAlgorithm == null)
                    { 
                        s_md5HashAlgorithm = new MD5CryptoServiceProvider();
                        s_hashMD5Guid = new Guid(0x406ea660, 0x64cf, 0x4c82, 0xb6, 0xf0, 0x42, 0xd4, 0x81, 0x72, 0xa7, 0x99); 
                    } 

                    CodeChecksumPragma csPragma = new CodeChecksumPragma(); 
                    csPragma.FileName = ParentFolderPrefix + SourceFileInfo.RelativeSourceFilePath + XAML;
                    csPragma.ChecksumAlgorithmId = s_hashMD5Guid;
                    csPragma.ChecksumData = TaskFileService.GetChecksum(SourceFileInfo.OriginalFilePath, s_hashMD5Guid);
                    ccu.StartDirectives.Add(csPragma); 

                    if (cnsImports != _ccRoot.CodeNS) 
                    { 
                        ccu.Namespaces.Add(cnsImports);
                    } 

                    ccu.Namespaces.Add(_ccRoot.CodeNS);

                    CodeDomProvider codeProvider = EnsureCodeProvider(); 

                    if (codeProvider.Supports(GeneratorSupport.PartialTypes) && _ccRoot.SubClass.Length == 0) 
                    { 
                        _ccRoot.CodeClass.IsPartial = true;
                    } 

                    codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o);

                    codeStreamWriter.Flush(); 
                    TaskFileService.WriteFile(codeMemStream.ToArray(),
                        TargetPath + SourceFileInfo.RelativeSourceFilePath 
                        + (TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension) 
                        + LanguageSourceExtension);
                } 
            }

            // Generate the InternalTypeHelper class in a separate code file only once and on an as
            // needed basis for the current assembly being built. This class provides support for 
            // accessing legitimate internal types and properties that are present in the same (local)
            // or a friend assembly and it is generated only when any such internals are actually 
            // encountered in any of the xaml files in the project. 
            GenerateInternalTypeHelperImplementation();
        } 

        //
        // Return FileInfo for the given source file.
        // 
        private SourceFileInfo OnSourceFileResolve(string filePath)
        { 
            SourceFileInfo sourceFileInfo; 

            if (SourceFileResolve != null) 
            {
                //
                // If SourceFileResolve event handler is registered,  the handler
                // is responsible for generating the SourceFileInfo. 
                // This is for MSBUILD tasks.
                // 
                SourceFileResolveEventArgs scea = new SourceFileResolveEventArgs(filePath); 

                SourceFileResolve(this, scea); 

                sourceFileInfo = scea.SourceFileInfo;
            }
            else 
            {
                // If SourceFileResolve event handler is not registered,  generate 
                // the default SourceFileInfo for this file. 
                //
                sourceFileInfo = new SourceFileInfo(filePath); 

                sourceFileInfo.SourcePath = _compilationUnitSourcePath;

                if (sourceFileInfo.IsXamlFile) 
                {
                    int fileExtIndex = filePath.LastIndexOf(DOT, StringComparison.Ordinal); 
 
                    sourceFileInfo.RelativeSourceFilePath = filePath.Substring(0, fileExtIndex);
                } 
            }

            return sourceFileInfo;
        } 

#endregion CompileUnit 
 
#region ErrorHandling
 
        static void ThrowCompilerException(string id)
        {
            string message = SR.Get(id);
            ThrowCompilerExceptionImpl(message); 
        }
 
        internal static void ThrowCompilerException(string id, string value) 
        {
            string message = SR.Get(id, value); 
            ThrowCompilerExceptionImpl(message);
        }

        internal static void ThrowCompilerException(string id, string value1, string value2) 
        {
            string message = SR.Get(id, value1, value2); 
            ThrowCompilerExceptionImpl(message); 
        }
 
        internal static void ThrowCompilerException(string id, string value1, string value2, string value3)
        {
            string message = SR.Get(id, value1, value2, value3);
            ThrowCompilerExceptionImpl(message); 
        }
 
        static void ThrowCompilerException(string id, string value1, string value2, string value3, string value4) 
        {
            string message = SR.Get(id, value1, value2, value3, value4); 
            ThrowCompilerExceptionImpl(message);
        }

        static void ThrowCompilerExceptionImpl(string message) 
        {
            Exception compilerException = new Exception(message); 
            throw compilerException; 
        }
 
        internal void OnError(Exception e)
        {
            if (Error != null)
            { 
                XamlParseException xe = e as XamlParseException;
                int lineNum = xe != null ? xe.LineNumber : 0; 
                int linePos = xe != null ? xe.LinePosition : 0; 
                string filename = SourceFileInfo.OriginalFilePath;
 
                MarkupErrorEventArgs eea = new MarkupErrorEventArgs(e, lineNum, linePos, filename);
                Error(this, eea);
            }
        } 

#endregion ErrorHandling 
 
#region Definition Namespace processing
 
        internal void ProcessDefinitionNamespace(XamlDefTagNode xamlDefTagNode)
        {
            bool exitLoop = false;
            XmlReader xmlReader = xamlDefTagNode.XmlReader; 
            string LocalName = xmlReader.LocalName;
            bool isEmptyElement = xamlDefTagNode.IsEmptyElement; 
            bool isProcessingCodeTag = false; 

            do 
            {
                XmlNodeType currNodeType = xmlReader.NodeType;
                switch (currNodeType)
                { 
                    case XmlNodeType.Element:
                    { 
                        if (isProcessingCodeTag) 
                        {
                            ThrowCompilerException(SRID.DefnTagsCannotBeNested, DefinitionNSPrefix, LocalName, xmlReader.LocalName); 
                        }

                        switch (LocalName)
                        { 
                            case CODETAG:
                                isProcessingCodeTag = true; 
                                if (!IsCodeNeeded) 
                                {
                                    ThrowCompilerException(SRID.MissingClassDefinitionForCodeTag, 
                                                           _ccRoot.ElementName,
                                                           DefinitionNSPrefix,
                                                           SourceFileInfo.RelativeSourceFilePath + XAML);
                                } 

                                bool moreAttributes = xmlReader.MoveToFirstAttribute(); 
                                while (moreAttributes) 
                                {
                                    string attributeNamespaceUri = xmlReader.LookupNamespace(xmlReader.Prefix); 
                                    if (!attributeNamespaceUri.Equals(XamlReaderHelper.DefinitionNamespaceURI) ||
                                        !xmlReader.LocalName.Equals(XamlReaderHelper.DefinitionUid))
                                    {
                                        ThrowCompilerException(SRID.AttributeNotAllowedOnCodeTag, 
                                                               xmlReader.Name,
                                                               DefinitionNSPrefix, 
                                                               CODETAG); 
                                    }
 
                                    moreAttributes = xmlReader.MoveToNextAttribute();
                                }

                                break; 

                            default: 
                                ThrowCompilerException(SRID.UnknownDefinitionTag, DefinitionNSPrefix, LocalName); 
                                break;
                        } 

                        // if an empty element do a Reader to
                        // get to the next node and then exit
                        if (isEmptyElement) 
                        {
                            xmlReader.Read(); 
                            exitLoop = true; 
                        }
 
                        break;
                    }

                    case XmlNodeType.EndElement: 
                    {
                        xmlReader.Read(); 
                        exitLoop = true; 
                        break;
                    } 

                    case XmlNodeType.CDATA:
                    case XmlNodeType.Text:
                    { 
                        IXmlLineInfo xmlLineInfo = xmlReader as IXmlLineInfo;
                        int lineNumber = 0; 
 
                        if (null != xmlLineInfo)
                        { 
                            lineNumber = xmlLineInfo.LineNumber;
                        }

                        if (LocalName.Equals(CODETAG)) 
                        {
                            AddCodeSnippet(xmlReader.Value, lineNumber); 
                        } 
                        else
                        { 
                            ThrowCompilerException(SRID.IllegalCDataTextScoping, DefinitionNSPrefix, LocalName, (currNodeType == XmlNodeType.CDATA ? "a CDATA section" : "text content"));
                        }

                        break; 
                    }
                } 
            } 
            while (!exitLoop && xmlReader.Read());
        } 

#endregion Definition Namespace processing

#region Baml Hookup Functions 

        private CodeMemberMethod EnsureStyleConnector() 
        { 
            if (_ccRoot.StyleConnectorFn == null)
            { 
                _ccRoot.StyleConnectorFn = new CodeMemberMethod();
                _ccRoot.StyleConnectorFn.Name = CONNECT;
                _ccRoot.StyleConnectorFn.Attributes = MemberAttributes.Public | MemberAttributes.Final;
                _ccRoot.StyleConnectorFn.PrivateImplementationType = new CodeTypeReference(KnownTypes.Types[(int)KnownElements.IStyleConnector]); 

                // void IStyleConnector.Connect(int connectionId, object target) { 
                // 
                CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(int), CONNECTIONID);
                CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(object), TARGET); 
                _ccRoot.StyleConnectorFn.Parameters.Add(param1);
                _ccRoot.StyleConnectorFn.Parameters.Add(param2);

                AddDebuggerNonUserCodeAttribute(_ccRoot.StyleConnectorFn); 
                AddEditorBrowsableAttribute(_ccRoot.StyleConnectorFn);
                AddSuppressMessageAttribute(_ccRoot.StyleConnectorFn, "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes"); 
 
                if (SwitchStatementSupported())
                { 
                    // switch (connectionId) -- Start Switch
                    // {
                    CodeSnippetStatement css = new CodeSnippetStatement(SWITCH_STATEMENT);
                    _ccRoot.StyleConnectorFn.Statements.Add(css); 
                }
            } 
 
            return _ccRoot.StyleConnectorFn;
        } 

        internal void ConnectStyleEvent(XamlClrEventNode xamlClrEventNode)
        {
            CodeConditionStatement ccsConnector = null; 

            // validate the event handler name per C# grammar for identifiers 
            ValidateEventHandlerName(xamlClrEventNode.EventName, xamlClrEventNode.Value); 

            EnsureStyleConnector(); 

            if (!xamlClrEventNode.IsSameScope)
            {
                int connectionId = xamlClrEventNode.ConnectionId; 
                if (SwitchStatementSupported())
                { 
                    // break any previous case staements as we are starting a new connection scope. 
                    if (_ccRoot.StyleConnectorFn.Statements.Count > 1)
                    { 
                        CodeSnippetStatement cssBreak = new CodeSnippetStatement(BREAK_STATEMENT);
                        _ccRoot.StyleConnectorFn.Statements.Add(cssBreak);
                    }
 
                    // case 1:
                    // 
                    CodeSnippetStatement cssCase = new CodeSnippetStatement(CASE_STATEMENT + connectionId + COLON); 
                    _ccRoot.StyleConnectorFn.Statements.Add(cssCase);
                } 
                else
                {
                    // if (connectionId == 1)
                    // 
                    ccsConnector = new CodeConditionStatement();
                    ccsConnector.Condition = new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression(CONNECTIONID), 
                                                                              CodeBinaryOperatorType.ValueEquality, 
                                                                              new CodePrimitiveExpression(connectionId));
                } 
            }
            else if (!SwitchStatementSupported())
            {
                // if in the same scope then use the if statement that was last generated 
                // at the start of the scope
                Debug.Assert(_ccRoot.StyleConnectorFn.Statements.Count > 0); 
                ccsConnector = _ccRoot.StyleConnectorFn.Statements[_ccRoot.StyleConnectorFn.Statements.Count - 1] as CodeConditionStatement; 
                Debug.Assert(ccsConnector != null);
            } 

            CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);

            if (xamlClrEventNode.IsStyleSetterEvent) 
            {
                // EventSetter declaration only once to avoid warning! 
                if (_ccRoot.StyleConnectorFn.Statements.Count == 0 || _ccRoot.StyleConnectorFn.Statements[0] is CodeSnippetStatement) 
                {
                    // EventSetter eventSetter; 
                    //
                    CodeVariableDeclarationStatement cvdsES = new CodeVariableDeclarationStatement(KnownTypes.Types[(int)KnownElements.EventSetter], EVENTSETTER);
                    _ccRoot.StyleConnectorFn.Statements.Insert(0, cvdsES);
                } 

 
                // eventSetter = new EventSetter(); 
                //
                CodeExpression[] esParams = {}; 
                CodeVariableReferenceExpression cvreES = new CodeVariableReferenceExpression(EVENTSETTER);
                CodeAssignStatement casES = new CodeAssignStatement(cvreES,
                                                                    new CodeObjectCreateExpression(KnownTypes.Types[(int)KnownElements.EventSetter],
                                                                                                   esParams)); 

                // eventSetter.Event = Button.ClickEvent; 
                // 
                CodePropertyReferenceExpression cpreEvent = new CodePropertyReferenceExpression(cvreES, EVENT);
                CodeAssignStatement casEvent = new CodeAssignStatement(cpreEvent, 
                                                                       GetEvent(xamlClrEventNode.EventMember,
                                                                                xamlClrEventNode.EventName,
                                                                                xamlClrEventNode.Value));
 
                // eventSetter.Handler = new RoutedEventHandler(OnClick);
                // 
                CodePropertyReferenceExpression cpreHandler = new CodePropertyReferenceExpression(cvreES, HANDLER); 
                CodeAssignStatement casHandler = new CodeAssignStatement(cpreHandler,
                                                                         GetEventDelegate(null, 
                                                                                          xamlClrEventNode.EventMember,
                                                                                          xamlClrEventNode.EventName,
                                                                                          xamlClrEventNode.Value));
 
                AddLinePragma(casHandler, xamlClrEventNode.LineNumber);
 
                // ((Style)target).Setters.Add(eventSetter); 
                //
                CodeCastExpression cceTarget = new CodeCastExpression(KnownTypes.Types[(int)KnownElements.Style], careTarget); 
                CodePropertyReferenceExpression cpreSetters = new CodePropertyReferenceExpression(cceTarget, SETTERS);
                CodeMethodInvokeExpression cmieAdd = new CodeMethodInvokeExpression(cpreSetters, ADD, cvreES);

                if (SwitchStatementSupported()) 
                {
                    _ccRoot.StyleConnectorFn.Statements.Add(casES); 
                    _ccRoot.StyleConnectorFn.Statements.Add(casEvent); 
                    _ccRoot.StyleConnectorFn.Statements.Add(casHandler);
                    _ccRoot.StyleConnectorFn.Statements.Add(new CodeExpressionStatement(cmieAdd)); 
                }
                else
                {
                    ccsConnector.TrueStatements.Add(casES); 
                    ccsConnector.TrueStatements.Add(casEvent);
                    ccsConnector.TrueStatements.Add(casHandler); 
                    ccsConnector.TrueStatements.Add(new CodeExpressionStatement(cmieAdd)); 
                    // Only add if statement at start of new scope
                    if (!xamlClrEventNode.IsSameScope) 
                    {
                        _ccRoot.StyleConnectorFn.Statements.Add(ccsConnector);
                    }
                } 
            }
            else 
            { 

                // 
                // ((Foo)target).Bar += new BarEventHandler(OnBar);
                //
                // *or*
                // 
                // ((Foo)target).AddHandler( Baz.BarEvent, new BarEventHandler(OnBar));
                // 
 
                CodeCastExpression cceTarget;
                Type eventTarget; 


                // Create the markup event information
 
                MarkupEventInfo mei = new MarkupEventInfo( xamlClrEventNode.Value,          // Event handler string
                                                           xamlClrEventNode.EventName,      // Event name string 
                                                           xamlClrEventNode.EventMember,    // MemberInfo 
                                                           xamlClrEventNode.LineNumber);    // LineNumber
 

                // Get the type that defines the event (e.g. typeof(Button) for Button.Clicked or typeof(Mouse) for Mouse.MouseMove)

                eventTarget = xamlClrEventNode.ListenerType; 

 
                // Create the type cast expression "(Foo)target" 

                cceTarget = new CodeCastExpression( eventTarget, careTarget); 


                // Create the whole code statement (either in += form or in AddHandler form)
 
                CodeStatement csAddCLREvent = AddCLREvent( eventTarget, null, cceTarget, mei );
 
                if (SwitchStatementSupported()) 
                {
                    _ccRoot.StyleConnectorFn.Statements.Add( csAddCLREvent ); 
                }
                else
                {
                    ccsConnector.TrueStatements.Add( csAddCLREvent ); 

                    // Only add if statement at start of new scope 
                    if (!xamlClrEventNode.IsSameScope) 
                    {
                        _ccRoot.StyleConnectorFn.Statements.Add(ccsConnector); 
                    }
                }
            }
        } 

        private void EndStyleEventConnection() 
        { 
            if (_ccRoot.StyleConnectorFn != null)
            { 
                _ccRoot.CodeClass.BaseTypes.Add(KnownTypes.Types[(int)KnownElements.IStyleConnector].FullName);

                if (SwitchStatementSupported())
                { 
                    // break any last case staement as we are done with style event connections.
                    if (_ccRoot.StyleConnectorFn.Statements.Count > 1) 
                    { 
                        CodeSnippetStatement cssBreak = new CodeSnippetStatement(BREAK_STATEMENT);
                        _ccRoot.StyleConnectorFn.Statements.Add(cssBreak); 
                    }

                    // switch (connectionId)
                    // { 
                    // } -- End Switch
                    CodeSnippetStatement css = new CodeSnippetStatement(INDENT12 + ENDCURLY); 
                    _ccRoot.StyleConnectorFn.Statements.Add(css); 
                }
 
                _ccRoot.CodeClass.Members.Add(_ccRoot.StyleConnectorFn);
                _ccRoot.StyleConnectorFn = null;
            }
        } 

        private void EnsureHookupFn() 
        { 
            // void IComponentConnector.Connect
            // 
            if (_ccRoot.HookupFn == null)
            {
                _ccRoot.HookupFn = new CodeMemberMethod();
                _ccRoot.HookupFn.Name = CONNECT; 
                _ccRoot.HookupFn.Attributes = MemberAttributes.Public | MemberAttributes.Final;
                _ccRoot.HookupFn.PrivateImplementationType = new CodeTypeReference(KnownTypes.Types[(int)KnownElements.IComponentConnector]); 
 
                // void IComponentConnector.Connect(int connectionId, object target) {
                // 
                CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(int), CONNECTIONID);
                CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(object), TARGET);
                _ccRoot.HookupFn.Parameters.Add(param1);
                _ccRoot.HookupFn.Parameters.Add(param2); 

                AddDebuggerNonUserCodeAttribute(_ccRoot.HookupFn); 
                AddEditorBrowsableAttribute(_ccRoot.HookupFn); 
                AddSuppressMessageAttribute(_ccRoot.HookupFn, "Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes");
 
                if (SwitchStatementSupported())
                {
                    // switch (connectionId) -- Start Switch
                    // { 
                    CodeSnippetStatement css = new CodeSnippetStatement(SWITCH_STATEMENT);
                    _ccRoot.HookupFn.Statements.Add(css); 
                } 
            }
        } 

        internal void ConnectNameAndEvents(string elementName, ArrayList events, int connectionId)
        {
            CodeContext cc = (CodeContext)_codeContexts.Peek(); 
            bool isAllowedNameScope = cc.IsAllowedNameScope;
 
            if (_codeContexts.Count > 1 && KnownTypes.Types[(int)KnownElements.INameScope].IsAssignableFrom(cc.ElementType)) 
            {
                cc.IsAllowedNameScope = false; 
            }

            if ((elementName == null || !isAllowedNameScope) && (events == null || events.Count == 0))
            { 
                _typeArgsList = null;
                return; 
            } 

            EnsureHookupFn(); 

            CodeConditionStatement ccsConnector = null;

            if (SwitchStatementSupported()) 
            {
                // case 1: 
                // 
                CodeSnippetStatement cssCase = new CodeSnippetStatement(CASE_STATEMENT + connectionId + COLON);
                _ccRoot.HookupFn.Statements.Add(cssCase); 
            }
            else
            {
                // if (connectionId == 1) 
                //
                ccsConnector = new CodeConditionStatement(); 
                ccsConnector.Condition = new CodeBinaryOperatorExpression(new CodeArgumentReferenceExpression(CONNECTIONID), 
                                                                          CodeBinaryOperatorType.ValueEquality,
                                                                          new CodePrimitiveExpression(connectionId)); 
            }


            // (System.Windows.Controls.Footype)target; 
            CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);
            CodeCastExpression cceTarget = new CodeCastExpression(cc.ElementTypeReference, careTarget); 
            CodeExpression ceEvent = cceTarget; 

            // Names in nested Name scopes not be hooked up via ICC.Connect() as no fields are generated in this case. 
            if (elementName != null && isAllowedNameScope)
            {
                // this.fooId = (System.Windows.Controls.Footype)target;
                // 
                ceEvent = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), elementName);
                CodeAssignStatement casName = new CodeAssignStatement(ceEvent, cceTarget); 
                if (SwitchStatementSupported()) 
                {
                    _ccRoot.HookupFn.Statements.Add(casName); 
                }
                else
                {
                    ccsConnector.TrueStatements.Add(casName); 
                }
            } 
 
            if (events != null)
            { 
                foreach (MarkupEventInfo mei in events)
                {
                    CodeStatement csEvent = AddCLREvent(cc, ceEvent, mei);
 
                    if (SwitchStatementSupported())
                    { 
                        _ccRoot.HookupFn.Statements.Add(csEvent); 
                    }
                    else 
                    {
                        ccsConnector.TrueStatements.Add(csEvent);
                    }
                } 
            }
 
            // return; 
            //
            if (SwitchStatementSupported()) 
            {
                _ccRoot.HookupFn.Statements.Add(new CodeMethodReturnStatement());
            }
            else 
            {
                ccsConnector.TrueStatements.Add(new CodeMethodReturnStatement()); 
                _ccRoot.HookupFn.Statements.Add(ccsConnector); 
            }
 
            _typeArgsList = null;
        }

        private void EndHookups() 
        {
            if (_ccRoot.HookupFn != null) 
            { 
                _ccRoot.CodeClass.BaseTypes.Add(KnownTypes.Types[(int)KnownElements.IComponentConnector].FullName);
 
                if (SwitchStatementSupported())
                {
                    // Don't generate an empty Switch block!
                    if (_ccRoot.HookupFn.Statements.Count == 1 && 
                        _ccRoot.HookupFn.Statements[0] is CodeSnippetStatement)
                    { 
                        _ccRoot.HookupFn.Statements.Clear(); 
                    }
                    else 
                    {
                        // switch (connectionId)
                        // {
                        // } -- End Switch 
                        CodeSnippetStatement css = new CodeSnippetStatement(INDENT12 + ENDCURLY);
                        _ccRoot.HookupFn.Statements.Add(css); 
                    } 
                }
 
                // _contentLoaded = true;
                //
                CodeFieldReferenceExpression cfreContentLoaded = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), CONTENT_LOADED);
                CodeAssignStatement casContentLoaded = new CodeAssignStatement(cfreContentLoaded, new CodePrimitiveExpression(true)); 
                _ccRoot.HookupFn.Statements.Add(casContentLoaded);
 
                _ccRoot.CodeClass.Members.Add(_ccRoot.HookupFn); 
                _ccRoot.HookupFn = null;
            } 
        }

        internal void GenerateBamlFile(MemoryStream bamlMemStream)
        { 
            // write baml file only if we're not doing intellisense build
            if ((IsBamlNeeded) && (TaskFileService.IsRealBuild)) 
            { 
                string filepath = TargetPath + SourceFileInfo.RelativeSourceFilePath + BAML;
                using (FileStream bamlFileStream = new FileStream(filepath, FileMode.Create, FileAccess.Write)) 
                {
                    bamlMemStream.WriteTo(bamlFileStream);
                }
            } 
        }
 
#endregion Baml Hookup Functions 

#region Helpers 

        private void InitializeTypeMapper()
        {
            _typeMapper = XamlTypeMapper.DefaultMapper; 
            ReflectionHelper.LocalAssemblyName = AssemblyName;
            _typeMapper.SetReflectionOnlyAssemblyResolver(); 
 
            if (ReferenceAssemblyList != null && ReferenceAssemblyList.Count > 0)
            { 
                for (int i = 0; i < ReferenceAssemblyList.Count; i++)
                {
                    ReferenceAssembly refasm = ReferenceAssemblyList[i] as ReferenceAssembly;
 
                    if (refasm != null && refasm.Path.Length > 0)
                    { 
                        _typeMapper.SetAssemblyPath(refasm.AssemblyName, refasm.Path); 
                    }
                } 
            }

            string asmMissing = string.Empty;
            if (XamlTypeMapper.AssemblyWB == null) 
            {
                asmMissing = "WindowsBase"; 
            } 
            if (XamlTypeMapper.AssemblyPC == null)
            { 
                asmMissing += (asmMissing.Length > 0 ? ", " : string.Empty) + "PresentationCore";
            }
            if (XamlTypeMapper.AssemblyPF == null)
            { 
                asmMissing += (asmMissing.Length > 0 ? ", " : string.Empty) + "PresentationFramework";
            } 
 
            if (asmMissing.Length > 0)
            { 
                string message = SR.Get(SRID.WinFXAssemblyMissing, asmMissing);
                ApplicationException aeAssemblyMissing = new ApplicationException(message);
                throw aeAssemblyMissing;
            } 

            KnownTypes.InitializeKnownTypes(XamlTypeMapper.AssemblyPF, XamlTypeMapper.AssemblyPC, XamlTypeMapper.AssemblyWB); 
            _typeMapper.InitializeReferenceXmlnsCache(); 
        }
 
        private bool SwitchStatementSupported()
        {
            return (IsLanguageCSharp || (CompilerInfo != null && (string.Compare(CompilerInfo.GetLanguages()[0], JSCRIPT, StringComparison.OrdinalIgnoreCase) == 0)));
        } 

        private bool IsInternalAccessSupported 
        { 
            get
            { 
                return (CompilerInfo == null || (string.Compare(CompilerInfo.GetLanguages()[0], JSHARP, StringComparison.OrdinalIgnoreCase) != 0));
            }
        }
 
        private bool IsLanguageCaseSensitive()
        { 
            CodeDomProvider cdp = EnsureCodeProvider(); 
            return cdp.LanguageOptions != LanguageOptions.CaseInsensitive;
        } 

        private bool IsLanguageCSharp
        {
            get { return _isLangCSharp; } 
        }
 
        private bool IsLanguageVB 
        {
            get { return _isLangVB; } 
        }

        // Combine namespace and className
        private string GetFullClassName(string ns, string className) 
        {
            string fullClass = className; 
 
            if (ns != null && ns.Length > 0)
            { 
                fullClass = ns + DOT + className;
            }

            return fullClass; 
        }
 
        internal void ValidateFullSubClassName(ref string subClassFullName) 
        {
            bool isValid = false; 
            int index = subClassFullName.LastIndexOf(DOT, StringComparison.Ordinal);

            if (index > 0)
            { 
                string subClassName = subClassFullName.Substring(index + 1);
                isValid = IsValidCLRNamespace(subClassFullName.Substring(0, index), false) && 
                          IsValidClassName(subClassName); 
            }
            else 
            {
                isValid = IsValidClassName(subClassFullName);
            }
 
            if (!isValid)
            { 
                // flag error. Can't throw here as we are pre-scanning and parser context doesn't 
                // have customized linenum\linepos yet.
                subClassFullName = DOT; 
            }
        }

        private bool CrackClassName(ref string className, out string ns) 
        {
            bool isValid = true; 
            ns = string.Empty; 

            if (className.Length > 0) 
            {
                // Split the Namespace
                int index = className.LastIndexOf(DOT, StringComparison.Ordinal);
 
                if (index > 0)
                { 
                    ns = className.Substring(0, index); 
                    className = className.Substring(index + 1);
                    isValid = IsValidCLRNamespace(ns, false); 
                }

                isValid = isValid && IsValidClassName(className);
            } 

            return isValid; 
        } 

        internal string GetGenericTypeName(string typeName, string typeArgs) 
        {
            if (typeArgs.Length == 0)
            {
                ThrowCompilerException(SRID.UnknownGenericType, 
                                       DefinitionNSPrefix,
                                       typeArgs, 
                                       typeName); 
            }
 
            StringBuilder sb = new StringBuilder(typeName, 20);
            sb.Append(GENERIC_DELIMITER);

            _typeArgsList = typeArgs.Split(new Char[] { COMMA }); 

            sb.Append(_typeArgsList.Length); 
 
            return sb.ToString();
        } 

        private static void AddEditorBrowsableAttribute(CodeTypeMember ctmTarget)
        {
            CodeFieldReferenceExpression cfre = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(EditorBrowsableState)), "Never"); 
            CodeAttributeArgument caa = new CodeAttributeArgument(cfre);
            ctmTarget.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(EditorBrowsableAttribute).FullName, caa)); 
        } 

        private static void AddSuppressMessageAttribute(CodeTypeMember ctmTarget, string category, string rule) 
        {
            CodeAttributeDeclaration cad = new CodeAttributeDeclaration(
                         new CodeTypeReference(typeof(SuppressMessageAttribute)),
                         new CodeAttributeArgument(new CodePrimitiveExpression(category)), 
                         new CodeAttributeArgument(new CodePrimitiveExpression(rule)));
 
            ctmTarget.CustomAttributes.Add(cad); 
        }
 
        private static void AddDebuggerNonUserCodeAttribute(CodeTypeMember ctmTarget)
        {
            CodeAttributeDeclaration cad = new CodeAttributeDeclaration(
                         new CodeTypeReference(typeof(DebuggerNonUserCodeAttribute))); 

            ctmTarget.CustomAttributes.Add(cad); 
        } 

        internal static void GenerateXmlComments(CodeTypeMember ctm, string comment) 
        {
            // generate xml comments

            // ///  
            // /// 
            CodeCommentStatement ccs = new CodeCommentStatement(SummaryStartTag, true); 
            ctm.Comments.Add(ccs); 
            ccs = new CodeCommentStatement(comment, true);
            ctm.Comments.Add(ccs); 
            ccs = new CodeCommentStatement(SummaryEndTag, true);
            ctm.Comments.Add(ccs);
        }
 
        private bool IsValidClassName(string className)
        { 
            if (className.Length == 0 ||!NameValidationHelper.IsValidIdentifierName(className)) 
            {
                return false; 
            }

            return true;
        } 

        private bool IsValidCLRNamespace(string ns, bool shouldThrow) 
        { 
            if (ns.Length > 0)
            { 
                string[] nsParts = ns.Split(new char[] { DOTCHAR });

                foreach (string nsPart in nsParts)
                { 
                    if (!NameValidationHelper.IsValidIdentifierName(nsPart.Trim()))
                    { 
                        if (shouldThrow) 
                        {
                            ThrowCompilerException(SRID.InvalidDefaultCLRNamespace, nsPart, ns); 
                        }
                        else
                        {
                            return false; 
                        }
                    } 
                } 
            }
 
            return true;
        }

        internal void ValidateEventHandlerName(string eventName, string handlerName) 
        {
            if (!IsCodeNeeded) 
            { 
                ThrowCompilerException(SRID.MissingClassDefinitionForEvent, _ccRoot.ElementName, DefinitionNSPrefix, eventName);
            } 

            string handler = handlerName.Trim();
            if (handler.Length == 0)
            { 
                ThrowCompilerException(SRID.EmptyEventStringNotAllowed, eventName, handlerName);
            } 
            else if (!NameValidationHelper.IsValidIdentifierName(handler)) 
            {
                ThrowCompilerException(SRID.InvalidEventHandlerName, eventName, handlerName); 
            }
        }

        private string ParentFolderPrefix 
        {
            get 
            { 
                string parentFolderPrefix = string.Empty;
                if (TargetPath.StartsWith(SourceFileInfo.SourcePath, StringComparison.OrdinalIgnoreCase)) 
                {
                    string relPath = TargetPath.Substring(SourceFileInfo.SourcePath.Length);
                    relPath += SourceFileInfo.RelativeSourceFilePath;
                    string[] dirs = relPath.Split(new Char[] { ESCAPED_BACKSLASH_CHAR }); 
                    for (int i = 1; i < dirs.Length; i++)
                    { 
                        parentFolderPrefix += PARENTFOLDER; 
                    }
                } 

                return parentFolderPrefix;
            }
        } 

        private void AddLinePragma(CodeTypeMember ctm, int lineNumber) 
        { 
            CodeLinePragma clp = new CodeLinePragma(ParentFolderPrefix + SourceFileInfo.RelativeSourceFilePath + XAML, lineNumber);
            ctm.LinePragma = clp; 
        }

        private void AddLinePragma(CodeStatement cs, int lineNumber)
        { 
            CodeLinePragma clp = new CodeLinePragma(ParentFolderPrefix + SourceFileInfo.RelativeSourceFilePath + XAML, lineNumber);
            cs.LinePragma = clp; 
        } 

        internal MemberAttributes GetMemberAttributes(string modifier) 
        {
            if (!IsCodeNeeded)
            {
                ThrowCompilerException(SRID.MissingClassWithFieldModifier, DefinitionNSPrefix); 
            }
 
            if (_private.Length == 0) 
            {
                bool converted = false; 
                CodeDomProvider codeProvider = EnsureCodeProvider();
                TypeConverter converter = codeProvider.GetConverter(typeof(MemberAttributes));
                if (converter != null)
                { 
                    if (converter.CanConvertTo(typeof(string)))
                    { 
                        try 
                        {
                            _private = converter.ConvertToInvariantString(MemberAttributes.Private).ToLowerInvariant(); 
                            _public = converter.ConvertToInvariantString(MemberAttributes.Public).ToLowerInvariant();
                            _protected = converter.ConvertToInvariantString(MemberAttributes.Family).ToLowerInvariant();
                            _internal = converter.ConvertToInvariantString(MemberAttributes.Assembly).ToLowerInvariant();
                            _protectedInternal = converter.ConvertToInvariantString(MemberAttributes.FamilyOrAssembly).ToLowerInvariant(); 
                            converted = true;
                        } 
                        catch (NotSupportedException) 
                        {
                        } 
                    }
                }

                if (!converted) 
                {
                    ThrowCompilerException(SRID.UnknownFieldModifier, MarkupCompiler.DefinitionNSPrefix, modifier, _language); 
                } 
            }
 
            string normalizedModifier = modifier;
            if (!IsLanguageCaseSensitive())
            {
                normalizedModifier = modifier.ToLowerInvariant(); 
            }
 
            if (normalizedModifier.Equals(_private)) 
            {
                return MemberAttributes.Private; 
            }
            else if (normalizedModifier.Equals(_public))
            {
                return MemberAttributes.Public; 
            }
            else if (normalizedModifier.Equals(_protected)) 
            { 
                return MemberAttributes.Family;
            } 
            else if (normalizedModifier.Equals(_internal))
            {
                return MemberAttributes.Assembly;
            } 
            else if (normalizedModifier.Equals(_protectedInternal))
            { 
                return MemberAttributes.FamilyOrAssembly; 
            }
            else 
            {
                ThrowCompilerException(SRID.UnknownFieldModifier, MarkupCompiler.DefinitionNSPrefix, modifier, _language);
            }
 
            return MemberAttributes.Assembly;
        } 
 
        private TypeAttributes GetTypeAttributes(ref string modifier)
        { 
            if (modifier.Length > 0)
            {
                if (_privateClass.Length == 0)
                { 
                    bool converted = false;
                    CodeDomProvider codeProvider = EnsureCodeProvider(); 
                    TypeConverter converter = codeProvider.GetConverter(typeof(TypeAttributes)); 
                    if (converter != null)
                    { 
                        if (converter.CanConvertTo(typeof(string)))
                        {
                            try
                            { 
                                _privateClass = converter.ConvertToInvariantString(TypeAttributes.NotPublic).ToLowerInvariant();
                                _publicClass = converter.ConvertToInvariantString(TypeAttributes.Public).ToLowerInvariant(); 
                                converted = true; 
                            }
                            catch (NotSupportedException) 
                            {
                            }
                        }
                    } 

                    if (!converted) 
                    { 
                        ThrowCompilerException(SRID.UnknownClassModifier, MarkupCompiler.DefinitionNSPrefix, modifier, _language);
                    } 
                }

                string normalizedModifier = modifier;
                if (!IsLanguageCaseSensitive()) 
                {
                    normalizedModifier = modifier.ToLowerInvariant(); 
                } 

                if (normalizedModifier.Equals(_privateClass)) 
                {
                    return TypeAttributes.NotPublic;
                }
                else if (normalizedModifier.Equals(_publicClass)) 
                {
                    return TypeAttributes.Public; 
                } 
                else
                { 
                    // flag error. Can't throw here as we are pre-scanning and parser context doesn't
                    // have customized linenum\linepos yet.
                    modifier = DOT;
                } 
            }
 
            return TypeAttributes.Public; 
        }
 
        internal void CheckForNestedNameScope()
        {
            CodeContext cc = (CodeContext)_codeContexts.Peek();
            if (_codeContexts.Count > 1 && KnownTypes.Types[(int)KnownElements.INameScope].IsAssignableFrom(cc.ElementType)) 
            {
                cc.IsAllowedNameScope = false; 
            } 
        }
 
#endregion Helpers

#region Property
 
        private CodeExpression GetPropertyValueExpression(ITypeDescriptorContext ctx, Type typeToConvertTo, Object value, string attributeValue)
        { 
            CodeExpression ce = null; 
            InstanceDescriptor desc = null;
            TypeConverter converter = null; 

            if (value != null && (typeToConvertTo == typeof(String) || typeToConvertTo.IsPrimitive))
            {
                ce = new CodePrimitiveExpression(value); 
            }
            else if (typeToConvertTo == typeof(Uri)) 
            { 
                converter = new UriTypeConverter();
                if (!UriParser.IsKnownScheme(URISCHEME_PACK)) 
                {
                    UriParser.Register(new GenericUriParser(GenericUriParserOptions.GenericAuthority), URISCHEME_PACK, -1);
                }
            } 
            else if (typeToConvertTo.IsEnum)
            { 
                converter = new EnumConverter(typeToConvertTo); 
            }
 
            if (converter != null)
            {
                if (value == null)
                { 
                    if (attributeValue != null)
                    { 
                        value = converter.ConvertFromString(ctx, TypeConverterHelper.EnglishUSCulture, attributeValue); 

                        if (value == null) 
                        {
                            return null;
                        }
                    } 
                    else
                    { 
                        ce = new CodePrimitiveExpression(null); 
                        return ce;
                    } 
                }

                if (converter.CanConvertTo(ctx, typeof(InstanceDescriptor)))
                { 
                    desc = (InstanceDescriptor)converter.ConvertTo(ctx, TypeConverterHelper.EnglishUSCulture, value, typeof(InstanceDescriptor));
 
                    Debug.Assert(desc != null); 

                    // static field ref... 
                    if (desc.MemberInfo is FieldInfo || desc.MemberInfo is PropertyInfo)
                    {
                        CodeFieldReferenceExpression cfre = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name);
                        ce = cfre; 
                    }
                    else  // static method invoke 
                    { 
                        object[] args = new object[desc.Arguments.Count];
                        desc.Arguments.CopyTo(args, 0); 
                        CodeExpression[] expressions = new CodeExpression[args.Length];

                        if (desc.MemberInfo is MethodInfo)
                        { 
                            MethodInfo mi = (MethodInfo)desc.MemberInfo;
                            ParameterInfo[] parameters = mi.GetParameters(); 
 
                            for (int i = 0; i < args.Length; i++)
                            { 
                                expressions[i] = GetPropertyValueExpression(ctx, parameters[i].ParameterType, args[i], null);
                            }

                            CodeMethodInvokeExpression cmie = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(desc.MemberInfo.DeclaringType.FullName), desc.MemberInfo.Name); 
                            foreach (CodeExpression e in expressions)
                            { 
                                cmie.Parameters.Add(e); 
                            }
 
                            ce = cmie;
                        }
                        else if (desc.MemberInfo is ConstructorInfo)  // instance ctor invoke
                        { 
                            ConstructorInfo ci = (ConstructorInfo)desc.MemberInfo;
                            ParameterInfo[] parameters = ci.GetParameters(); 
 
                            for (int i = 0; i < args.Length; i++)
                            { 
                                expressions[i] = GetPropertyValueExpression(ctx, parameters[i].ParameterType, args[i], null);
                            }

                            CodeObjectCreateExpression coce = new CodeObjectCreateExpression(desc.MemberInfo.DeclaringType.FullName); 
                            foreach (CodeExpression e in expressions)
                            { 
                                coce.Parameters.Add(e); 
                            }
 
                            ce = coce;
                        }
                    }
                } 
            }
 
            return ce; 
        }
 
#endregion Property

#region Event
 
        // The given MemberInfo could either be an EventInfo for a Clr event or a
        // MethodInfo for a static Add{EventName}Handler helper for an attached event 
        private Type GetEventHandlerType(MemberInfo memberInfo) 
        {
            Type eventHandlerType = null; 
            if (memberInfo is EventInfo)
            {
                EventInfo ei = (EventInfo)memberInfo;
                eventHandlerType = ei.EventHandlerType; 
            }
            else 
            { 
                MethodInfo mi = (MethodInfo)memberInfo;
                ParameterInfo[] pis = mi.GetParameters(); 
                Debug.Assert(pis != null && pis.Length == 2 && KnownTypes.Types[(int)KnownElements.DependencyObject].IsAssignableFrom(pis[0].ParameterType));
                eventHandlerType = pis[1].ParameterType;
            }
 
            return eventHandlerType;
        } 
 
        private CodeFieldReferenceExpression GetEvent(MemberInfo miEvent, string eventName, string eventHandler)
        { 
            FieldInfo fiEvent = miEvent.DeclaringType.GetField(eventName + EVENT, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
            if (fiEvent == null || fiEvent.FieldType != KnownTypes.Types[(int)KnownElements.RoutedEvent])
            {
                ThrowCompilerException(SRID.RoutedEventNotRegistered, miEvent.DeclaringType.FullName, eventName, eventHandler); 
            }
 
            CodeTypeReferenceExpression ctreEvent = new CodeTypeReferenceExpression(miEvent.DeclaringType.FullName); 
            CodeFieldReferenceExpression cfreEvent = new CodeFieldReferenceExpression(ctreEvent, fiEvent.Name);
            return cfreEvent; 
        }


        private CodeExpression GetEventDelegate(CodeContext cc, MemberInfo miEvent, string eventName, string eventHandler) 
        {
            Type eventTarget = cc != null ? cc.ElementType : miEvent.DeclaringType; 
            string eventTargetName = eventTarget != null ? eventTarget.FullName : cc.LocalElementFullName; 

            bool subClassed = _ccRoot.SubClass.Length > 0; 
            CodeDelegateCreateExpression cdce = new CodeDelegateCreateExpression();

            // Fetch the EventHandlerType from either the EventInfo or the MethodInfo
            // for the Add{Propertyname}Handler method's MethodInfo 
            Type eventHandlerType = GetEventHandlerType(miEvent);
            string [] typeArgsList = cc != null ? cc.GenericTypeArgs : null; 
 
            cdce.DelegateType = GenerateConstructedTypeReference(eventHandlerType, typeArgsList, eventTarget, eventTargetName, eventName);
            cdce.MethodName = eventHandler.Trim() + (subClassed ? HELPER : string.Empty); 
            cdce.TargetObject = new CodeThisReferenceExpression();
            CodeExpression cDelExp = cdce;

            // NOTE: workaround for VB CodeDom bug which does not produce correct Delegate expression code 
            if (IsLanguageVB)
            { 
                CodeExpression[] delParams = { cdce }; 
                CodeObjectCreateExpression coce = new CodeObjectCreateExpression(eventHandlerType, delParams);
                cDelExp = coce; 
            }

//            The bug that this chunk of code works around (VS#542946) was fixed but
//            exposes a different bug (VS#572060)   To work around the second bug, we 
//            remove the workaround for the first one.  (RogerCh 20020918)
 
//            Note that #542946 was not fixed for VB, so the code block above remains. 

//            else if (Language == CompilerLanguage.JScript) 
//            {
//                CodeCastExpression cce = new CodeCastExpression(mei.ei.EventHandlerType, cdce);
//                cDelExp = cce;
//            } 

            return cDelExp; 
        } 

 
        private CodeStatement AddCLREvent(CodeContext cc, CodeExpression ce, MarkupEventInfo mei)
        {
            // Infer the event target's (aka the listener) type from the current code context
            return AddCLREvent( cc.ElementType, cc, ce, mei ); 
        }
 
        private CodeStatement AddCLREvent(Type eventTarget, CodeContext cc, CodeExpression ce, MarkupEventInfo mei) 
        {
 
            bool subClassed = _ccRoot.SubClass.Length > 0;
            CodeStatement csEvent = null;
            // param2: 
            CodeExpression cDelExp = GetEventDelegate(cc, mei.mi, mei.eventName, mei.eventHandler); 

            if (mei.mi.DeclaringType.IsAssignableFrom(eventTarget)) 
            { 
                // _element.FooEvent += new FooEventHandlerDelegate(OnFoo);
                csEvent = new CodeAttachEventStatement(ce, mei.eventName, cDelExp); 
            }
            else if (eventTarget == null || // for known attached events on unknown local tags
                     KnownTypes.Types[(int)KnownElements.UIElement].IsAssignableFrom(eventTarget) ||
                     KnownTypes.Types[(int)KnownElements.ContentElement].IsAssignableFrom(eventTarget)) 
            {
                // _element.AddHandler(FooEvent, new FooEventHandlerDelegate(OnFoo)); 
                CodeFieldReferenceExpression cfreEvent = GetEvent(mei.mi, mei.eventName, mei.eventHandler); 
                CodeMethodInvokeExpression cmieAddHandler = new CodeMethodInvokeExpression(ce, ADDHANDLER, cfreEvent, cDelExp);
                csEvent = new CodeExpressionStatement(cmieAddHandler); 
            }
            else
            {
                string eventTargetName = eventTarget != null ? eventTarget.FullName : cc.LocalElementFullName; 
                ThrowCompilerException(SRID.UnknownEventAttribute, mei.eventName, mei.eventHandler, eventTargetName);
            } 
 
            // When x:SubClass is used, event handlers can be specified in a code-behind file, under this sub class.
            // But these handler methods need to be accessible from the intermediary generated sub class. So an empty 
            // internal virtual method with the same signature as the handler method is generated in this intermediary
            // sub class (in the generated file):
            //
            //      internal virtual void OnFooEvent(object sender, FooEventArgs ea) 
            //      {
            //      } 
            // 
            // Since a delegate cannot take the address of a virtual function, a non-virtual helper function
            // with the same signature as the above function & which calls the above function is also generated: 
            //
            //      private void OnFooEventHelper(object sender, FooEventArgs ea)
            //      {
            //          OnFooEvent(sender, ea); 
            //      }
            // 
            // All this is done only if x:Subclass is specified, since this means that this sub class would need to be 
            // defined in a code-behind file. This also means that inline events (in ) will not be supported.
 
            if (subClassed)
            {
                GenerateProtectedEventHandlerMethod(mei);
            } 

            AddLinePragma(csEvent, mei.lineNumber); 
            return csEvent; 
        }
 
        private void GenerateProtectedEventHandlerMethod(MarkupEventInfo mei)
        {
            Debug.Assert(_ccRoot != null && _ccRoot.SubClass.Length > 0);
 
            // Fetch the EventHandlerType from either the EventInfo or the MethodInfo
            // for the Add{Propertyname}Handler method's MethodInfo 
            Type eventHandlerType = GetEventHandlerType(mei.mi); 

            MethodInfo methodInvoke = eventHandlerType.GetMethod("Invoke"); 
            ParameterInfo[] pars = methodInvoke.GetParameters();

            CodeMemberMethod cmmEventHandler = new CodeMemberMethod();
            CodeMemberMethod cmmEventHandlerHelper = new CodeMemberMethod(); 

            AddDebuggerNonUserCodeAttribute(cmmEventHandlerHelper); 
 
            cmmEventHandler.Attributes = MemberAttributes.Assembly | MemberAttributes.Overloaded;
            cmmEventHandler.ReturnType = new CodeTypeReference(typeof(void)); 
            cmmEventHandler.Name = mei.eventHandler.Trim();

            CodeMethodInvokeExpression cmieOnEvent = new CodeMethodInvokeExpression(null, cmmEventHandler.Name);
 
            for (int i = 0; i < pars.Length; i++)
            { 
                CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(pars[i].ParameterType, pars[i].Name); 
                cmmEventHandler.Parameters.Add(param);
                cmmEventHandlerHelper.Parameters.Add(param); 
                cmieOnEvent.Parameters.Add(new CodeArgumentReferenceExpression(pars[i].Name));
            }

            // 
            // internal virtual void OnFooEvent(object sender, FooEventArgs ea)
            // { 
            // } 
            //
            _ccRoot.CodeClass.Members.Add(cmmEventHandler); 

            cmmEventHandlerHelper.Name = cmmEventHandler.Name + HELPER;
            cmmEventHandlerHelper.ReturnType = new CodeTypeReference(typeof(void));
            cmmEventHandlerHelper.Statements.Add(new CodeExpressionStatement(cmieOnEvent)); 

            // 
            // private void OnFooEventHelper(object sender, FooEventArgs ea) 
            // {
            //     OnFooEvent(sender, ea); 
            // }
            //
            _ccRoot.CodeClass.Members.Add(cmmEventHandlerHelper);
        } 

        internal struct MarkupEventInfo 
        { 
            internal MarkupEventInfo(string eh, string en, MemberInfo mi, int ln)
            { 
                eventHandler = eh;
                eventName = en;
                this.mi = mi;
                lineNumber = ln; 
            }
 
            internal string eventHandler; 
            internal string eventName;
            internal MemberInfo mi; 
            internal int lineNumber;
        }

#endregion Event 

#region Language 
 
        private CodeDomProvider EnsureCodeProvider()
        { 
            if (_codeProvider == null)
            {
                Debug.Assert(CompilerInfo != null && CompilerInfo.IsCodeDomProviderTypeValid);
                _codeProvider = CompilerInfo.CreateProvider(); 
            }
 
            return _codeProvider; 
        }
 
        private bool IsLanguageSupported(string language)
        {
            _language = language;
            _isLangCSharp = string.Compare(language, CSHARP, StringComparison.OrdinalIgnoreCase) == 0; 

            if (IsLanguageCSharp) 
            { 
                _codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
                return true; 
            }
            else
            {
                _isLangVB = string.Compare(language, VB, StringComparison.OrdinalIgnoreCase) == 0; 
                if (IsLanguageVB)
                { 
                    _codeProvider = new Microsoft.VisualBasic.VBCodeProvider(); 
                    return true;
                } 
            }

            if (CodeDomProvider.IsDefinedLanguage(language))
            { 
                CompilerInfo = CodeDomProvider.GetCompilerInfo(language);
                return (CompilerInfo != null); 
            } 

            return false; 
        }

        //
        private void EnsureLanguageSourceExtension() 
        {
            // If empty string is passed, use the default language source extension. 
            if (String.IsNullOrEmpty(LanguageSourceExtension)) 
            {
                if (CompilerInfo != null) 
                {
                    string[] listExtensions = CompilerInfo.GetExtensions();
                    LanguageSourceExtension = listExtensions[0];
                } 
                else if (IsLanguageCSharp)
                { 
                    LanguageSourceExtension = ".cs"; 
                }
                else if (IsLanguageVB) 
                {
                    LanguageSourceExtension = ".vb";
                }
            } 
        }
 
#endregion Language 

#region CorePageGen 

        internal CodeMemberField AddNameField(string name, int lineNumber)
        {
            CodeMemberField cmField = AddNameField(name); 
            if (cmField != null)
            { 
                AddLinePragma(cmField, lineNumber); 
            }
            return cmField; 
        }

        internal CodeMemberField AddNameField(string name)
        { 
            // Names in nested Name scopes should not have Name fields
            CodeContext cc = (CodeContext)_codeContexts.Peek(); 
            if (!cc.IsAllowedNameScope) 
            {
                return null; 
            }

            CodeMemberField field = new CodeMemberField();
            field.Name = name; 
            field.Attributes = MemberAttributes.Assembly;
            field.Type = cc.ElementTypeReference; 
 
            // Generate WithEvents ID fields in VB for objects supporting events
            field.UserData["WithEvents"] = true; 

            _ccRoot.CodeClass.Members.Add(field);
            return field;
        } 

        private void AddCodeSnippet(string codeText, int lineNum) 
        { 
            if (codeText == null || codeText.Trim().Length == 0)
                return; 

            CodeSnippetTypeMember snippet = new CodeSnippetTypeMember();
            AddLinePragma(snippet, lineNum);
            snippet.Text = codeText; 
            _ccRoot.CodeClass.Members.Add(snippet);
        } 
 
        internal void AddGenericArguments(ParserContext parserContext, string typeArgs)
        { 
            if (_typeArgsList != null)
            {
                string localTypeArgNamespace = string.Empty;
                string localTypeArgClassName = string.Empty; 

                // for each generic param in this Type ... 
                for (int i = 0; i < _typeArgsList.Length; i++) 
                {
                    Type currTypeArg = parserContext.XamlTypeMapper.GetTypeArgsType(_typeArgsList[i].Trim(), 
                                                                                    parserContext,
                                                                                    out localTypeArgClassName,
                                                                                    out localTypeArgNamespace);
 
                    if (currTypeArg == null)
                    { 
                        bool error = false; 
                        if (localTypeArgNamespace.Length == 0 && localTypeArgClassName.Length == 0)
                        { 
                            error = true;
                        }
                        else
                        { 
                            error = !IsValidClassName(localTypeArgClassName) ||
                                    !IsValidCLRNamespace(localTypeArgNamespace, false); 
                        } 

                        if (error) 
                        {
                            ThrowCompilerException(SRID.InvalidTypeName,
                                                   MarkupCompiler.DefinitionNSPrefix,
                                                   typeArgs, 
                                                   _typeArgsList[i].Trim(),
                                                   (i + 1).ToString(CultureInfo.CurrentCulture)); 
                        } 
                        else
                        { 
                            _typeArgsList[i] = GetFullClassName(localTypeArgNamespace, localTypeArgClassName);
                        }
                    }
                    else 
                    {
                        _typeArgsList[i] = currTypeArg.FullName; 
                    } 

                    // construct the type args list for the base class type to be generated 
                    _ccRoot.CodeClass.BaseTypes[0].TypeArguments.Add(new CodeTypeReference(_typeArgsList[i]));
                }
            }
        } 

        private static CodeTypeReference GenerateConstructedTypeReference(Type t, string [] typeArgsList, string genericName) 
        { 
            CodeTypeReference ctrConstructedType = null;
 
            // If the type has generic parameters, then need to add TypeArguments to the CodeTypeReference of this Type
            if (genericName.Length > 0 || t.IsGenericType)
            {
                Debug.Assert(genericName.Length > 0 || t.IsGenericTypeDefinition); 

                if (t != null) 
                { 
                    Debug.Assert(genericName.Length == 0 && typeArgsList != null);
 
                    // NOTE: Remove when CodeDom is fixed to understand mangled generic names.
                    genericName = t.FullName;
                    int bang = genericName.IndexOf(GENERIC_DELIMITER, StringComparison.Ordinal);
                    if (bang > 0) 
                    {
                        genericName = genericName.Substring(0, bang); 
                    } 
#if DBG
                    Type[] typeParams = t.GetGenericArguments(); 

                    // TypeArgument count must match TypeParameter count on generic type.
                    Debug.Assert(typeArgsList != null && typeArgsList.Length == typeParams.Length);
 
                    // for each generic param in this Type ...
                    for (int i = 0; i < typeArgsList.Length; i++) 
                    { 
                        // Type params should always be unbound
                        Debug.Assert(typeParams[i].IsGenericParameter); 
                    }
#endif
                }
 
                ctrConstructedType = new CodeTypeReference(genericName);
            } 
            else 
            {
                ctrConstructedType = new CodeTypeReference(t.FullName); 
            }

            return ctrConstructedType;
        } 

        private static CodeTypeReference GenerateConstructedTypeReference(Type t, string [] typeArgsList, Type refType, string refTypeFullName, string eventName) 
        { 
            CodeTypeReference ctrConstructedType = null;
 
            // If the type has generic parameters, then need to add TypeArguments to the CodeTypeReference of this Type
            if (t.IsGenericType)
            {
                Type[] refTypeParams = null; 
                CodeTypeReference ctrTypeArg = null;
                Type[] typeParams = t.GetGenericArguments(); 
 
                // NOTE: Remove when CodeDom is fixed to understand mangled generic names.
                string genericName = t.Namespace + DOT + t.Name; 
                int bang = genericName.IndexOf(GENERIC_DELIMITER, StringComparison.Ordinal);
                if (bang > 0)
                {
                    genericName = genericName.Substring(0, bang); 
                }
 
                ctrConstructedType = new CodeTypeReference(genericName); 

                // NOTE: For certain types like EventHandler delegate types, CodeDom seems 
                // to add bogus CodeTypeReferences as TypeArguments, so it needs to be cleared explicitly.
                ctrConstructedType.TypeArguments.Clear();

                // for each generic param in this Type ... 
                foreach (Type typeParam in typeParams)
                { 
                    // if the param is unbound 
                    if (typeParam.IsGenericParameter)
                    { 
                        // get the generic params of the containing\reference Type, only once
                        if (refTypeParams == null)
                        {
                            if (refType == null || !refType.IsGenericType || !refType.IsGenericTypeDefinition || typeArgsList == null) 
                            {
                                ThrowCompilerException(SRID.ContainingTagNotGeneric, eventName, ctrConstructedType.BaseType, refTypeFullName); 
                            } 

                            refTypeParams = refType.GetGenericArguments(); 
                        }

                        ctrTypeArg = null;
 
                        // for each reference generic param
                        for (int i = 0; i < refTypeParams.Length; i++) 
                        { 
                            // if it matches the current generic param of this Type
                            if (refTypeParams[i] == typeParam) 
                            {
                                // The TypeArgumentList must have already been populated with full Type names &
                                // the TypeArgument count must match TypeParameter count on generic reference type.
                                Debug.Assert(typeArgsList != null && typeArgsList.Length == refTypeParams.Length); 

                                // Find the Type argument from the list that is in the same position as generic Type param 
                                string currTypeArg = typeArgsList[i]; 

                                // and create a CodeTypeReference from it 
                                ctrTypeArg = new CodeTypeReference(currTypeArg);
                                break;
                            }
                        } 

                        // no match! 
                        if (ctrTypeArg == null) 
                        {
                            ThrowCompilerException(SRID.MatchingTypeArgsNotFoundInRefType, 
                                                   eventName,
                                                   ctrConstructedType.BaseType,
                                                   typeParam.FullName,
                                                   refTypeFullName + "<" + string.Join(",", typeArgsList) + ">"); 
                        }
                    } 
                    else 
                    {
                        ctrTypeArg = new CodeTypeReference(typeParam); 
                    }

                    // construct the type args list for the base class type to be generated
                    ctrConstructedType.TypeArguments.Add(ctrTypeArg); 
                }
            } 
            else 
            {
                ctrConstructedType = new CodeTypeReference(t.FullName); 
            }

            return ctrConstructedType;
        } 

        private CodeTypeDeclaration GenerateClass(string className, ref string modifier, Type baseClass, string baseClassFullName) 
        { 
            // public class MyClass : BaseClass {
            // 
            CodeTypeReference ctrBaseClass = null;
            CodeTypeDeclaration ctdClass = new CodeTypeDeclaration();
            ctdClass.Name = className;
            if (baseClass != null) 
            {
                // At this point, we should only have fully open generic types if there is a typeargs list. 
                Debug.Assert(_typeArgsList == null || (baseClass.IsGenericType && baseClass.IsGenericTypeDefinition)); 
                Debug.Assert(_typeArgsList != null || !baseClass.IsGenericType);
 
                ctrBaseClass = GenerateConstructedTypeReference(baseClass, _typeArgsList, string.Empty);

                // Add the type reference for the normal or fully constructed generic base class
                ctdClass.BaseTypes.Add(ctrBaseClass); 
            }
            else if (baseClassFullName.Length > 0) 
            { 
                ctrBaseClass = GenerateConstructedTypeReference(null, _typeArgsList, baseClassFullName);
 
                // Add the type reference for the local base class
                ctdClass.BaseTypes.Add(ctrBaseClass);
            }
 
            ctdClass.TypeAttributes = GetTypeAttributes(ref modifier);
            ctdClass.Members.Clear(); 
 
            if (TypeAttributes.Public == ctdClass.TypeAttributes)
            { 
                GenerateXmlComments(ctdClass, className);
            }

            // VBNOTE: The VB compiler will generate a ctor with an InitializeComponent call if not explicitly specified 
            // by the user if this Attribute is set on the class.
            if (IsLanguageVB && !IsCompilingEntryPointClass) 
            { 
                ctdClass.CustomAttributes.Add(new CodeAttributeDeclaration("Microsoft.VisualBasic.CompilerServices.DesignerGenerated"));
            } 

            return ctdClass;
        }
 
        private CodeContext GenerateSubClass(ref string className, ref string modifier, Type baseClass, string baseClassFullName)
        { 
            string ns = string.Empty; 
            string baseClassName = string.Empty;
            bool isValidClassName = CrackClassName(ref className, out ns); 

            if (!string.IsNullOrEmpty(baseClassFullName))
            {
                int dotIndex = baseClassFullName.LastIndexOf(DOTCHAR); 
                if (dotIndex != -1)
                { 
                    baseClassName = baseClassFullName.Substring(dotIndex + 1); 
                    if (!IsValidClassName(baseClassName))
                    { 
                        ThrowCompilerException(SRID.InvalidBaseClassName, baseClassName);
                    }
                    string bns = baseClassFullName.Substring(0, dotIndex);
                    if (!IsValidCLRNamespace(bns, false)) 
                    {
                        ThrowCompilerException(SRID.InvalidBaseClassNamespace, bns, baseClassName); 
                    } 
                }
            } 

            if (!isValidClassName)
            {
                // flag error. Can't throw here as we are pre-scanning and parser context doesn't 
                // have customized linenum\linepos yet.
                className = DOT; 
            } 
            else if (IsCompilingEntryPointClass && className.Length == 0)
            { 
                string baseName = baseClass != null ? baseClass.Name : baseClassName;
                className = ANONYMOUS_ENTRYCLASS_PREFIX + baseName;
                Debug.Assert(!string.IsNullOrEmpty(baseName));
                ns = XamlTypeMapper.GeneratedNamespace; 
            }
 
            // namespace MyNamespace 
            // {
            Debug.Assert(_ccRoot == null); 
            Debug.Assert(_codeContexts == null || _codeContexts.Count == 0, "mismatched CodeContexts");
            CodeNamespace cns = new CodeNamespace();
            cns.Name = ns;
            cns.Types.Clear(); 

            CodeTypeDeclaration ctdClass = GenerateClass(className, ref modifier, baseClass, baseClassFullName); 
            CodeContext cc = new CodeContextRoot(ctdClass, cns, baseClass, _typeArgsList, baseClassFullName); 
            cc.ElementTypeReference = new CodeTypeReference(GetFullClassName(ns, className));
 
            return cc;
        }

        private void GenerateCreateDelegateHelper() 
        {
            if (!IsInternalAccessSupported || !HasLocalEvent) 
            { 
                return;
            } 

            Debug.Assert(HasLocalReference, "if we have a local event, there should be a local mapping PI for it");

            // internal Delegate _CreateDelegate(Type delegateType, string handler) 
            // {
            //     return Delegate.CreateDelegate(delegateType, this, handler); 
            // } 
            //
            CodeMemberMethod cmmCD = new CodeMemberMethod(); 
            cmmCD.Name = CREATEDELEGATEHELPER;
            cmmCD.ReturnType = new CodeTypeReference(typeof(Delegate));
            cmmCD.Attributes = MemberAttributes.Assembly | MemberAttributes.Final;
            AddDebuggerNonUserCodeAttribute(cmmCD); 
            AddSuppressMessageAttribute(cmmCD, "Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode");
 
            CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(Type), DELEGATETYPE); 
            CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(string), HANDLERARG);
            cmmCD.Parameters.Add(param1); 
            cmmCD.Parameters.Add(param2);

            CodeMethodReferenceExpression cmreCD = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Delegate)), "CreateDelegate");
            CodeMethodInvokeExpression cmieCD = new CodeMethodInvokeExpression(); 
            cmieCD.Method = cmreCD;
            cmieCD.Parameters.Add(new CodeArgumentReferenceExpression(DELEGATETYPE)); 
            cmieCD.Parameters.Add(new CodeThisReferenceExpression()); 
            cmieCD.Parameters.Add(new CodeArgumentReferenceExpression(HANDLERARG));
 
            cmmCD.Statements.Add(new CodeMethodReturnStatement(cmieCD));
            _ccRoot.CodeClass.Members.Add(cmmCD);
        }
 
        private void GenerateInitializeComponent(bool isApp)
        { 
            // public void InitializeComponent() 
            // {
            // 
            CodeMemberMethod cmmLC = _ccRoot.InitializeComponentFn;

            if (cmmLC == null)
            { 
                cmmLC = _ccRoot.EnsureInitializeComponentFn;
                if (!isApp) 
                { 
                    cmmLC.ImplementationTypes.Add(new CodeTypeReference(KnownTypes.Types[(int)KnownElements.IComponentConnector]));
                } 
            }

            //     if (_contentLoaded)
            //     { 
            //         return;
            //     } 
            // 
            CodeConditionStatement ccsCL = new CodeConditionStatement();
            ccsCL.Condition = new CodeFieldReferenceExpression(null, CONTENT_LOADED); 
            ccsCL.TrueStatements.Add(new CodeMethodReturnStatement());
            if (!isApp)
            {
                cmmLC.Statements.Add(ccsCL); 
            }
            else 
            { 
                cmmLC.Statements.Insert(0, ccsCL);
            } 

            //     _contentLoaded = true;
            //
            CodeAssignStatement casCL = new CodeAssignStatement(new CodeFieldReferenceExpression(null, CONTENT_LOADED), 
                                                                new CodePrimitiveExpression(true));
            if (!isApp) 
            { 
                cmmLC.Statements.Add(casCL);
            } 
            else
            {
                cmmLC.Statements.Insert(1, casCL);
            } 

            // Generate canonicalized string as resource id. 
            string resourceID = ResourceIDHelper.GetResourceIDFromRelativePath(SourceFileInfo.RelativeSourceFilePath + XAML); 
            string uriPart = string.Empty;
 
            string version = String.IsNullOrEmpty(AssemblyVersion) ? String.Empty : COMPONENT_DELIMITER + VER + AssemblyVersion;
            string token = String.IsNullOrEmpty(AssemblyPublicKeyToken) ? String.Empty : COMPONENT_DELIMITER + AssemblyPublicKeyToken;
            uriPart = FORWARDSLASH + AssemblyName + version + token + COMPONENT_DELIMITER + COMPONENT + FORWARDSLASH + resourceID;
 
            //
            //  Uri resourceLocator = new Uri(uriPart, UriKind.Relative); 
            // 
            string resVarname = RESOURCE_LOCATER;
 
            CodeFieldReferenceExpression cfreRelUri = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(System.UriKind)), "Relative");

            CodeExpression[] uriParams = { new CodePrimitiveExpression(uriPart), cfreRelUri };
            CodeObjectCreateExpression coceResourceLocator = new CodeObjectCreateExpression(typeof(System.Uri), uriParams); 
            CodeVariableDeclarationStatement cvdsresLocator = new CodeVariableDeclarationStatement(typeof(System.Uri), resVarname, coceResourceLocator);
 
            cmmLC.Statements.Add(cvdsresLocator); 

            // 
            //  System.Windows.Application.LoadComponent(this, resourceLocator);
            //
            CodeMethodReferenceExpression cmreLoadContent = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(KnownTypes.Types[(int)KnownElements.Application]), LOADCOMPONENT);
            CodeMethodInvokeExpression cmieLoadContent = new CodeMethodInvokeExpression(); 

            cmieLoadContent.Method = cmreLoadContent; 
 
            CodeVariableReferenceExpression cvreMemStm = new CodeVariableReferenceExpression(resVarname);
 
            cmieLoadContent.Parameters.Add(new CodeThisReferenceExpression());
            cmieLoadContent.Parameters.Add(cvreMemStm);

            CodeExpressionStatement cesLC = new CodeExpressionStatement(cmieLoadContent); 
            AddLinePragma(cesLC, 1);
            cmmLC.Statements.Add(cesLC); 
 
            // private bool _contentLoaded;
            // 
            CodeMemberField cmfCL = new CodeMemberField();
            cmfCL.Name = CONTENT_LOADED;
            cmfCL.Attributes = MemberAttributes.Private;
            cmfCL.Type = new CodeTypeReference(typeof(bool)); 
            _ccRoot.CodeClass.Members.Add(cmfCL);
 
            if (!isApp) 
            {
                // Make sure that ICC.Connect is generated to avoid compilation errors 
                EnsureHookupFn();
            }
        }
 
        private void GenerateInternalTypeHelperImplementation()
        { 
            if (!IsInternalAccessSupported || 
                !(HasInternals || HasLocalReference) ||
                _hasGeneratedInternalTypeHelper) 
            {
                return;
            }
 
            _hasGeneratedInternalTypeHelper = true;
 
            // namespace XamlGeneratedNamespace 
            // {
            // 
            CodeNamespace cns = new CodeNamespace();
            cns.Name = XamlTypeMapper.GeneratedNamespace;

            //     [EditorBrowsable(EditorBrowsableState.Never)] 
            //     public sealed class GeneratedInternalTypeHelper : InternalTypeHelper
            //     { 
            // 
            CodeTypeDeclaration ctdClass = new CodeTypeDeclaration();
            ctdClass.Name = XamlTypeMapper.GeneratedInternalTypeHelperClassName; 
            ctdClass.BaseTypes.Add(new CodeTypeReference("System.Windows.Markup.InternalTypeHelper"));
            ctdClass.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
            AddDebuggerNonUserCodeAttribute(ctdClass);
            AddEditorBrowsableAttribute(ctdClass); 
            GenerateXmlComments(ctdClass, ctdClass.Name);
 
            //         protected override object CreateInstance(Type type, CultureInfo culture) 
            //         {
            //             return Activator.CreateInstance(type, 
            //                                             BindingFlags.Public |
            //                                             BindingFlags.NonPublic |
            //                                             BindingFlags.Instance |
            //                                             BindingFlags.CreateInstance, 
            //                                             null,
            //                                             null, 
            //                                             culture); 
            //         }
            // 
            CodeMemberMethod cmmCI = new CodeMemberMethod();
            cmmCI.Name = "CreateInstance";
            cmmCI.Attributes = MemberAttributes.Family | MemberAttributes.Override;
            cmmCI.ReturnType = new CodeTypeReference(typeof(Object)); 

            CodeParameterDeclarationExpression param1 = new CodeParameterDeclarationExpression(typeof(Type), TYPE); 
            CodeParameterDeclarationExpression param4 = new CodeParameterDeclarationExpression(typeof(CultureInfo), CULTURE); 
            cmmCI.Parameters.Add(param1);
            cmmCI.Parameters.Add(param4); 

            CodeMethodReferenceExpression cmreCI = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Activator)), "CreateInstance");
            CodeMethodInvokeExpression cmieCI = new CodeMethodInvokeExpression();
            cmieCI.Method = cmreCI; 
            cmieCI.Parameters.Add(new CodeArgumentReferenceExpression(TYPE));
            CodeFieldReferenceExpression cfre1 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Public"); 
            CodeFieldReferenceExpression cfre2 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "NonPublic"); 
            CodeFieldReferenceExpression cfre3 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "Instance");
            CodeFieldReferenceExpression cfre4 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "CreateInstance"); 
            CodeBinaryOperatorExpression cboe1 = new CodeBinaryOperatorExpression(cfre1, CodeBinaryOperatorType.BitwiseOr, cfre2);
            CodeBinaryOperatorExpression cboe2 = new CodeBinaryOperatorExpression(cfre3, CodeBinaryOperatorType.BitwiseOr, cfre4);
            CodeBinaryOperatorExpression cboeCI = new CodeBinaryOperatorExpression(cboe1, CodeBinaryOperatorType.BitwiseOr, cboe2);
            cmieCI.Parameters.Add(cboeCI); 
            cmieCI.Parameters.Add(new CodePrimitiveExpression(null));
            cmieCI.Parameters.Add(new CodePrimitiveExpression(null)); 
            cmieCI.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE)); 

            cmmCI.Statements.Add(new CodeMethodReturnStatement(cmieCI)); 
            GenerateXmlComments(cmmCI, cmmCI.Name);
            ctdClass.Members.Add(cmmCI);

            //         protected override object GetPropertyValue(PropertyInfo propertyInfo, object target, CultureInfo culture) 
            //         {
            //             return propertyInfo.GetValue(target, BindingFlags.Default, null, null, culture); 
            //         } 
            //
            CodeMemberMethod cmmGPV = new CodeMemberMethod(); 
            cmmGPV.Name = "GetPropertyValue";
            cmmGPV.Attributes = MemberAttributes.Family | MemberAttributes.Override;
            cmmGPV.ReturnType = new CodeTypeReference(typeof(Object));
 
            param1 = new CodeParameterDeclarationExpression(typeof(PropertyInfo), PROPINFO);
            CodeParameterDeclarationExpression param2 = new CodeParameterDeclarationExpression(typeof(object), TARGET); 
            cmmGPV.Parameters.Add(param1); 
            cmmGPV.Parameters.Add(param2);
            cmmGPV.Parameters.Add(param4); 

            CodeMethodReferenceExpression cmreGPV = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(PROPINFO), "GetValue");
            CodeMethodInvokeExpression cmieGPV = new CodeMethodInvokeExpression();
            cmieGPV.Method = cmreGPV; 
            cmieGPV.Parameters.Add(new CodeArgumentReferenceExpression(TARGET));
            cmieGPV.Parameters.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), DEFAULT)); 
            cmieGPV.Parameters.Add(new CodePrimitiveExpression(null)); 
            cmieGPV.Parameters.Add(new CodePrimitiveExpression(null));
            cmieGPV.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE)); 

            cmmGPV.Statements.Add(new CodeMethodReturnStatement(cmieGPV));
            GenerateXmlComments(cmmGPV, cmmGPV.Name);
            ctdClass.Members.Add(cmmGPV); 

            //         protected override void SetPropertyValue(PropertyInfo propertyInfo, object target, object value, CultureInfo culture) 
            //         { 
            //             propertyInfo.SetValue(target, value, BindingFlags.Default, null, null, culture);
            //         } 
            //
            CodeMemberMethod cmmSPV = new CodeMemberMethod();
            cmmSPV.Name = "SetPropertyValue";
            cmmSPV.Attributes = MemberAttributes.Family | MemberAttributes.Override; 

            CodeParameterDeclarationExpression param3 = new CodeParameterDeclarationExpression(typeof(object), VALUE); 
            cmmSPV.Parameters.Add(param1); 
            cmmSPV.Parameters.Add(param2);
            cmmSPV.Parameters.Add(param3); 
            cmmSPV.Parameters.Add(param4);

            CodeMethodReferenceExpression cmreSPV = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(PROPINFO), "SetValue");
            CodeMethodInvokeExpression cmieSPV = new CodeMethodInvokeExpression(); 
            cmieSPV.Method = cmreSPV;
            cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(TARGET)); 
            cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(VALUE)); 
            cmieSPV.Parameters.Add(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), DEFAULT));
            cmieSPV.Parameters.Add(new CodePrimitiveExpression(null)); 
            cmieSPV.Parameters.Add(new CodePrimitiveExpression(null));
            cmieSPV.Parameters.Add(new CodeArgumentReferenceExpression(CULTURE));

            cmmSPV.Statements.Add(new CodeExpressionStatement(cmieSPV)); 
            GenerateXmlComments(cmmSPV, cmmSPV.Name);
            ctdClass.Members.Add(cmmSPV); 
 
            //         protected override Delegate CreateDelegate(Type delegateType, object target, string handler)
            //         { 
            //             return (Delegate)target.GetType().InvokeMember("_CreateDelegate",
            //                                                            BindingFlags.Instance |
            //                                                            BindingFlags.NonPublic |
            //                                                            BindingFlags.InvokeMethod, 
            //                                                            null,
            //                                                            target, 
            //                                                            new object[] { delegateType, handler }); 
            //         }
            // 
            CodeMemberMethod cmmCD = new CodeMemberMethod();
            cmmCD.Name = "CreateDelegate";
            cmmCD.Attributes = MemberAttributes.Family | MemberAttributes.Override;
            cmmCD.ReturnType = new CodeTypeReference(typeof(Delegate)); 

            param1 = new CodeParameterDeclarationExpression(typeof(Type), DELEGATETYPE); 
            param3 = new CodeParameterDeclarationExpression(typeof(string), HANDLERARG); 
            cmmCD.Parameters.Add(param1);
            cmmCD.Parameters.Add(param2); 
            cmmCD.Parameters.Add(param3);

            CodeArgumentReferenceExpression careTarget = new CodeArgumentReferenceExpression(TARGET);
            CodeMethodReferenceExpression cmreGetType = new CodeMethodReferenceExpression(careTarget, "GetType"); 
            CodeMethodInvokeExpression cmieGetType = new CodeMethodInvokeExpression();
            cmieGetType.Method = cmreGetType; 
 
            CodeMethodReferenceExpression cmreCD = new CodeMethodReferenceExpression(cmieGetType, "InvokeMember");
            CodeMethodInvokeExpression cmieCD = new CodeMethodInvokeExpression(); 
            cmieCD.Method = cmreCD;
            cmieCD.Parameters.Add(new CodePrimitiveExpression(CREATEDELEGATEHELPER));

            CodeFieldReferenceExpression cfre5 = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(BindingFlags)), "InvokeMethod"); 
            CodeBinaryOperatorExpression cboe = new CodeBinaryOperatorExpression(cfre2, CodeBinaryOperatorType.BitwiseOr, cfre3);
            CodeBinaryOperatorExpression cboeCD = new CodeBinaryOperatorExpression(cfre5, CodeBinaryOperatorType.BitwiseOr, cboe); 
            cmieCD.Parameters.Add(cboeCD); 

            cmieCD.Parameters.Add(new CodePrimitiveExpression(null)); 
            cmieCD.Parameters.Add(careTarget);

            CodeArrayCreateExpression caceCD = new CodeArrayCreateExpression(typeof(object));
            CodeArgumentReferenceExpression careDelType = new CodeArgumentReferenceExpression(DELEGATETYPE); 
            CodeArgumentReferenceExpression careHandler = new CodeArgumentReferenceExpression(HANDLERARG);
            caceCD.Initializers.Add(careDelType); 
            caceCD.Initializers.Add(careHandler); 
            cmieCD.Parameters.Add(caceCD);
            cmieCD.Parameters.Add(new CodePrimitiveExpression(null)); 

            CodeCastExpression cceCD = new CodeCastExpression(typeof(Delegate), cmieCD);
            cmmCD.Statements.Add(new CodeMethodReturnStatement(cceCD));
            GenerateXmlComments(cmmCD, cmmCD.Name); 
            ctdClass.Members.Add(cmmCD);
 
            //         protected override void AddEventHandler(EventInfo eventInfo, object target, Delegate handler); 
            //         {
            //             eventInfo.AddEventHandler(target, handler); 
            //         }
            //
            CodeMemberMethod cmmAEH = new CodeMemberMethod();
            cmmAEH.Name = "AddEventHandler"; 
            cmmAEH.Attributes = MemberAttributes.Family | MemberAttributes.Override;
 
            param1 = new CodeParameterDeclarationExpression(typeof(EventInfo), EVENTINFO); 
            param3 = new CodeParameterDeclarationExpression(typeof(Delegate), HANDLERARG);
            cmmAEH.Parameters.Add(param1); 
            cmmAEH.Parameters.Add(param2);
            cmmAEH.Parameters.Add(param3);

            CodeMethodReferenceExpression cmreAEH = new CodeMethodReferenceExpression(new CodeArgumentReferenceExpression(EVENTINFO), "AddEventHandler"); 
            CodeMethodInvokeExpression cmieAEH = new CodeMethodInvokeExpression();
            cmieAEH.Method = cmreAEH; 
            cmieAEH.Parameters.Add(new CodeArgumentReferenceExpression(TARGET)); 
            cmieAEH.Parameters.Add(new CodeArgumentReferenceExpression(HANDLERARG));
 
            cmmAEH.Statements.Add(new CodeExpressionStatement(cmieAEH));
            GenerateXmlComments(cmmAEH, cmmAEH.Name);
            ctdClass.Members.Add(cmmAEH);
 
            //     }
            // 
            cns.Types.Add(ctdClass); 

            // } 
            //
            CodeCompileUnit ccu = new CodeCompileUnit();
            ccu.Namespaces.Add(cns);
 
            // For VB only we need to let the parser know about the RootNamespace value
            // in order to look for the XamlGeneratedNamespace.GeneratedInternalTypeHelper 
            // type whose full type name would have been implicitly by the VB comopiler to 
            // RootNS.XamlGeneratedNamespace.GeneratedInternalTypeHelper
 
            if (IsLanguageVB && !string.IsNullOrEmpty(DefaultNamespace))
            {
                // [assembly: RootNamespaceAttribute("RootNS")]
                CodeAttributeDeclaration cad = new CodeAttributeDeclaration( 
                             "System.Windows.Markup.RootNamespaceAttribute",
                             new CodeAttributeArgument(new CodePrimitiveExpression(DefaultNamespace))); 
 
                ccu.AssemblyCustomAttributes.Add(cad);
            } 

            string generatedInternalTypeHelperFileName = TargetPath + SharedStrings.GeneratedInternalTypeHelperFileName
                + (TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension)
                + LanguageSourceExtension; 

            MemoryStream codeMemStream = new MemoryStream(); 
 
            // using Disposes the StreamWriter when it ends.  Disposing the StreamWriter
            // also closes the underlying MemoryStream.  Furthermore, don't add BOM here since 
            // TaskFileService.WriteFile adds it.
            using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false)))
            {
                CodeGeneratorOptions o = new CodeGeneratorOptions(); 
                CodeDomProvider codeProvider = EnsureCodeProvider();
                codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o); 
 
                codeStreamWriter.Flush();
                TaskFileService.WriteFile(codeMemStream.ToArray(), generatedInternalTypeHelperFileName); 
            }
        }

        internal string StartElement(ref string className, string subClassFullName, ref string modifier, Type elementType, string baseClassFullName) 
        {
            string classFullName = null; 
            CodeContext cc = null; 

            if (_ccRoot == null) 
            {
                if (className.Length > 0)
                {
                    IsCodeNeeded = true; 
                }
                else if (subClassFullName.Length > 0) 
                { 
                    ThrowCompilerException(SRID.MissingClassWithSubClass, DefinitionNSPrefix);
                } 
                else if (modifier.Length > 0)
                {
                    ThrowCompilerException(SRID.MissingClassWithModifier, DefinitionNSPrefix);
                } 
                else if (_typeArgsList != null)
                { 
                    string rootClassName = elementType != null ? elementType.Name : baseClassFullName.Substring(baseClassFullName.LastIndexOf(DOT, StringComparison.Ordinal)+1); 
                    ThrowCompilerException(SRID.MissingClassDefinitionForTypeArgs, rootClassName, DefinitionNSPrefix);
                } 

                // Don't allow subclassing further from markup-subclasses with content
                if (elementType != null && KnownTypes.Types[(int)KnownElements.IComponentConnector].IsAssignableFrom(elementType))
                { 
                    ThrowCompilerException(SRID.SubSubClassingNotAllowed, elementType.FullName);
                } 
 
                cc = GenerateSubClass(ref className, ref modifier, elementType, baseClassFullName);
                Debug.Assert(_codeContexts.Count == 0, "mismatched codecontext"); 
                _ccRoot = cc as CodeContextRoot;
                Debug.Assert(_ccRoot != null);

                if (IsCodeNeeded) 
                {
                    if (subClassFullName.Length > 0) 
                    { 
                        classFullName = subClassFullName;
                        _ccRoot.SubClass = classFullName; 
                    }
                    else
                    {
                        classFullName = GetFullClassName(_ccRoot.CodeNS.Name, _ccRoot.CodeClass.Name); 
                    }
 
                    if (IsLanguageVB) 
                    {
                        // This classFullName is going to be used to write Root Start Element. 
                        // If it is for VB, and DefaultClrName is set, we need to put DefaultClrName
                        // as prefix to any existing full class name.
                        //
                        // if this x:Class is set to "MyNS.MyPage, and RootNamespace (DefaultNamespace) 
                        // is set to MyRoot, the finally generated class by VBC would be MyRoot.MyNS.MyPage.
                        // so in the Baml record, it should keep MyRoot.MyNS.MyPage. 
                        // 

                        classFullName = GetFullClassName(DefaultNamespace, classFullName); 
                    }
                }

                if (IsCompilingEntryPointClass) 
                {
                    cc.IsAllowedNameScope = false; 
                } 
            }
            else 
            {
                cc = new CodeContext(elementType, null, baseClassFullName);
                CodeContext ccParent = (CodeContext)_codeContexts.Peek();
                cc.IsAllowedNameScope = ccParent.IsAllowedNameScope; 
            }
 
            _codeContexts.Push(cc); 

            return classFullName; 
        }

        internal void EndElement(bool pass2)
        { 
            CodeContext cc = (CodeContext)_codeContexts.Pop();
            Debug.Assert(cc != null); 
 
            if (_codeContexts.Count == 0)
            { 
                Debug.Assert(_ccRoot == (cc as CodeContextRoot));
                Debug.Assert(_ccRoot.CodeClass != null);

                if (!pass2) 
                {
                    // For entry point class, a sub-class is always needed 
                    // even if if wasn't otherwise needed by other markup 
                    // like x:Code or events etc. upto this point.
                    if (IsCompilingEntryPointClass) 
                    {
                        IsCodeNeeded = true;
                    }
 
                    if (IsCodeNeeded)
                    { 
                        if (IsBamlNeeded) 
                        {
                            GenerateInitializeComponent(IsCompilingEntryPointClass); 
                            if (!IsCompilingEntryPointClass)
                            {
                                GenerateCreateDelegateHelper();
                            } 
                        }
                        else 
                        { 
                            Debug.Assert(_ccRoot.HookupFn == null);
                        } 

                        EndHookups();
                        EndStyleEventConnection();
                    } 

                    GenerateSource(); 
                } 
            }
        } 

        internal void AddUsing(string clrNS)
        {
            if (String.IsNullOrEmpty(clrNS)) 
            {
                return; 
            } 

            if (_usingNS == null) 
            {
                _usingNS = new ArrayList();
            }
 
            _usingNS.Add(clrNS);
        } 
 
#endregion CorePageGen
 
#region App Entry Point

        // This code block is shared by regular Application and HostInBrowser Application
        private CodeVariableReferenceExpression GenerateAppInstance(CodeMemberMethod cmmMain) 
        {
            string appClassName = _ccRoot.SubClass.Length > 0 ? _ccRoot.SubClass 
                                               : GetFullClassName(_ccRoot.CodeNS.Name, _ccRoot.CodeClass.Name); 

            //  MyNS.MyApplication app = new MyNS.MyApplication(); 
            //
            CodeObjectCreateExpression coce;
            CodeVariableReferenceExpression cvre = new CodeVariableReferenceExpression(APPVAR);
            CodeExpression[] ctorParams = {}; 

            coce = new CodeObjectCreateExpression(appClassName, ctorParams); 
 
            CodeVariableDeclarationStatement cvds = new CodeVariableDeclarationStatement(appClassName, APPVAR, coce);
 
            cmmMain.Statements.Add(cvds);

            return cvre;
        } 

        internal void AddApplicationProperty(MemberInfo memberInfo, string attributeValue, int lineNumber) 
        { 
            Debug.Assert(_ccRoot == (_codeContexts.Peek() as CodeContextRoot));
            Debug.Assert(_ccRoot.ElementType == null || 
                         (memberInfo.DeclaringType.IsAssignableFrom(_ccRoot.ElementType) && (memberInfo is PropertyInfo)));

            TypeConvertContext ctx = new TypeConvertContext(_parserContext, attributeValue);
            CodeExpression ceValue = GetPropertyValueExpression(ctx, typeof(Uri), null, attributeValue); 
            CodeThisReferenceExpression ctreTag = new CodeThisReferenceExpression();
            CodePropertyReferenceExpression cprePropSet = new CodePropertyReferenceExpression(ctreTag, memberInfo.Name); 
 
            CodeStatement csPropSet = new CodeAssignStatement(cprePropSet, ceValue);
 
            AddLinePragma(csPropSet, lineNumber);

            _ccRoot.EnsureInitializeComponentFn.Statements.Add(csPropSet);
        } 

        internal void AddApplicationEvent(MarkupEventInfo mei) 
        { 
            // validate the event handler name per C# grammar for identifiers
            ValidateEventHandlerName(mei.eventName, mei.eventHandler); 

            // this.FooEvent += new FooEventHandlerDelegate(this.OnFoo);
            CodeThisReferenceExpression ctre = new CodeThisReferenceExpression();
            CodeStatement csEvent = AddCLREvent(_ccRoot, ctre, mei); 

            Debug.Assert(_ccRoot == (_codeContexts.Peek() as CodeContextRoot)); 
            _ccRoot.EnsureInitializeComponentFn.Statements.Add(csEvent); 
        }
 
        private CodeMemberMethod GenerateEntryPointMethod()
        {
            CodeMemberMethod cmmMain = null;
            CodeDomProvider codeProvider = EnsureCodeProvider(); 

            if (codeProvider.Supports(GeneratorSupport.EntryPointMethod)) 
            { 
                //
                // [STAThread] 
                // public static void Main () {
                //

                cmmMain = new CodeEntryPointMethod(); 
                cmmMain.Attributes = MemberAttributes.Public | MemberAttributes.Static;
                cmmMain.CustomAttributes.Add(new CodeAttributeDeclaration(typeof(STAThreadAttribute).FullName)); 
                AddDebuggerNonUserCodeAttribute(cmmMain); 
                GenerateXmlComments(cmmMain, "Application Entry Point.");
                cmmMain.ReturnType = new CodeTypeReference(typeof(void)); 
            }

            return cmmMain;
        } 

        private void GenerateAppEntryPoint() 
        { 
            if (ApplicationFile.Length > 0)
            { 

                // [STAThread]
                // public static void Main () {
                // 
                CodeMemberMethod cmmMain = GenerateEntryPointMethod();
 
                if (cmmMain != null) 
                {
                    CodeVariableReferenceExpression cvreSplashScreen = null; 
                    if (!string.IsNullOrEmpty(_splashImage) && !HostInBrowser)
                    {
                        cvreSplashScreen = GenerateSplashScreenInstance(cmmMain);
                    } 

                    //   MyApplication app = new MyApplication(); 
                    // 
                    CodeVariableReferenceExpression cvreApp = GenerateAppInstance(cmmMain);
 
                    if (_ccRoot.InitializeComponentFn != null)
                    {
                        //   app.InitializeComponent();
                        // 
                        CodeMethodInvokeExpression cmieIT = new CodeMethodInvokeExpression();
                        cmieIT.Method = new CodeMethodReferenceExpression(cvreApp, INITIALIZE_COMPONENT); 
                        cmmMain.Statements.Add(new CodeExpressionStatement(cmieIT)); 
                    }
 
                    if (!HostInBrowser)
                    {
                        //   app.Run();
                        // 
                        CodeMethodReferenceExpression cmreRun = new CodeMethodReferenceExpression(cvreApp, "Run");
                        CodeMethodInvokeExpression cmieRun = new CodeMethodInvokeExpression(); 
                        cmieRun.Method = cmreRun; 

                        CodeStatement csRun = new CodeExpressionStatement(cmieRun); 
                        cmmMain.Statements.Add(csRun);
                    }

                    _ccRoot.CodeClass.Members.Add(cmmMain); 
                }
            } 
        } 

        private void GenerateLooseContentAttributes() 
        {
            CodeDomProvider codeProvider = EnsureCodeProvider();

            if (codeProvider.Supports(GeneratorSupport.AssemblyAttributes)) 
            {
                CodeCompileUnit ccu = new CodeCompileUnit(); 
 
                foreach (string file in ContentList)
                { 
                    // [assembly: AssemblyAssociatedContentFileAttribute("file")]

                    string normalized = ResourceIDHelper.GetResourceIDFromRelativePath(file);
                    CodeAttributeDeclaration cad = new CodeAttributeDeclaration( 
                                 "System.Windows.Resources.AssemblyAssociatedContentFileAttribute",
                                 new CodeAttributeArgument(new CodePrimitiveExpression(normalized))); 
 
                    ccu.AssemblyCustomAttributes.Add(cad);
                } 

                string contentCodeFileName = TargetPath + AssemblyName + SharedStrings.ContentFile
                    + (TaskFileService.IsRealBuild? SharedStrings.GeneratedExtension : SharedStrings.IntellisenseGeneratedExtension)
                    + LanguageSourceExtension; 

 
                MemoryStream codeMemStream = new MemoryStream(); 

                // using Disposes the StreamWriter when it ends.  Disposing the StreamWriter 
                // also closes the underlying MemoryStream.  Furthermore, don't add BOM here since
                // TaskFileService.WriteFile adds it.
                using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false)))
                { 
                    CodeGeneratorOptions o = new CodeGeneratorOptions();
                    codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o); 
 
                    codeStreamWriter.Flush();
                    TaskFileService.WriteFile(codeMemStream.ToArray(), contentCodeFileName); 
                }
            }
        }
 
#endregion App Entry Point
 
#region Splash Screen Code Generation 

        private CodeVariableReferenceExpression GenerateSplashScreenInstance(CodeMemberMethod cmmMain) 
        {
            // SplashScreen splashScreen = new SplashScreen(Assembly.GetExecutingAssembly(), "splash.png");
            CodeObjectCreateExpression coceApplicationSplashScreen = new CodeObjectCreateExpression(SPLASHCLASSNAME, new CodePrimitiveExpression(GetSplashResourceId()));
            // ApplicationSplashScreen splashScreen = ... 
            CodeVariableDeclarationStatement cvdsAppSplash = new CodeVariableDeclarationStatement(SPLASHCLASSNAME, SPLASHVAR, coceApplicationSplashScreen);
            cmmMain.Statements.Add(cvdsAppSplash); 
 
            // splashScreen.Show(true);
            CodeVariableReferenceExpression cvreAppSplash = new CodeVariableReferenceExpression(SPLASHVAR); 
            CodeMethodInvokeExpression cmieShowSplashScreen = new CodeMethodInvokeExpression(cvreAppSplash, "Show", new CodePrimitiveExpression(true));
            cmmMain.Statements.Add(cmieShowSplashScreen);

            return cvreAppSplash; 
        }
 
        private string GetSplashResourceId() 
        {
            // Perform the same resouce string mangle that is done in ResourceGenerator 
            string resourceId;
            string fullFilePath = Path.GetFullPath(_splashImage);
            string relPath = TaskHelper.GetRootRelativePath(TargetPath, fullFilePath);
 
            //
            // If the resFile is relative to the StagingDir (OutputPath here) 
            // take the relative path as resource id. 
            // If the resFile is not relative to StagingDir, but relative
            // to the project directory, take this relative path as resource id. 
            // Otherwise, just take the file name as resource id.
            //

            if (string.IsNullOrEmpty(relPath)) 
            {
                relPath = TaskHelper.GetRootRelativePath(Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar, fullFilePath); 
            } 

            if (string.IsNullOrEmpty(relPath) == false) 
            {
                resourceId = relPath;
            }
            else 
            {
                resourceId = Path.GetFileName(fullFilePath); 
            } 

            // Modify resource ID to correspond to canonicalized Uri format 
            // i.e. - all lower case, use "/" as separator
            // ' ' is converted to escaped version %20
            //
 
            resourceId = ResourceIDHelper.GetResourceIDFromRelativePath(resourceId);
 
            return resourceId; 
        }
 
#endregion

#region CodeContext
 
        private class CodeContext
        { 
            internal CodeContext(Type elementType, string [] typeArgsList, string localElementFullName) 
            {
                _elementType = elementType; 
                _typeArgsList = typeArgsList;
                _localElementFullName = localElementFullName;
            }
 
            internal Type ElementType
            { 
                get { return _elementType; } 
            }
 
            internal string ElementName
            {
                get { return _elementType != null ? _elementType.Name : _localElementFullName.Substring(_localElementFullName.LastIndexOf(DOT, StringComparison.Ordinal) + 1); }
            } 

            internal string [] GenericTypeArgs 
            { 
                get { return _typeArgsList; }
            } 

            internal string LocalElementFullName
            {
                get { return _localElementFullName; } 
            }
 
            internal bool IsAllowedNameScope 
            {
                get { return _isAllowedNameScope; } 
                set { _isAllowedNameScope = value; }
            }

            internal CodeTypeReference ElementTypeReference 
            {
                get 
                { 
                    if (_ctrElemTypeRef == null)
                    { 
                        _ctrElemTypeRef = MarkupCompiler.GenerateConstructedTypeReference(_elementType, _typeArgsList, _localElementFullName);
                    }

                    return _ctrElemTypeRef; 
                }
 
                set { _ctrElemTypeRef = value; } 
            }
 
            private bool _isAllowedNameScope = true;
            private Type _elementType = null;
            private string [] _typeArgsList = null;
            private string _localElementFullName = string.Empty; 
            protected CodeTypeReference _ctrElemTypeRef = null;
        } 
 
        private class CodeContextRoot : CodeContext
        { 
            internal CodeContextRoot(CodeTypeDeclaration codeClass,
                                     CodeNamespace codeNS,
                                     Type elementType,
                                     string [] typeArgsList, 
                                     string localElementFullName) : base (elementType, typeArgsList, localElementFullName)
            { 
                _codeNS = codeNS; 
                _codeClass = codeClass;
                _ctrElemTypeRef = codeClass.BaseTypes[0]; 
            }

            internal CodeMemberMethod HookupFn
            { 
                get { return _hookupFn; }
                set { _hookupFn = value; } 
            } 

            internal CodeMemberMethod StyleConnectorFn 
            {
                get { return _styleConnectorFn; }
                set { _styleConnectorFn = value; }
            } 

            internal CodeMemberMethod InitializeComponentFn 
            { 
                get { return _initializeComponentFn; }
            } 

            internal CodeMemberMethod EnsureInitializeComponentFn
            {
                get 
                {
                    if (_initializeComponentFn == null) 
                    { 
                        _initializeComponentFn = new CodeMemberMethod();
                        _initializeComponentFn.Name = INITIALIZE_COMPONENT; 
                        _initializeComponentFn.Attributes = MemberAttributes.Public | MemberAttributes.Final;
                        AddDebuggerNonUserCodeAttribute(_initializeComponentFn);
                        MarkupCompiler.GenerateXmlComments(_initializeComponentFn, INITIALIZE_COMPONENT);
                        _codeClass.Members.Add(_initializeComponentFn); 
                    }
 
                    return _initializeComponentFn; 
                }
            } 

            internal CodeTypeDeclaration CodeClass
            {
                get { return _codeClass; } 
            }
 
            internal CodeNamespace CodeNS 
            {
                get { return _codeNS; } 
            }

            // This is used as the class to instantiate when a language does not support partial
            // classes. A code-behind file needs to derive this class from the generated sub-class 
            // that is normally specified by the x:Class attribute.
            internal string SubClass 
            { 
                get { return _subClass; }
                set { _subClass = value; } 
            }

            private CodeTypeDeclaration _codeClass;
            private CodeNamespace _codeNS; 
            private CodeMemberMethod _initializeComponentFn = null;
            private CodeMemberMethod _hookupFn = null; 
            private CodeMemberMethod _styleConnectorFn = null; 
            private string _subClass = string.Empty;
        } 

#endregion CodeContext

#endregion Implementation 

#region Private Data 
 
        private string                  _targetPath = string.Empty; // Current Dir is default
        private string[]                _contentList = null; 
        private ArrayList               _referenceAssemblyList = null;
        private string                  _localXamlApplication = null;
        private string[]                _localXamlPages = null;
        private string []               _typeArgsList = null; 
        private ArrayList               _pendingLocalFiles = null;
        private bool                    _hostInBrowser = false; 
        private bool                    _xamlDebuggingInformation = false; 
        private string                  _splashImage = null;
 
        private bool                    _isLangCSharp = false;
        private bool                    _isLangVB = false;
        private string                  _language = string.Empty;
        private string                  _languageSourceExtension = string.Empty; 
        private static string           _definitionNSPrefix = DEFINITION_PREFIX;
        private CompilerInfo            _ci = null; 
        private CodeDomProvider         _codeProvider = null; 
        private XamlTypeMapper          _typeMapper = null;
 
        private bool                    _isCompilingEntryPointClass = false;
        private bool                    _isBamlNeeded = false;
        private bool                    _isCodeNeeded = false;
        private bool                    _hasLocalEvent = false; 
        private bool                    _hasGeneratedInternalTypeHelper = false;
        private string                  _assemblyName = string.Empty; 
        private string                  _assemblyVersion = string.Empty; 
        private string                  _assemblyPublicKeyToken = string.Empty;
        private string                  _applicationFile = string.Empty; 
        private string                  _defaultNamespace = string.Empty;
        private ParserHooks             _parserHooks;

        private SourceFileInfo          _sourceFileInfo = null; 
        private string                  _compilationUnitSourcePath = string.Empty;
        private ArrayList               _usingNS = null; 
        private Assembly                _localAssembly = null; 
        private ReferenceAssembly       _localAssemblyFile = null;
        private ParserContext           _parserContext = null; 
        private CodeContextRoot         _ccRoot = null;
        private Stack                   _codeContexts = null;
        private ITaskFileService        _taskFileService = null;
 
        // Per language sccess Modfiers
        private string                  _private = string.Empty; 
        private string                  _public = string.Empty; 
        private string                  _protected = string.Empty;
        private string                  _internal = string.Empty; 
        private string                  _protectedInternal = string.Empty;
        private string                  _privateClass = string.Empty;
        private string                  _publicClass = string.Empty;
 
        // Prefixes & Tags
        private const string            INDENT12 = "            "; 
        private const string            ANONYMOUS_ENTRYCLASS_PREFIX = "Generated"; 
        private const string            DEFINITION_PREFIX = "x";
        private const char              COMMA = ','; 
        private const string            GENERIC_DELIMITER = "`";
        internal const char             DOTCHAR = '.';
        internal const string           DOT = ".";
        internal const string           CODETAG = "Code"; 

        // Language support 
        private const string            XAML = ".xaml"; 
        private const string            BAML = ".baml";
        private const string            VB = "vb"; 
        private const string            CSHARP = "c#";
        private const string            JSHARP = "vj#";
        private const string            JSCRIPT = "js";
 
        // Generated identifiers
        private const string            CREATEDELEGATEHELPER = "_CreateDelegate"; 
        private const string            CONTENT_LOADED = "_contentLoaded"; 
        private const string            CONNECT = "Connect";
        private const string            CONNECTIONID = "connectionId"; 
        private const string            TARGET = "target";
        private const string            EVENTSETTER = "eventSetter";
        private const string            EVENT = "Event";
        private const string            ADDHANDLER = "AddHandler"; 
        private const string            HELPER = "Helper";
        private const string            HANDLERARG = "handler"; 
        private const string            TYPE = "type"; 
        private const string            CULTURE = "culture";
        private const string            DEFAULT = "Default"; 
        private const string            VALUE = "value";
        private const string            DELEGATETYPE = "delegateType";
        private const string            PROPINFO = "propertyInfo";
        private const string            EVENTINFO = "eventInfo"; 
        private const string            APPVAR = "app";
        private const string            SPLASHVAR = "splashScreen"; 
        private const string            SPLASHCLASSNAME = "SplashScreen"; 
        private const string            ARGS = "args";
        private const string            INITIALIZE_COMPONENT = "InitializeComponent"; 
        private const string            SWITCH_STATEMENT = INDENT12 + "switch (" + CONNECTIONID + ")\r\n" + INDENT12 + "{";
        private const string            BREAK_STATEMENT = INDENT12 + "break;";
        private const string            CASE_STATEMENT = INDENT12 + "case ";
        private const string            ENDCURLY = "}"; 
        private const string            COLON = ":";
        private const string            RESOURCE_LOCATER = "resourceLocater"; 
        private const string            LOADCOMPONENT = "LoadComponent"; 
        private const string            SETTERS = "Setters";
        private const string            SummaryStartTag = @""; 
        private const string            SummaryEndTag = @"";
        internal const string           ADD = "Add";
        internal const string           HANDLER = "Handler";
 
        // Delimiters & Uri processing
        private const string            VER = "V"; 
        private const string            COMPONENT = "component"; 
        private const char              COMPONENT_DELIMITER = ';';
        private const string            ESCAPED_BACKSLASH = "\\"; 
        private const char              ESCAPED_BACKSLASH_CHAR = '\\';
        private const string            FORWARDSLASH = "/";
        private const string            URISCHEME_PACK = "pack";
        private const string            PARENTFOLDER = @"..\"; 

        // For generating pragma checksum data 
        private static HashAlgorithm s_md5HashAlgorithm; 
        private static Guid s_hashMD5Guid;
 
#endregion Private Data
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

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