MarkupCompiler.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / BuildTasks / MS / Internal / MarkupCompiler / MarkupCompiler.cs / 1458001 / 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 
using Microsoft.Build.Utilities; 
using System.Runtime.CompilerServices;
 
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; } 
        }
 
        /// 
        /// The CompilerWrapper's TaskLoggingHelper for reporting compiler warnings.
        /// 
        internal TaskLoggingHelper TaskLogger 
        {
            set { _taskLogger = 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.WriteGeneratedCodeFileFile 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.WriteGeneratedCodeFile(codeMemStream.ToArray(), 
                        TargetPath + SourceFileInfo.RelativeSourceFilePath, 
                        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"); 
                AddSuppressMessageAttribute(_ccRoot.StyleConnectorFn, "Microsoft.Performance", "CA1800:DoNotCastUnnecessarily");
                AddSuppressMessageAttribute(_ccRoot.StyleConnectorFn, "Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity"); 

                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");
                AddSuppressMessageAttribute(_ccRoot.HookupFn, "Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity");
                AddSuppressMessageAttribute(_ccRoot.HookupFn, "Microsoft.Performance", "CA1800:DoNotCastUnnecessarily"); 

                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)
            {
                var iComponentConnector = new CodeTypeReference(KnownTypes.Types[(int)KnownElements.IComponentConnector]); 
                _ccRoot.CodeClass.BaseTypes.Add(iComponentConnector);
 
                // Visual Basic requires InitializeComponent to explicitly implement IComponentConnector.InitializeComponent 
                // if the class implements the interface. GenerateInitializeComponent handles the cases where the class is not
                // the entry point for any programming language. 
                if (IsLanguageVB && IsCompilingEntryPointClass)
                {
                    _ccRoot.InitializeComponentFn.ImplementationTypes.Add(iComponentConnector);
                } 

                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.InvariantEnglishUS, 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.InvariantEnglishUS, 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, int linePosition) 
        {
            CodeMemberField cmField = NameField(name, lineNumber, linePosition); 
            if (cmField != null)
            {
                AddLinePragma(cmField, lineNumber);
            } 
            return cmField;
        } 
 
        internal CodeMemberField NameField(string name, int lineNumber, int linePosition)
        { 
            // Warn for named ResourceDictionary items.
            if (_codeContexts.Count >= 2)
            {
                Type resourceDictionary = KnownTypes.Types[(int)KnownElements.ResourceDictionary]; 
                Type iNameScope = KnownTypes.Types[(int)KnownElements.INameScope];
                object[] contexts = _codeContexts.ToArray(); 
                for (int i = 1; i < contexts.Length; ++i) 
                {
                    Type t = ((CodeContext)contexts[i]).ElementType; 
                    if (iNameScope.IsAssignableFrom(t))
                    {
                        break;
                    } 
                    if (resourceDictionary.IsAssignableFrom(t))
                    { 
                        _taskLogger.LogWarningFromResources( 
                            null,
                            null, 
                            null,
                            SourceFileInfo.OriginalFilePath,
                            lineNumber,
                            linePosition, 
                            0,
                            0, 
                            SRID.NamedResDictItemWarning, 
                            ((CodeContext)_codeContexts.Peek()).ElementType.FullName,
                            name 
                        );
                        break;
                    }
                } 
            }
            // 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; 
            field.CustomAttributes.Add(
                new CodeAttributeDeclaration( 
                         new CodeTypeReference("System.Diagnostics.CodeAnalysis.SuppressMessageAttribute"),
                         new CodeAttributeArgument(new CodePrimitiveExpression("Microsoft.Performance")),
                         new CodeAttributeArgument(new CodePrimitiveExpression("CA1823:AvoidUnusedPrivateFields"))));
 

            // 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 static void AddGeneratedCodeAttribute(CodeTypeMember ctmTarget, string tool, string version) 
        {
            CodeAttributeDeclaration cad = new CodeAttributeDeclaration( 
                         new CodeTypeReference(typeof(GeneratedCodeAttribute)), 
                         new CodeAttributeArgument(new CodePrimitiveExpression(tool)),
                         new CodeAttributeArgument(new CodePrimitiveExpression(version))); 

            ctmTarget.CustomAttributes.Add(cad);
        }
 
        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")); 
            }
 
            AssemblyName assemblyName = new AssemblyName(Assembly.GetExecutingAssembly().FullName);
            AddGeneratedCodeAttribute(ctdClass, assemblyName.Name, assemblyName.Version.ToString());

            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);
            }

            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.WriteGeneratedCodeFile 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.WriteGeneratedCodeFile(codeMemStream.ToArray(), 
                    TargetPath + SharedStrings.GeneratedInternalTypeHelperFileName,
                    SharedStrings.GeneratedExtension, SharedStrings.IntellisenseGeneratedExtension, 
                    LanguageSourceExtension);
            }
        }
 
        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); 
                }

                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.WriteGeneratedCodeFile adds it. 
                using (StreamWriter codeStreamWriter = new StreamWriter(codeMemStream, new UTF8Encoding(false)))
                { 
                    CodeGeneratorOptions o = new CodeGeneratorOptions();
                    codeProvider.GenerateCodeFromCompileUnit(ccu, codeStreamWriter, o);

                    codeStreamWriter.Flush(); 
                    TaskFileService.WriteGeneratedCodeFile(codeMemStream.ToArray(),
                        TargetPath + AssemblyName + SharedStrings.ContentFile, 
                        SharedStrings.GeneratedExtension, SharedStrings.IntellisenseGeneratedExtension, 
                        LanguageSourceExtension);
                } 
            }
        }

#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;
        private TaskLoggingHelper       _taskLogger = 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