CodeGenerator.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 / cdf / src / WCF / Serialization / System / Runtime / Serialization / CodeGenerator.cs / 1305376 / CodeGenerator.cs

                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
// ***NOTE*** If this code is changed, make corresponding changes in System.ServiceModel.CodeGenerator also
namespace System.Runtime.Serialization 
{
    using System; 
    using System.Collections; 
    using System.Diagnostics;
    using System.Globalization; 
    using System.Reflection;
    using System.Reflection.Emit;
    using System.Security;
 
    class CodeGenerator
    { 
        [Fx.Tag.SecurityNote(Critical = "Static fields are marked SecurityCritical or readonly to prevent" 
            + " data from being modified or leaked to other components in appdomain.")]
        [SecurityCritical] 
        static MethodInfo getTypeFromHandle;
        static MethodInfo GetTypeFromHandle
        {
            [Fx.Tag.SecurityNote(Critical = "Fetches the critical getTypeFromHandle field.", 
                Safe = "Get-only properties only needs to be protected for write; initialized in getter if null.")]
            [SecuritySafeCritical] 
            get 
            {
                if (getTypeFromHandle == null) 
                    getTypeFromHandle = typeof(Type).GetMethod("GetTypeFromHandle");
                return getTypeFromHandle;
            }
        } 

        [Fx.Tag.SecurityNote(Critical = "Static fields are marked SecurityCritical or readonly to prevent" 
            + " data from being modified or leaked to other components in appdomain.")] 
        [SecurityCritical]
        static MethodInfo stringFormat; 
        static MethodInfo StringFormat
        {
            [Fx.Tag.SecurityNote(Critical = "Fetches the critical stringFormat field.",
                Safe = "Get-only properties only needs to be protected for write; initialized in getter if null.")] 
            [SecuritySafeCritical]
            get 
            { 
                if (stringFormat == null)
                    stringFormat = typeof(string).GetMethod("Format", new Type[] { typeof(string), typeof(object[]) }); 
                return stringFormat;
            }
        }
 
        [Fx.Tag.SecurityNote(Critical = "Static fields are marked SecurityCritical or readonly to prevent"
            + " data from being modified or leaked to other components in appdomain.")] 
        [SecurityCritical] 
        static MethodInfo stringConcat2;
        static MethodInfo StringConcat2 
        {
            [Fx.Tag.SecurityNote(Critical = "Fetches the critical stringConcat2 field.",
                Safe = "Get-only properties only needs to be protected for write; initialized in getter if null.")]
            [SecuritySafeCritical] 
            get
            { 
                if (stringConcat2 == null) 
                    stringConcat2 = typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string) });
                return stringConcat2; 
            }
        }

        [Fx.Tag.SecurityNote(Critical = "Static fields are marked SecurityCritical or readonly to prevent" 
            + " data from being modified or leaked to other components in appdomain.")]
        [SecurityCritical] 
        static MethodInfo stringConcat3; 
        static MethodInfo StringConcat3
        { 
            [Fx.Tag.SecurityNote(Critical = "Fetches the critical stringConcat3 field.",
                Safe = "Get-only properties only needs to be protected for write; initialized in getter if null.")]
            [SecuritySafeCritical]
            get 
            {
                if (stringConcat3 == null) 
                    stringConcat3 = typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string), typeof(string) }); 
                return stringConcat3;
            } 
        }

        [Fx.Tag.SecurityNote(Critical = "Static fields are marked SecurityCritical or readonly to prevent"
            + " data from being modified or leaked to other components in appdomain.")] 
        [SecurityCritical]
        static MethodInfo objectToString; 
        static MethodInfo ObjectToString 
        {
            [Fx.Tag.SecurityNote(Critical = "Fetches the critical objectToString field.", 
                Safe = "Get-only properties only needs to be protected for write; initialized in getter if null.")]
            [SecuritySafeCritical]
            get
            { 
                if (objectToString == null)
                    objectToString = typeof(object).GetMethod("ToString", new Type[0]); 
                return objectToString; 
            }
        } 

        [Fx.Tag.SecurityNote(Critical = "Static fields are marked SecurityCritical or readonly to prevent"
            + " data from being modified or leaked to other components in appdomain.")]
        [SecurityCritical] 
        static MethodInfo objectEquals;
        static MethodInfo ObjectEquals 
        { 
            [Fx.Tag.SecurityNote(Critical = "Fetches the critical objectEquals field.",
                Safe = "Get-only properties only needs to be protected for write; initialized in getter if null.")] 
            [SecuritySafeCritical]
            get
            {
                if (objectEquals == null) 
                    objectEquals = Globals.TypeOfObject.GetMethod("Equals", BindingFlags.Public | BindingFlags.Static);
                return objectEquals; 
            } 
        }
 
        [Fx.Tag.SecurityNote(Critical = "Static fields are marked SecurityCritical or readonly to prevent"
            + " data from being modified or leaked to other components in appdomain.")]
        [SecurityCritical]
        static MethodInfo arraySetValue; 
        static MethodInfo ArraySetValue
        { 
            [Fx.Tag.SecurityNote(Critical = "Fetches the critical arraySetValue field.", 
                Safe = "Get-only properties only needs to be protected for write; initialized in getter if null.")]
            [SecuritySafeCritical] 
            get
            {
                if (arraySetValue == null)
                    arraySetValue = typeof(Array).GetMethod("SetValue", new Type[] { typeof(object), typeof(int) }); 
                return arraySetValue;
            } 
        } 

        Type delegateType; 

        #if USE_REFEMIT
        AssemblyBuilder assemblyBuilder;
        ModuleBuilder moduleBuilder; 
        TypeBuilder typeBuilder;
        static int typeCounter; 
        MethodBuilder methodBuilder; 
        #else
        [Fx.Tag.SecurityNote(Critical = "Static fields are marked SecurityCritical or readonly to prevent" 
            + " data from being modified or leaked to other components in appdomain.")]
        [SecurityCritical]
        static Module serializationModule;
        static Module SerializationModule 
        {
            [Fx.Tag.SecurityNote(Critical = "Fetches the critical serializationModule field.", 
                Safe = "Get-only properties only needs to be protected for write; initialized in getter if null.")] 
            [SecuritySafeCritical]
            get 
            {
                if (serializationModule == null)
                {
                    serializationModule = typeof(CodeGenerator).Module;   // could to be replaced by different dll that has SkipVerification set to false 
                }
                return serializationModule; 
            } 
        }
        DynamicMethod dynamicMethod; 
        #endif

        ILGenerator ilGen;
        ArrayList argList; 
        Stack blockStack;
        Label methodEndLabel; 
 
        LocalBuilder stringFormatArray;
 
        Hashtable localNames;
        int lineNo = 1;
        enum CodeGenTrace {None, Save, Tron};
        CodeGenTrace codeGenTrace; 

        internal CodeGenerator() 
        { 
            SourceSwitch codeGenSwitch = SerializationTrace.CodeGenerationSwitch;
            if ((codeGenSwitch.Level & SourceLevels.Verbose) == SourceLevels.Verbose) 
                codeGenTrace = CodeGenTrace.Tron;
            else if ((codeGenSwitch.Level & SourceLevels.Information) == SourceLevels.Information)
                codeGenTrace = CodeGenTrace.Save;
            else 
                codeGenTrace = CodeGenTrace.None;
        } 
 
#if !USE_REFEMIT
        internal void BeginMethod(DynamicMethod dynamicMethod, Type delegateType, string methodName, Type[] argTypes, bool allowPrivateMemberAccess) 
        {
            this.dynamicMethod = dynamicMethod;
            this.ilGen = this.dynamicMethod.GetILGenerator();
            this.delegateType = delegateType; 

            InitILGeneration(methodName, argTypes); 
        } 
#endif
 
        internal void BeginMethod(string methodName, Type delegateType, bool allowPrivateMemberAccess)
        {
            MethodInfo signature = delegateType.GetMethod("Invoke");
            ParameterInfo[] parameters = signature.GetParameters(); 
            Type[] paramTypes = new Type[parameters.Length];
            for (int i = 0; i < parameters.Length; i++) 
                paramTypes[i] = parameters[i].ParameterType; 
            BeginMethod(signature.ReturnType, methodName, paramTypes, allowPrivateMemberAccess);
            this.delegateType = delegateType; 
        }

        void BeginMethod(Type returnType, string methodName, Type[] argTypes, bool allowPrivateMemberAccess)
        { 
            #if USE_REFEMIT
            string typeName = "Type" + (typeCounter++); 
            InitAssemblyBuilder(typeName + "." + methodName); 
            this.typeBuilder = moduleBuilder.DefineType(typeName, TypeAttributes.Public);
            this.methodBuilder = typeBuilder.DefineMethod(methodName, MethodAttributes.Public|MethodAttributes.Static, returnType, argTypes); 
            this.ilGen = this.methodBuilder.GetILGenerator();
            #else
            this.dynamicMethod = new DynamicMethod(methodName, returnType, argTypes, SerializationModule, allowPrivateMemberAccess);
            this.ilGen = this.dynamicMethod.GetILGenerator(); 
            #endif
 
            InitILGeneration(methodName, argTypes); 
        }
 
        void InitILGeneration(string methodName, Type[] argTypes)
        {
            this.methodEndLabel = ilGen.DefineLabel();
            this.blockStack = new Stack(); 
            this.argList = new ArrayList();
            for (int i=0;i");
                Else(); 
                if (type.IsArray)
                {
                    LocalBuilder arrayVar = DeclareLocal(type, "arrayVar");
                    Store(arrayVar); 
                    Load("{ ");
                    LocalBuilder arrayValueString = DeclareLocal(typeof(string), "arrayValueString"); 
                    Store(arrayValueString); 
                    LocalBuilder i = DeclareLocal(typeof(int), "i");
                    For(i, 0, arrayVar); 
                    Load(arrayValueString);
                    LoadArrayElement(arrayVar, i);
                    ToString(arrayVar.LocalType.GetElementType());
                    Load(", "); 
                    Concat3();
                    Store(arrayValueString); 
                    EndFor(); 
                    Load(arrayValueString);
                    Load("}"); 
                    Concat2();
                }
                else
                    Call(ObjectToString); 
                EndIf();
            } 
        } 

        internal void Concat2() 
        {
            Call(StringConcat2);
        }
 
        internal void Concat3()
        { 
            Call(StringConcat3); 
        }
 
        internal Label[] Switch(int labelCount)
        {
            SwitchState switchState = new SwitchState(DefineLabel(), DefineLabel());
            Label[] caseLabels = new Label[labelCount]; 
            for (int i=0;i 0;
            return !hasAptca; 
        } 

        void DemandFullTrust() 
        {
            fullTrustDemanded = true;
/*
            if (codeGenTrace != CodeGenTrace.None) 
                EmitSourceComment("DemandFullTrust() {");
 
            Ldc(PermissionState.Unrestricted); 
            New(permissionSetCtor);
            Call(permissionSetDemand); 

            if (codeGenTrace != CodeGenTrace.None)
                EmitSourceComment("}");
*/ 
        }
 
        static bool IsProtectedWithSecurity(MethodBase method) 
        {
            return false; 
            //return (method.Attributes & MethodAttributes.HasSecurity) != 0;
        }

#endif 

    } 
 

    internal class ArgBuilder 
    {
        internal int Index;
        internal Type ArgType;
        internal ArgBuilder(int index, Type argType) 
        {
            this.Index = index; 
            this.ArgType = argType; 
        }
    } 

    internal class ForState
    {
        LocalBuilder indexVar; 
        Label beginLabel;
        Label testLabel; 
        Label endLabel; 
        bool requiresEndLabel;
        object end; 

        internal ForState(LocalBuilder indexVar, Label beginLabel, Label testLabel, object end)
        {
            this.indexVar = indexVar; 
            this.beginLabel = beginLabel;
            this.testLabel = testLabel; 
            this.end = end; 
        }
 
        internal LocalBuilder Index
        {
            get
            { 
                return indexVar;
            } 
        } 

        internal Label BeginLabel 
        {
            get
            {
                return beginLabel; 
            }
        } 
 
        internal Label TestLabel
        { 
            get
            {
                return testLabel;
            } 
        }
 
        internal Label EndLabel 
        {
            get 
            {
                return endLabel;
            }
            set 
            {
                endLabel = value; 
            } 
        }
 
        internal bool RequiresEndLabel
        {
            get
            { 
                return requiresEndLabel;
            } 
            set 
            {
                requiresEndLabel = value; 
            }
        }

        internal object End 
        {
            get 
            { 
                return end;
            } 
        }
    }

    internal enum Cmp 
    {
        LessThan, 
        EqualTo, 
        LessThanOrEqualTo,
        GreaterThan, 
        NotEqualTo,
        GreaterThanOrEqualTo
    }
 
    internal class IfState
    { 
        Label elseBegin; 
        Label endIf;
 
        internal Label EndIf
        {
            get
            { 
                return this.endIf;
            } 
            set 
            {
                this.endIf= value; 
            }
        }

        internal Label ElseBegin 
        {
            get 
            { 
                return this.elseBegin;
            } 
            set
            {
                this.elseBegin= value;
            } 
        }
 
    } 

#if NotUsed 
    internal class BitFlagsGenerator
    {
        LocalBuilder[] locals;
        CodeGenerator ilg; 
        int bitCount;
        internal BitFlagsGenerator(int bitCount, CodeGenerator ilg, string localName) 
        { 
            this.ilg = ilg;
            this.bitCount = bitCount; 
            int localCount = (bitCount+7)/8;
            locals = new LocalBuilder[localCount];
            for (int i=0;i> 3; 
        }
 
        static byte GetBitValue(int bitIndex)
        {
            return (byte)(1 << (bitIndex & 7));
        } 
    }
#endif 
 
    internal class SwitchState
    { 
        Label defaultLabel;
        Label endOfSwitchLabel;
        bool defaultDefined;
        internal SwitchState(Label defaultLabel, Label endOfSwitchLabel) 
        {
            this.defaultLabel = defaultLabel; 
            this.endOfSwitchLabel = endOfSwitchLabel; 
            this.defaultDefined = false;
        } 
        internal Label DefaultLabel
        {
            get
            { 
                return defaultLabel;
            } 
        } 

        internal Label EndOfSwitchLabel 
        {
            get
            {
                return endOfSwitchLabel; 
            }
        } 
        internal bool DefaultDefined 
        {
            get 
            {
                return defaultDefined;
            }
            set 
            {
                defaultDefined = value; 
            } 
        }
    } 

}

 

// 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