Compiler.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 / ndp / fx / src / Xml / System / Xml / Serialization / Compiler.cs / 1305376 / Compiler.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
 
namespace System.Xml.Serialization { 
    using System.Reflection;
    using System.Reflection.Emit; 
    using System.Collections;
    using System.IO;
    using System;
    using System.Text; 
    using System.ComponentModel;
    using System.CodeDom.Compiler; 
    using System.Security; 
    using System.Security.Permissions;
    using System.Diagnostics; 
    using System.Security.Principal;
    using System.Security.Policy;
    using System.Threading;
    using System.Xml.Serialization.Configuration; 
    using System.Globalization;
    using System.Runtime.Versioning; 
    using System.Runtime.CompilerServices; 

    internal class Compiler { 
        bool debugEnabled = DiagnosticsSwitches.KeepTempFiles.Enabled;
        Hashtable imports = new Hashtable();
        StringWriter writer = new StringWriter(CultureInfo.InvariantCulture);
 
        [ResourceExposure(ResourceScope.Machine)]
        protected string[] Imports { 
            get { 
                string[] array = new string[imports.Values.Count];
                imports.Values.CopyTo(array, 0); 
                return array;
            }
        }
 
        // SxS: This method does not take any resource name and does not expose any resources to the caller.
        // It's OK to suppress the SxS warning. 
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)] 
        [ResourceExposure(ResourceScope.None)]
        internal void AddImport(Type type, Hashtable types) { 
            if (type == null)
                return;
            if (TypeScope.IsKnownType(type))
                return; 
            if (types[type] != null)
                return; 
            types[type] = type; 
            Type baseType = type.BaseType;
            if (baseType != null) 
                AddImport(baseType, types);

            Type declaringType = type.DeclaringType;
            if (declaringType != null) 
                AddImport(declaringType, types);
 
            foreach (Type intf in type.GetInterfaces()) 
                AddImport(intf, types);
 
            ConstructorInfo[] ctors = type.GetConstructors();
            for (int i = 0; i < ctors.Length; i++) {
                ParameterInfo[] parms = ctors[i].GetParameters();
                for (int j = 0; j < parms.Length; j++) { 
                    AddImport(parms[j].ParameterType, types);
                } 
            } 

            if (type.IsGenericType) { 
                Type[] arguments = type.GetGenericArguments();
                for (int i = 0; i < arguments.Length; i++) {
                    AddImport(arguments[i], types);
                } 
            }
 
            TempAssembly.FileIOPermission.Assert(); 
            Module module = type.Module;
            Assembly assembly = module.Assembly; 
            if (DynamicAssemblies.IsTypeDynamic(type)) {
                DynamicAssemblies.Add(assembly);
                return;
            } 

            object[] typeForwardedFromAttribute = type.GetCustomAttributes(typeof(TypeForwardedFromAttribute), false); 
            if (typeForwardedFromAttribute.Length > 0) 
            {
                TypeForwardedFromAttribute originalAssemblyInfo = typeForwardedFromAttribute[0] as TypeForwardedFromAttribute; 
                Assembly originalAssembly = Assembly.Load(originalAssemblyInfo.AssemblyFullName);
                imports[originalAssembly] = originalAssembly.Location;
            }
 
            imports[assembly] = assembly.Location;
        } 
 
        // SxS: This method does not take any resource name and does not expose any resources to the caller.
        // It's OK to suppress the SxS warning. 
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
        [ResourceExposure(ResourceScope.None)]
        internal void AddImport(Assembly assembly) {
            TempAssembly.FileIOPermission.Assert(); 
            imports[assembly] = assembly.Location;
        } 
 
        internal TextWriter Source {
            get { return writer; } 
        }

        internal void Close() { }
 
        [ResourceConsumption(ResourceScope.Machine)]
        [ResourceExposure(ResourceScope.Machine)] 
        internal static string GetTempAssemblyPath(string baseDir, Assembly assembly, string defaultNamespace) { 
            if (assembly.IsDynamic) {
                throw new InvalidOperationException(Res.GetString(Res.XmlPregenAssemblyDynamic)); 
            }

            PermissionSet perms = new PermissionSet(PermissionState.None);
            perms.AddPermission(new FileIOPermission(PermissionState.Unrestricted)); 
            perms.AddPermission(new EnvironmentPermission(PermissionState.Unrestricted));
            perms.Assert(); 
 
            try {
                if (baseDir != null && baseDir.Length > 0) { 
                    // check that the dirsctory exists
                    if (!Directory.Exists(baseDir)) {
                        throw new UnauthorizedAccessException(Res.GetString(Res.XmlPregenMissingDirectory, baseDir));
                    } 
                }
                else { 
                    baseDir = Path.GetTempPath(); 
                    // check that the dirsctory exists
                    if (!Directory.Exists(baseDir)) { 
                        throw new UnauthorizedAccessException(Res.GetString(Res.XmlPregenMissingTempDirectory));
                    }
                }
                if (baseDir.EndsWith("\\", StringComparison.Ordinal)) 
                    baseDir += GetTempAssemblyName(assembly.GetName(), defaultNamespace);
                else 
                    baseDir += "\\" + GetTempAssemblyName(assembly.GetName(), defaultNamespace); 
            }
            finally { 
                CodeAccessPermission.RevertAssert();
            }
            return baseDir + ".dll";
        } 

        internal static string GetTempAssemblyName(AssemblyName parent, string ns) { 
            return parent.Name + ".XmlSerializers" + (ns == null || ns.Length == 0 ? "" : "." +  ns.GetHashCode()); 
        }
 
        // SxS: This method does not take any resource name and does not expose any resources to the caller.
        // It's OK to suppress the SxS warning.
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]
        [ResourceExposure(ResourceScope.None)] 
        internal Assembly Compile(Assembly parent, string ns, XmlSerializerCompilerParameters xmlParameters, Evidence evidence) {
            CodeDomProvider codeProvider = new Microsoft.CSharp.CSharpCodeProvider(); 
            CompilerParameters parameters = xmlParameters.CodeDomParameters; 
            parameters.ReferencedAssemblies.AddRange(Imports);
 
            if (debugEnabled) {
                parameters.GenerateInMemory = false;
                parameters.IncludeDebugInformation = true;
                parameters.TempFiles.KeepFiles = true; 
            }
            PermissionSet perms = new PermissionSet(PermissionState.None); 
            if (xmlParameters.IsNeedTempDirAccess) { 
                perms.AddPermission(TempAssembly.FileIOPermission);
            } 
            perms.AddPermission(new EnvironmentPermission(PermissionState.Unrestricted));
            perms.AddPermission(new SecurityPermission(SecurityPermissionFlag.UnmanagedCode));
            perms.AddPermission(new SecurityPermission(SecurityPermissionFlag.ControlEvidence));
            perms.Assert(); 

            if (parent != null && (parameters.OutputAssembly == null || parameters.OutputAssembly.Length ==0)) { 
                string assemblyName = AssemblyNameFromOptions(parameters.CompilerOptions); 
                if (assemblyName == null)
                    assemblyName = GetTempAssemblyPath(parameters.TempFiles.TempDir, parent, ns); 
                //
                parameters.OutputAssembly = assemblyName;
            }
 
            if (parameters.CompilerOptions == null || parameters.CompilerOptions.Length == 0)
                parameters.CompilerOptions = "/nostdlib"; 
            else 
                parameters.CompilerOptions += " /nostdlib";
 
            parameters.CompilerOptions += " /D:_DYNAMIC_XMLSERIALIZER_COMPILATION";
#pragma warning disable 618
            parameters.Evidence = evidence;
#pragma warning restore 618 
            CompilerResults results = null;
            Assembly assembly = null; 
            try { 
                results = codeProvider.CompileAssemblyFromSource(parameters, writer.ToString());
                // check the output for errors or a certain level-1 warning (1595) 
                if (results.Errors.Count > 0) {
                    StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
                    stringWriter.WriteLine(Res.GetString(Res.XmlCompilerError, results.NativeCompilerReturnValue.ToString(CultureInfo.InvariantCulture)));
                    bool foundOne = false; 
                    foreach (CompilerError e in results.Errors) {
                        // clear filename. This makes ToString() print just error number and message. 
                        e.FileName = ""; 
                        if (!e.IsWarning || e.ErrorNumber == "CS1595") {
                            foundOne = true; 
                            stringWriter.WriteLine(e.ToString());
                        }
                    }
                    if (foundOne) { 
                        throw new InvalidOperationException(stringWriter.ToString());
                    } 
                } 
                assembly = results.CompiledAssembly;
            } 
            catch (UnauthorizedAccessException) {
                // try to get the user token
                string user = GetCurrentUser();
                if (user == null || user.Length == 0) { 
                    throw new UnauthorizedAccessException(Res.GetString(Res.XmlSerializerAccessDenied));
                } 
                else { 
                    throw new UnauthorizedAccessException(Res.GetString(Res.XmlIdentityAccessDenied, user));
                } 
            }
            catch (FileLoadException fle) {
                throw new InvalidOperationException(Res.GetString(Res.XmlSerializerCompileFailed), fle);
            } 
            finally {
                CodeAccessPermission.RevertAssert(); 
            } 
            // somehow we got here without generating an assembly
            if (assembly == null) throw new InvalidOperationException(Res.GetString(Res.XmlInternalError)); 

            return assembly;
        }
 
        static string AssemblyNameFromOptions(string options) {
            if (options == null || options.Length == 0) 
                return null; 

            string outName = null; 
            string[] flags = options.ToLower(CultureInfo.InvariantCulture).Split(null);
            for (int i = 0; i < flags.Length; i++) {
                string val = flags[i].Trim();
                if (val.StartsWith("/out:", StringComparison.Ordinal)) { 
                    outName = val.Substring(5);
                } 
            } 
            return outName;
        } 

        internal static string GetCurrentUser()
        {
#if !FEATURE_PAL 
            try {
                WindowsIdentity id = WindowsIdentity.GetCurrent(); 
                if (id != null && id.Name != null) 
                    return id.Name;
            } 
            catch (Exception e) {
                if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                    throw;
                } 
            }
#endif // !FEATURE_PAL 
            return ""; 
        }
    } 
}



// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

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