Ejemplo n.º 1
0
	// note: pointers don't *need* to be SecurityCritical because they can't be
	// used without a "unsafe" or "fixed" context that transparent code won't support
	static bool CheckType (TypeReference type)
	{
		string fullname = type.FullName;

		// pointers can only be used by fixed/unsafe code
		return !fullname.EndsWith ("*");
	}
Ejemplo n.º 2
0
 public VariableDefinition(string name, int index, MethodDefinition method, TypeReference variable)
     : this(variable)
 {
     m_name = name;
     m_index = index;
     m_method = method;
 }
Ejemplo n.º 3
0
		public static Expression CreateDefaultValueForType(TypeReference type)
		{
			if (type != null && !type.IsArrayType) {
				switch (type.Type) {
					case "System.SByte":
					case "System.Byte":
					case "System.Int16":
					case "System.UInt16":
					case "System.Int32":
					case "System.UInt32":
					case "System.Int64":
					case "System.UInt64":
					case "System.Single":
					case "System.Double":
						return new PrimitiveExpression(0, "0");
					case "System.Char":
						return new PrimitiveExpression('\0', "'\\0'");
					case "System.Object":
					case "System.String":
						return new PrimitiveExpression(null, "null");
					case "System.Boolean":
						return new PrimitiveExpression(false, "false");
					default:
						return new DefaultValueExpression(type);
				}
			} else {
				return new PrimitiveExpression(null, "null");
			}
		}
Ejemplo n.º 4
0
    public void Execute()
    {
        var systemDefinition = AssemblyResolver.Resolve("System");
        var systemTypes = systemDefinition.MainModule.Types;

        var debugType = systemTypes.First(x => x.Name == "Debug");
        DebugWriteLineMethod = ModuleDefinition.Import(debugType.Methods.First(x =>
            x.Name == "WriteLine" &&
            x.Parameters.Count == 1 &&
            x.Parameters[0].ParameterType.Name == "String"));

        var mscorlib = AssemblyResolver.Resolve("mscorlib");
        var mscorlibTypes = mscorlib.MainModule.Types;
        var methodBaseType = mscorlibTypes.First(x => x.Name == "MethodBase");
        GetMethodFromHandle = ModuleDefinition.Import(methodBaseType.Methods.First(x =>
            x.Name == "GetMethodFromHandle" &&
            x.Parameters.Count == 1 &&
            x.Parameters[0].ParameterType.Name == "RuntimeMethodHandle"));

        var stopwatchType = systemTypes.First(x => x.Name == "Stopwatch");
        StopwatchType = ModuleDefinition.Import(stopwatchType);
        StartNewMethod = ModuleDefinition.Import(stopwatchType.Methods.First(x => x.Name == "StartNew"));
        StopMethod = ModuleDefinition.Import(stopwatchType.Methods.First(x => x.Name == "Stop"));
        ElapsedMilliseconds = ModuleDefinition.Import(stopwatchType.Methods.First(x => x.Name == "get_ElapsedMilliseconds"));

        var stringType = ModuleDefinition.TypeSystem.String;
        ConcatMethod = ModuleDefinition.Import(stringType.Resolve().Methods.First(x => x.Name == "Concat" && x.Parameters.Count == 3));
    }
Ejemplo n.º 5
0
        internal static void Fill(string tdString, TypeReference item)
        {
            if (!string.IsNullOrEmpty(tdString))
            {
                char prefix = tdString[0];
                var td = (TypeDescriptors) prefix;
                switch (td)
                {
                    case TypeDescriptors.Array:
                        var atype = (ArrayType) item;

                        TypeReference elementType = Allocate(tdString.Substring(1));
                        Fill(tdString.Substring(1), elementType);

                        /* All types are already allocated
                         * We want to reuse object reference if already in type repository
                         * BUT if not, we don't want to add a new reference to this type:
                         * it's a 'transient' type only used in the Dexer object model but
                         * not persisted in dex file.
                         */
                        atype.ElementType = elementType; //context.Import(elementType, false);

                        break;
                    case TypeDescriptors.FullyQualifiedName:
                        var cref = (ClassReference) item;
                        cref.Fullname = tdString.Substring(1, tdString.Length - 2);
                        break;
                }
            }
        }
 MethodReference GetEquality(TypeReference typeDefinition)
 {
     if (typeDefinition.IsGenericParameter)
     {
         return null;
     }
     if (typeDefinition.Namespace.StartsWith("System.Collections"))
     {
         return null;
     }
     if (typeDefinition.IsArray)
     {
         return null;
     }
     if (typeDefinition.IsGenericInstance)
     {
         if (typeDefinition.FullName.StartsWith("System.Nullable"))
         {
             var typeWrappedByNullable = ((GenericInstanceType) typeDefinition).GenericArguments.First();
             if (typeWrappedByNullable.IsGenericParameter)
             {
                 return null;
             }
             var genericInstanceMethod = new GenericInstanceMethod(msCoreReferenceFinder.NullableEqualsMethod);
             genericInstanceMethod.GenericArguments.Add(typeWrappedByNullable);
             return moduleReader.Module.Import(genericInstanceMethod);
         }
     }
     var equality = GetStaticEquality(typeDefinition);
     if (equality != null)
     {
         return moduleReader.Module.Import(equality);
     }
     return null;
 }
 public void FindWinRTMsCoreReferences()
 {
     var systemRuntime = assemblyResolver.Resolve("System.Runtime");
     var systemRuntimeTypes = systemRuntime.MainModule.Types;
     var voidDefinition = systemRuntimeTypes.First(x => x.Name == "Void");
     VoidTypeReference = Module.Import(voidDefinition);
 }
    void FindMsCoreReferences()
    {
        var msCoreLibDefinition = AssemblyResolver.Resolve("mscorlib");

        msCoreTypes = msCoreLibDefinition.MainModule.Types.ToList();

        var objectDefinition = msCoreTypes.FirstOrDefault(x => x.Name == "Object");
        if (objectDefinition == null)
        {
            throw new WeavingException("Only compat with desktop .net");
        }

        var voidDefinition = msCoreTypes.First(x => x.Name == "Void");
        voidTypeReference = ModuleDefinition.ImportReference(voidDefinition);

        var dictionary = msCoreTypes.First(x => x.Name == "Dictionary`2");
        var dictionaryOfStringOfString = ModuleDefinition.ImportReference(dictionary);
        dictionaryOfStringOfStringAdd = ModuleDefinition.ImportReference(dictionaryOfStringOfString.Resolve().Methods.First(m => m.Name == "Add"))
            .MakeHostInstanceGeneric(ModuleDefinition.TypeSystem.String, ModuleDefinition.TypeSystem.String);

        var list = msCoreTypes.First(x => x.Name == "List`1");
        var listOfString = ModuleDefinition.ImportReference(list);
        listOfStringAdd = ModuleDefinition.ImportReference(listOfString.Resolve().Methods.First(m => m.Name == "Add"))
            .MakeHostInstanceGeneric(ModuleDefinition.TypeSystem.String);

        var compilerGeneratedAttribute = msCoreTypes.First(x => x.Name == "CompilerGeneratedAttribute");
        compilerGeneratedAttributeCtor = ModuleDefinition.ImportReference(compilerGeneratedAttribute.Methods.First(x => x.IsConstructor));
    }
Ejemplo n.º 9
0
 public FieldDefinition(ClassDefinition owner, string name, TypeReference fieldType)
     : this()
 {
     Owner = owner;
     Name = name;
     Type = fieldType;
 }
Ejemplo n.º 10
0
        //=====================================================================

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="pointedToType">The pointed to type</param>
        public PointerTypeReference(TypeReference pointedToType)
        {
            if(pointedToType == null)
                throw new ArgumentNullException("pointedToType");

            this.PointedToType = pointedToType;
        }
Ejemplo n.º 11
0
    public void FindCoreReferences()
    {
        var coreTypes = new List<TypeDefinition>();
        AppendTypes("mscorlib", coreTypes);
        AppendTypes("System.IO", coreTypes);
        AppendTypes("System.Runtime", coreTypes);
        AppendTypes("System.Reflection", coreTypes);

        var textReaderTypeDefinition = coreTypes.First(x => x.Name == "TextReader");
        ReadToEndMethod = ModuleDefinition.ImportReference(textReaderTypeDefinition.Find("ReadToEnd"));

        var exceptionTypeDefinition = coreTypes.First(x => x.Name == "Exception");
        ExceptionConstructorReference = ModuleDefinition.ImportReference(exceptionTypeDefinition.Find(".ctor", "String"));

        var stringTypeDefinition = coreTypes.First(x => x.Name == "String");
        ConcatReference = ModuleDefinition.ImportReference(stringTypeDefinition.Find("Concat", "String", "String", "String"));

        DisposeTextReaderMethod = ModuleDefinition.ImportReference(textReaderTypeDefinition.Find("Dispose"));
        var streamTypeDefinition = coreTypes.First(x => x.Name == "Stream");
        DisposeStreamMethod = ModuleDefinition.ImportReference(streamTypeDefinition.Find("Dispose"));
        StreamTypeReference = ModuleDefinition.ImportReference(streamTypeDefinition);
        var streamReaderTypeDefinition = coreTypes.First(x => x.Name == "StreamReader");
        StreamReaderTypeReference = ModuleDefinition.ImportReference(streamReaderTypeDefinition);
        StreamReaderConstructorReference = ModuleDefinition.ImportReference(streamReaderTypeDefinition.Find(".ctor", "Stream"));
        var assemblyTypeDefinition = coreTypes.First(x => x.Name == "Assembly");
        AssemblyTypeReference = ModuleDefinition.ImportReference(assemblyTypeDefinition);
        GetExecutingAssemblyMethod = ModuleDefinition.ImportReference(assemblyTypeDefinition.Find("GetExecutingAssembly"));
        GetManifestResourceStreamMethod = ModuleDefinition.ImportReference(assemblyTypeDefinition.Find("GetManifestResourceStream", "String"));
    }
Ejemplo n.º 12
0
        public static string Encode(TypeReference tref, bool shorty)
        {
            var result = new StringBuilder();

            var td = (char)tref.TypeDescriptor;

            if (!shorty)
            {
                result.Append(td);

                if (tref is ArrayType)
                    result.Append(Encode((tref as ArrayType).ElementType, false));

                if (tref is ClassReference)
                    result.Append(string.Concat((tref as ClassReference).Fullname.Replace(ClassReference.NamespaceSeparator, ClassReference.InternalNamespaceSeparator), ";"));
            }
            else
            {
                /* A ShortyDescriptor is the short form representation of a method prototype,
                 * including return and parameter types, except that there is no distinction
                 * between various reference (class or array) types. Instead, all reference
                 * types are represented by a single 'L' character. */
                if (td == (char)TypeDescriptors.Array)
                    td = (char)TypeDescriptors.FullyQualifiedName;

                result.Append(td);
            }

            return result.ToString();
        }
Ejemplo n.º 13
0
    public void Execute()
    {
        var validationTemplateAttribute = ModuleDefinition
            .Assembly
            .CustomAttributes
            .FirstOrDefault(x=>x.AttributeType.Name == "ValidationTemplateAttribute");

        if (validationTemplateAttribute == null)
        {
            LogInfo("Could not find a 'ValidationTemplateAttribute' on the current assembly. Going to search current assembly for 'ValidationTemplate'.");

            TypeDefinition = ModuleDefinition
                .GetTypes()
                .FirstOrDefault(x =>
                    x.Name == "ValidationTemplate" ||
                    x.Name == "ValidationTemplate`1");
            if (TypeDefinition == null)
            {
                throw new WeavingException("Could not find a type named 'ValidationTemplate'");
            }
            TypeReference = TypeDefinition;

            FindConstructor();
        }
        else
        {
            var typeReference = (TypeReference) validationTemplateAttribute.ConstructorArguments.First().Value;

            TypeReference = typeReference;
            TypeDefinition = typeReference.Resolve();

            FindConstructor();
            TemplateConstructor = ModuleDefinition.Import(TemplateConstructor);
        }
    }
Ejemplo n.º 14
0
    private static MethodReference CloneMethodWithDeclaringType(MethodDefinition methodDef, TypeReference declaringTypeRef)
    {
        if (!declaringTypeRef.IsGenericInstance || methodDef == null)
        {
            return methodDef;
        }

        var methodRef = new MethodReference(methodDef.Name, methodDef.ReturnType, declaringTypeRef)
        {
            CallingConvention = methodDef.CallingConvention,
            HasThis = methodDef.HasThis,
            ExplicitThis = methodDef.ExplicitThis
        };

        foreach (var paramDef in methodDef.Parameters)
        {
            methodRef.Parameters.Add(new ParameterDefinition(paramDef.Name, paramDef.Attributes, paramDef.ParameterType));
        }

        foreach (var genParamDef in methodDef.GenericParameters)
        {
            methodRef.GenericParameters.Add(new GenericParameter(genParamDef.Name, methodRef));
        }

        return methodRef;
    }
Ejemplo n.º 15
0
 internal void AddAppliesToType(string typeName)
 {
     TypeReference item = new TypeReference {
         name = typeName
     };
     this.referenceList.Add(item);
 }
Ejemplo n.º 16
0
        //=====================================================================

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="referredToType">The referred to type</param>
        public ReferenceTypeReference(TypeReference referredToType)
        {
            if(referredToType == null)
                throw new ArgumentNullException("referredToType");

            this.ReferredToType = referredToType;
        }
Ejemplo n.º 17
0
        private TypeReference ReadObject(JsonReader reader)
        {
            reader.Read();
            if (reader.TokenType != JsonToken.PropertyName || ((string)reader.Value != "__ref__" && (string)reader.Value != "type"))
            {
                throw new ArgumentException("Unexpected token type " + reader.TokenType);
            }

            var isRef = (string) reader.Value == "__ref__";

            reader.Read();
            if (reader.TokenType != JsonToken.String)
            {
                throw new ArgumentException("Unexpected token type " + reader.TokenType);
            }

            var retval = new TypeReference
            {
                IsReference = isRef,
                Name = (string)reader.Value
            };
            reader.Read();

            return retval;
        }
Ejemplo n.º 18
0
 public void ExecuteWinRT()
 {
     var systemRuntime = assemblyResolver.Resolve("System.Runtime");
     var systemRuntimeTypes = systemRuntime.MainModule.Types;
     var voidDefinition = systemRuntimeTypes.First(x => x.Name == "Void");
     VoidTypeReference = moduleReader.Module.Import(voidDefinition);
 }
Ejemplo n.º 19
0
    public void Init()
    {
        var logManagerType = NLogReference.MainModule.Types.First(x => x.Name == "LogManager");
        var getLoggerGenericDefinition = logManagerType.Methods.First(x => x.Name == "GetCurrentClassLogger");
        buildLoggerGenericMethod = ModuleDefinition.Import(getLoggerGenericDefinition);
        var loggerTypeDefinition = NLogReference.MainModule.Types.First(x => x.Name == "Logger");
        var getLoggerDefinition = logManagerType.Methods.First(x => x.Name == "GetLogger" && x.IsMatch("String"));
        buildLoggerMethod = ModuleDefinition.Import(getLoggerDefinition);

        TraceMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("Trace", "String", "Object[]"));
        isTraceEnabledMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("get_IsTraceEnabled"));
        TraceExceptionMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("TraceException", "String", "Exception"));
        DebugMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("Debug", "String","Object[]"));
        isDebugEnabledMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("get_IsDebugEnabled"));
        DebugExceptionMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("DebugException", "String", "Exception"));
        InfoMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("Info", "String", "Object[]"));
        isInfoEnabledMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("get_IsInfoEnabled"));
        InfoExceptionMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("InfoException", "String", "Exception"));
        WarnMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("Warn", "String", "Object[]"));
        isWarnEnabledMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("get_IsWarnEnabled"));
        WarnExceptionMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("WarnException", "String", "Exception"));
        ErrorMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("Error", "String", "Object[]"));
        isErrorEnabledMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("get_IsErrorEnabled"));
        ErrorExceptionMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("ErrorException", "String", "Exception"));
        FatalMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("Fatal", "String", "Object[]"));
        isFatalEnabledMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("get_IsFatalEnabled"));
        FatalExceptionMethod = ModuleDefinition.Import(loggerTypeDefinition.FindMethod("FatalException", "String", "Exception"));
        LoggerType = ModuleDefinition.Import(loggerTypeDefinition);
    }
    public void Execute()
    {
        var msCoreLibDefinition = assemblyResolver.Resolve("mscorlib");
        var msCoreTypes = msCoreLibDefinition.MainModule.Types;

        var objectDefinition = msCoreTypes.FirstOrDefault(x => x.Name == "Object");
        if (objectDefinition == null)
        {
            ExecuteWinRT();
            return;
        }
        var module = moduleWeaver.ModuleDefinition;

        var methodBaseDefinition = msCoreTypes.First(x => x.Name == "MethodBase");
        GetMethodFromHandle = module.ImportReference(methodBaseDefinition.Methods.First(x => x.Name == "GetMethodFromHandle"));

        var methodInfo = msCoreTypes.FirstOrDefault(x => x.Name == "MethodInfo");
        MethodInfoTypeReference = module.ImportReference(methodInfo);

        var compilerGeneratedDefinition = msCoreTypes.First(x => x.Name == "CompilerGeneratedAttribute");
        CompilerGeneratedReference = module.ImportReference(compilerGeneratedDefinition.Methods.First(x => x.IsConstructor));

        var systemCoreDefinition = GetSystemCoreDefinition();

        var expressionTypeDefinition = systemCoreDefinition.MainModule.Types.First(x => x.Name == "Expression");
        var propertyMethodDefinition =
            expressionTypeDefinition.Methods.First(
                x => x.Name == "Property" && x.Parameters.Last().ParameterType.Name == "MethodInfo");
        PropertyReference = module.ImportReference(propertyMethodDefinition);
    }
 /// <summary>
 /// Default ctor
 /// </summary>
 public VariableStartEntry(int offset, Register register, IVariable variable, TypeReference type) : base(offset)
 {
     this.register = register;
     Variable = variable;
     name = variable.OriginalName;
     this.type = type;
 }
Ejemplo n.º 22
0
        internal void AddAppliesToType(string typeName)
        {
            TypeReference tr = new TypeReference();

            tr.name = typeName;
            this.referenceList.Add(tr);
        }
Ejemplo n.º 23
0
    public void Execute()
    {
        var assemblyContainsAttribute = ModuleDefinition.Assembly.CustomAttributes.ContainsAttribute("Anotar.NLog.LogMinimalMessageAttribute");
        var moduleContainsAttribute = ModuleDefinition.CustomAttributes.ContainsAttribute("Anotar.NLog.LogMinimalMessageAttribute");
        if (assemblyContainsAttribute || moduleContainsAttribute)
        {
            LogMinimalMessage = true;
		}
		FindReference();
		Init();
        var stringType = ModuleDefinition.TypeSystem.String.Resolve();
        ConcatMethod = ModuleDefinition.Import(stringType.FindMethod("Concat", "String", "String"));
        FormatMethod = ModuleDefinition.Import(stringType.FindMethod("Format", "String", "Object[]"));
        ObjectArray = new ArrayType(ModuleDefinition.TypeSystem.Object);

        var msCoreLibDefinition = AssemblyResolver.Resolve("mscorlib");
        ExceptionType = ModuleDefinition.Import(msCoreLibDefinition.MainModule.Types.First(x => x.Name == "Exception"));
        foreach (var type in ModuleDefinition
            .GetTypes()
            .Where(x => (x.BaseType != null) && !x.IsEnum && !x.IsInterface))
        {
            ProcessType(type);
        }

        //TODO: ensure attributes don't exist on interfaces
        RemoveReference();
    }
Ejemplo n.º 24
0
		/// <summary>
		/// Determines whether a type given by its full name corresponds to a type reference.
		/// </summary>
		public static bool IsType(TypeReference type, string typeName)
		{
			if (type.SystemType == typeName) return true;

			int index = typeName.LastIndexOf('.');
			return (index > 0 && type.SystemType == typeName.Substring(index + 1));
		}
Ejemplo n.º 25
0
    public void Init()
    {
        var logManagerFactoryType = MetroLogReference.MainModule.Types.First(x => x.Name == "LogManagerFactory");
        var getDefaultLogManagerDefinition = logManagerFactoryType.Methods.First(x => x.Name == "get_DefaultLogManager");
        getDefaultLogManager = ModuleDefinition.Import(getDefaultLogManagerDefinition);

        var logManagerType = MetroLogReference.MainModule.Types.First(x => x.Name == "ILogManager");
        var getLoggerDefinition = logManagerType.Methods.First(x => x.Name == "GetLogger" && x.IsMatch("String", "LoggingConfiguration"));
        buildLoggerMethod = ModuleDefinition.Import(getLoggerDefinition);
        var loggerType = MetroLogReference.MainModule.Types.First(x => x.Name == "ILogger");

        TraceMethod = ModuleDefinition.Import(loggerType.FindMethod("Trace", "String", "Object[]"));
        isTraceEnabledMethod = ModuleDefinition.Import(loggerType.FindMethod("get_IsTraceEnabled"));
        TraceExceptionMethod = ModuleDefinition.Import(loggerType.FindMethod("Trace", "String", "Exception"));
        DebugMethod = ModuleDefinition.Import(loggerType.FindMethod("Debug", "String", "Object[]"));
        isDebugEnabledMethod = ModuleDefinition.Import(loggerType.FindMethod("get_IsDebugEnabled"));
        DebugExceptionMethod = ModuleDefinition.Import(loggerType.FindMethod("Debug", "String", "Exception"));
        InfoMethod = ModuleDefinition.Import(loggerType.FindMethod("Info", "String", "Object[]"));
        isInfoEnabledMethod = ModuleDefinition.Import(loggerType.FindMethod("get_IsInfoEnabled"));
        InfoExceptionMethod = ModuleDefinition.Import(loggerType.FindMethod("Info", "String", "Exception"));
        WarnMethod = ModuleDefinition.Import(loggerType.FindMethod("Warn", "String", "Object[]"));
        isWarnEnabledMethod = ModuleDefinition.Import(loggerType.FindMethod("get_IsWarnEnabled"));
        WarnExceptionMethod = ModuleDefinition.Import(loggerType.FindMethod("Warn", "String", "Exception"));
        ErrorMethod = ModuleDefinition.Import(loggerType.FindMethod("Error", "String", "Object[]"));
        isErrorEnabledMethod = ModuleDefinition.Import(loggerType.FindMethod("get_IsErrorEnabled"));
        ErrorExceptionMethod = ModuleDefinition.Import(loggerType.FindMethod("Error", "String", "Exception"));
        FatalMethod = ModuleDefinition.Import(loggerType.FindMethod("Fatal", "String", "Object[]"));
        isFatalEnabledMethod = ModuleDefinition.Import(loggerType.FindMethod("get_IsFatalEnabled"));
        FatalExceptionMethod = ModuleDefinition.Import(loggerType.FindMethod("Fatal", "String", "Exception"));
        LoggerType = ModuleDefinition.Import(loggerType);
    }
Ejemplo n.º 26
0
    public static string GetName(TypeReference type)
    {
        if (type.IsNested)
            return GetName (type.DeclaringType) + "+" + type.Name;

        return type.Name;
    }
Ejemplo n.º 27
0
 public void CheckTypeReferenceForProperWinRTHome(TypeReference typeReference, string module)
 {
     ScopeReference scope = GetScopeReferenceOfType(typeReference);
     Assert.Equal(module, scope.Name.Value);
     int windowsRuntimeFlag = ((int)System.Reflection.AssemblyContentType.WindowsRuntime << 9);
     Assert.True((((int)scope.Flags) & windowsRuntimeFlag) == windowsRuntimeFlag);
 }
Ejemplo n.º 28
0
        public void DéfinirUnTypeRéférenceAvecEgalitéDeuxInstancesAyantLesMêmesPropriétés()
        {
            var valeur1 = new TypeReference(12);
            var valeur2 = new TypeReference(12);

            Check.That(valeur1).IsEqualTo(valeur2);
            Check.That(typeof(TypeReference).IsValueType).IsFalse();
        }
Ejemplo n.º 29
0
 TypeDefinition ToDefinition(TypeReference typeReference)
 {
     if (typeReference.IsDefinition)
     {
         return (TypeDefinition) typeReference;
     }
     return typeResolver.Resolve(typeReference);
 }
Ejemplo n.º 30
0
 internal static CilTypeReference Create(TypeReference typeReference, ref CilReaders readers, int token)
 {
     CilTypeReference type = new CilTypeReference();
     type._typeReference = typeReference;
     type._readers = readers;
     type._token = token;
     return type;
 }
Ejemplo n.º 31
0
 public static void Register(TypeReference dataType, MethodReference methodReference)
 {
     writeFuncs[dataType.FullName] = methodReference;
 }
Ejemplo n.º 32
0
 public VariableDefinition(string name, int index, MethodDefinition method, TypeReference variableType) :
     base(name, index, variableType)
 {
     m_method = method;
 }
Ejemplo n.º 33
0
 public AfterAsyncWeaveProcess(ILogger log, MethodDefinition target, InjectionDefinition injection) : base(log, target, injection)
 {
     _asyncResult = (_stateMachine.Fields.First(f => f.Name == "<>t__builder").FieldType as IGenericInstance)?.GenericArguments.FirstOrDefault();
 }
Ejemplo n.º 34
0
 public ParameterDefinition(string name, int seq, ParameterAttributes attrs, TypeReference paramType) : base(name, seq, paramType)
 {
     m_attributes = attrs;
 }
Ejemplo n.º 35
0
 public Instruction Create(OpCode opcode, TypeReference type)
 {
     return(Instruction.Create(opcode, type));
 }
 protected abstract void HandleMemberType(TypeReference memberType, string codeNamespace, StringBuilder sb = null);
Ejemplo n.º 37
0
        static MethodDefinition GenerateArraySegmentReadFunc(TypeReference variable, int recursionCount)
        {
            GenericInstanceType genericInstance = (GenericInstanceType)variable;
            TypeReference       elementType     = genericInstance.GenericArguments[0];

            MethodReference elementReadFunc = GetReadFunc(elementType, recursionCount + 1);

            if (elementReadFunc == null)
            {
                return(null);
            }

            string functionName = "_ReadArraySegment_" + variable.GetElementType().Name + "_";

            if (variable.DeclaringType != null)
            {
                functionName += variable.DeclaringType.Name;
            }
            else
            {
                functionName += "None";
            }

            // create new reader for this type
            MethodDefinition readerFunc = new MethodDefinition(functionName,
                                                               MethodAttributes.Public |
                                                               MethodAttributes.Static |
                                                               MethodAttributes.HideBySig,
                                                               variable);

            readerFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, Weaver.CurrentAssembly.MainModule.ImportReference(Weaver.NetworkReaderType)));

            // int lengh
            readerFunc.Body.Variables.Add(new VariableDefinition(Weaver.int32Type));
            // T[] array
            readerFunc.Body.Variables.Add(new VariableDefinition(elementType.MakeArrayType()));
            // int i;
            readerFunc.Body.Variables.Add(new VariableDefinition(Weaver.int32Type));
            readerFunc.Body.InitLocals = true;

            ILProcessor worker = readerFunc.Body.GetILProcessor();

            // int length = reader.ReadPackedInt32();
            worker.Append(worker.Create(OpCodes.Ldarg_0));
            worker.Append(worker.Create(OpCodes.Call, GetReadFunc(Weaver.int32Type)));
            worker.Append(worker.Create(OpCodes.Stloc_0));

            // T[] array = new int[length]
            worker.Append(worker.Create(OpCodes.Ldloc_0));
            worker.Append(worker.Create(OpCodes.Newarr, elementType));
            worker.Append(worker.Create(OpCodes.Stloc_1));

            // loop through array and deserialize each element
            // generates code like this
            // for (int i=0; i< length ; i++)
            // {
            //     value[i] = reader.ReadXXX();
            // }
            worker.Append(worker.Create(OpCodes.Ldc_I4_0));
            worker.Append(worker.Create(OpCodes.Stloc_2));
            Instruction labelHead = worker.Create(OpCodes.Nop);

            worker.Append(worker.Create(OpCodes.Br, labelHead));

            // loop body
            Instruction labelBody = worker.Create(OpCodes.Nop);

            worker.Append(labelBody);
            // value[i] = reader.ReadT();
            worker.Append(worker.Create(OpCodes.Ldloc_1));
            worker.Append(worker.Create(OpCodes.Ldloc_2));
            worker.Append(worker.Create(OpCodes.Ldelema, elementType));
            worker.Append(worker.Create(OpCodes.Ldarg_0));
            worker.Append(worker.Create(OpCodes.Call, elementReadFunc));
            worker.Append(worker.Create(OpCodes.Stobj, elementType));

            worker.Append(worker.Create(OpCodes.Ldloc_2));
            worker.Append(worker.Create(OpCodes.Ldc_I4_1));
            worker.Append(worker.Create(OpCodes.Add));
            worker.Append(worker.Create(OpCodes.Stloc_2));

            // loop while check
            worker.Append(labelHead);
            worker.Append(worker.Create(OpCodes.Ldloc_2));
            worker.Append(worker.Create(OpCodes.Ldloc_0));
            worker.Append(worker.Create(OpCodes.Blt, labelBody));

            // return new ArraySegment<T>(array);
            worker.Append(worker.Create(OpCodes.Ldloc_1));
            worker.Append(worker.Create(OpCodes.Newobj, Weaver.ArraySegmentConstructorReference.MakeHostInstanceGeneric(genericInstance)));
            worker.Append(worker.Create(OpCodes.Ret));
            return(readerFunc);
        }
        protected bool IsPublicServiceMethod(MethodDefinition method, out TypeReference requestType, out TypeReference responseType,
                                             out string requestParam)
        {
            if (method == null)
            {
                throw new ArgumentNullException(nameof(method));
            }

            responseType = null;
            requestType  = null;
            requestParam = null;

            if ((CecilUtils.FindAttr(method.CustomAttributes, "System.Web.Mvc", "NonActionAttribute") ??
                 CecilUtils.FindAttr(method.CustomAttributes, "Microsoft.AspNetCore.Mvc", "NonActionAttribute") ??
                 CecilUtils.FindAttr(method.CustomAttributes, "Serenity.ComponentModel", "ScriptSkipAttribute")) != null)
            {
                return(false);
            }

            if (!CecilUtils.IsSubclassOf(method.DeclaringType, "System.Web.Mvc", "Controller") &&
                !CecilUtils.IsSubclassOf(method.DeclaringType, "Microsoft.AspNetCore.Mvc", "Controller"))
            {
                return(false);
            }

            if (method.IsSpecialName && (method.Name.StartsWith("set_", StringComparison.Ordinal) || method.Name.StartsWith("get_", StringComparison.Ordinal)))
            {
                return(false);
            }

            var parameters = method.Parameters.Where(x => !x.ParameterType.Resolve().IsInterface).ToArray();

            if (parameters.Length > 1)
            {
                return(false);
            }

            if (parameters.Length == 1)
            {
                requestType = parameters[0].ParameterType;
                if (requestType.IsPrimitive || !CanHandleType(requestType.Resolve()))
                {
                    return(false);
                }
            }
            else
            {
                requestType = null;
            }

            requestParam = parameters.Length == 0 ? "request" : parameters[0].Name;

            responseType = method.ReturnType == null ? null : method.ReturnType;
            if (responseType != null &&
                responseType.IsGenericInstance &&
                (responseType as GenericInstanceType).ElementType.FullName.StartsWith("Serenity.Services.Result`1", StringComparison.Ordinal))
            {
                responseType = (responseType as GenericInstanceType).GenericArguments[0];
                return(true);
            }
            else if (responseType != null &&
                     responseType.IsGenericInstance &&
                     (responseType as GenericInstanceType).ElementType.FullName.StartsWith("System.Threading.Tasks.Task`1", StringComparison.Ordinal))
            {
                responseType = (responseType as GenericInstanceType).GenericArguments[0];
                return(true);
            }
            else if (CecilUtils.IsOrSubClassOf(responseType, "System.Web.Mvc", "ActionResult") ||
                     CecilUtils.IsOrSubClassOf(responseType, "Microsoft.AspNetCore.Mvc", "ActionResult"))
            {
                return(false);
            }
            else if (responseType == null || CecilUtils.IsVoid(responseType))
            {
                return(false);
            }

            return(true);
        }
        protected virtual string MakeFriendlyName(TypeReference type, string codeNamespace, StringBuilder sb = null)
        {
            sb = sb ?? this.sb;

            if (type.IsGenericInstance)
            {
                var name = type.Name;
                var idx  = name.IndexOf('`', StringComparison.Ordinal);
                if (idx >= 0)
                {
                    name = name.Substring(0, idx);
                }

                sb.Append(name);
                sb.Append('<');

                int i = 0;
                foreach (var argument in (type as GenericInstanceType).GenericArguments)
                {
                    if (i++ > 0)
                    {
                        sb.Append(", ");
                    }

                    HandleMemberType(argument, codeNamespace, sb);
                }

                sb.Append('>');

                return(name + "`" + (type as GenericInstanceType).GenericArguments.Count);
            }
            else if (type.HasGenericParameters)
            {
                var name = type.Name;
                var idx  = name.IndexOf('`', StringComparison.Ordinal);
                if (idx >= 0)
                {
                    name = name.Substring(0, idx);
                }

                sb.Append(name);
                sb.Append('<');

                int i = 0;
                foreach (var argument in type.GenericParameters)
                {
                    if (i++ > 0)
                    {
                        sb.Append(", ");
                    }

                    sb.Append(argument.Name);
                }

                sb.Append(">");

                return(name + "`" + type.GenericParameters.Count);
            }
            else
            {
                sb.Append(type.Name);
                return(type.Name);
            }
        }
Ejemplo n.º 40
0
 public static bool IsTypeOf(this TypeReference self, Type other) => self.FullName == other.FullName;
Ejemplo n.º 41
0
 public static MethodRefBuilder MethodByName(ModuleDefinition module, TypeReference typeRef, string methodName)
 => new MethodRefBuilder(module, typeRef, FindMethod(typeRef, methodName, null, null, null));
Ejemplo n.º 42
0
 public static string AssemblyQualifiedName(this TypeReference reference, bool withGenerics = false)
 {
     return(((withGenerics && reference.IsGenericInstance) ? reference.FullName : (string.IsNullOrWhiteSpace(reference.Namespace) ? reference.Name : reference.Namespace + '.' + reference.Name)) + ", " + reference.Resolve().Module.Assembly.FullName);
 }
Ejemplo n.º 43
0
 protected abstract bool TryConvertMap(IReferenceMap referenceMap, TypeReference elementType, object value, out object result);
Ejemplo n.º 44
0
 internal static void Register(TypeReference dataType, MethodReference methodReference)
 {
     readFuncs[dataType.FullName] = methodReference;
 }
Ejemplo n.º 45
0
        /// <summary>
        /// Returns whether the project contains a given type.
        /// </summary>
        public bool Contains(TypeReference type)
        {
            string name = type.GetScopeName();

            return(assemblyMap.ContainsKey(name));
        }
Ejemplo n.º 46
0
        static MethodDefinition GenerateArrayReadFunc(TypeReference variable, int recursionCount)
        {
            if (!variable.IsArrayType())
            {
                Weaver.Error($"{variable} is an unsupported type. Jagged and multidimensional arrays are not supported");
                return(null);
            }

            TypeReference   elementType     = variable.GetElementType();
            MethodReference elementReadFunc = GetReadFunc(elementType, recursionCount + 1);

            if (elementReadFunc == null)
            {
                return(null);
            }

            string functionName = "_ReadArray" + variable.GetElementType().Name + "_";

            if (variable.DeclaringType != null)
            {
                functionName += variable.DeclaringType.Name;
            }
            else
            {
                functionName += "None";
            }

            // create new reader for this type
            MethodDefinition readerFunc = new MethodDefinition(functionName,
                                                               MethodAttributes.Public |
                                                               MethodAttributes.Static |
                                                               MethodAttributes.HideBySig,
                                                               variable);

            readerFunc.Parameters.Add(new ParameterDefinition("reader", ParameterAttributes.None, Weaver.CurrentAssembly.MainModule.ImportReference(Weaver.NetworkReaderType)));

            readerFunc.Body.Variables.Add(new VariableDefinition(Weaver.int32Type));
            readerFunc.Body.Variables.Add(new VariableDefinition(variable));
            readerFunc.Body.Variables.Add(new VariableDefinition(Weaver.int32Type));
            readerFunc.Body.InitLocals = true;

            ILProcessor worker = readerFunc.Body.GetILProcessor();

            // int length = reader.ReadPackedInt32();
            worker.Append(worker.Create(OpCodes.Ldarg_0));
            worker.Append(worker.Create(OpCodes.Call, GetReadFunc(Weaver.int32Type)));
            worker.Append(worker.Create(OpCodes.Stloc_0));

            // if (length < 0) {
            //    return null
            // }
            worker.Append(worker.Create(OpCodes.Ldloc_0));
            worker.Append(worker.Create(OpCodes.Ldc_I4_0));
            Instruction labelEmptyArray = worker.Create(OpCodes.Nop);

            worker.Append(worker.Create(OpCodes.Bge, labelEmptyArray));
            // return null
            worker.Append(worker.Create(OpCodes.Ldnull));
            worker.Append(worker.Create(OpCodes.Ret));
            worker.Append(labelEmptyArray);

            // T value = new T[length];
            worker.Append(worker.Create(OpCodes.Ldloc_0));
            worker.Append(worker.Create(OpCodes.Newarr, variable.GetElementType()));
            worker.Append(worker.Create(OpCodes.Stloc_1));

            // for (int i=0; i< length ; i++) {
            worker.Append(worker.Create(OpCodes.Ldc_I4_0));
            worker.Append(worker.Create(OpCodes.Stloc_2));
            Instruction labelHead = worker.Create(OpCodes.Nop);

            worker.Append(worker.Create(OpCodes.Br, labelHead));

            // loop body
            Instruction labelBody = worker.Create(OpCodes.Nop);

            worker.Append(labelBody);
            // value[i] = reader.ReadT();
            worker.Append(worker.Create(OpCodes.Ldloc_1));
            worker.Append(worker.Create(OpCodes.Ldloc_2));
            worker.Append(worker.Create(OpCodes.Ldelema, variable.GetElementType()));
            worker.Append(worker.Create(OpCodes.Ldarg_0));
            worker.Append(worker.Create(OpCodes.Call, elementReadFunc));
            worker.Append(worker.Create(OpCodes.Stobj, variable.GetElementType()));

            worker.Append(worker.Create(OpCodes.Ldloc_2));
            worker.Append(worker.Create(OpCodes.Ldc_I4_1));
            worker.Append(worker.Create(OpCodes.Add));
            worker.Append(worker.Create(OpCodes.Stloc_2));

            // loop while check
            worker.Append(labelHead);
            worker.Append(worker.Create(OpCodes.Ldloc_2));
            worker.Append(worker.Create(OpCodes.Ldloc_0));
            worker.Append(worker.Create(OpCodes.Blt, labelBody));

            // return value;
            worker.Append(worker.Create(OpCodes.Ldloc_1));
            worker.Append(worker.Create(OpCodes.Ret));
            return(readerFunc);
        }
Ejemplo n.º 47
0
 public ParameterDefinition(TypeReference paramType) :
     this(string.Empty, -1, (ParameterAttributes)0, paramType)
 {
 }
Ejemplo n.º 48
0
        void InitParameters()
        {
            parameters = new List <IType>();
            foreach (var i in def.Parameters)
            {
                IType         type    = null;
                bool          isByRef = false;
                bool          isArray = false;
                int           rank    = 1;
                TypeReference pt      = i.ParameterType;
                if (pt.IsByReference)
                {
                    isByRef = true;
                    pt      = ((ByReferenceType)pt).ElementType;
                }
                if (pt.IsArray)
                {
                    isArray = true;
                    rank    = ((ArrayType)pt).Rank;
                    pt      = ((ArrayType)pt).ElementType;
                }
                if (pt.IsGenericParameter)
                {
                    type = FindGenericArgument(pt.Name);
                    if (type == null && def.HasGenericParameters)
                    {
                        bool found = false;
                        foreach (var j in def.GenericParameters)
                        {
                            if (j.Name == pt.Name)
                            {
                                found = true;
                                break;
                            }
                        }
                        if (found)
                        {
                            type = new ILGenericParameterType(pt.Name);
                        }
                        else
                        {
                            throw new NotSupportedException("Cannot find Generic Parameter " + pt.Name + " in " + def.FullName);
                        }
                    }
                }
                else
                {
                    type = appdomain.GetType(pt, declaringType, this);
                }

                if (isByRef)
                {
                    type = type.MakeByRefType();
                }
                if (isArray)
                {
                    type = type.MakeArrayType(rank);
                }
                parameters.Add(type);
            }
        }
Ejemplo n.º 49
0
 public void Emit(OpCode opcode, TypeReference type)
 {
     Append(Create(opcode, type));
 }
        internal static int GetTypeIndex(TypeReference type)
        {
            V_0 = type.Resolve();
            if (V_0 != null && V_0.get_IsEnum() && V_0 != null)
            {
                V_1 = null;
                V_2 = V_0.get_Fields().GetEnumerator();
                try
                {
                    while (V_2.MoveNext())
                    {
                        V_3 = V_2.get_Current();
                        if (!String.op_Equality(V_3.get_Name(), "value__"))
                        {
                            continue;
                        }
                        V_1 = V_3;
                        goto Label0;
                    }
                }
                finally
                {
                    V_2.Dispose();
                }
Label0:
                type = V_1.get_FieldType();
            }
            V_4 = type.get_FullName();
            if (V_4 != null)
            {
                if (String.op_Equality(V_4, "System.Boolean"))
                {
                    return(0);
                }
                if (String.op_Equality(V_4, "System.SByte") || String.op_Equality(V_4, "System.Byte"))
                {
                    return(1);
                }
                if (String.op_Equality(V_4, "System.Char") || String.op_Equality(V_4, "System.Int16") || String.op_Equality(V_4, "System.UInt16"))
                {
                    return(2);
                }
                if (String.op_Equality(V_4, "System.Int32") || String.op_Equality(V_4, "System.UInt32"))
                {
                    return(3);
                }
                if (String.op_Equality(V_4, "System.IntPtr") || String.op_Equality(V_4, "System.Int64") || String.op_Equality(V_4, "System.UInt64"))
                {
                    return(4);
                }
                if (String.op_Equality(V_4, "System.Single"))
                {
                    return(5);
                }
                if (String.op_Equality(V_4, "System.Double"))
                {
                    return(6);
                }
            }
            throw new NotSupportedException("Not supported type.");
        }
Ejemplo n.º 51
0
 public VariableDefinition(TypeReference variableType) : base(variableType)
 {
 }
Ejemplo n.º 52
0
 protected override StringBuilder AppendGenericTypeConstraints(StringBuilder buf, TypeReference type)
 {
     if (type.GenericParameters.Count == 0)
     {
         return(buf);
     }
     return(AppendConstraints(buf, type.GenericParameters));
 }
Ejemplo n.º 53
0
        /// <summary>
        /// Creates a valid <see cref="JsValue"/> instance from any <see cref="Object"/> instance
        /// </summary>
        /// <param name="engine"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public static JsValue FromObject(Engine engine, object value)
        {
            if (value == null)
            {
                return(Null);
            }

            foreach (var converter in engine.Options._ObjectConverters)
            {
                JsValue result;
                if (converter.TryConvert(value, out result))
                {
                    return(result);
                }
            }

            var valueType = value.GetType();

            var typeMappers = Engine.TypeMappers;

            Func <Engine, object, JsValue> typeMapper;

            if (typeMappers.TryGetValue(valueType, out typeMapper))
            {
                return(typeMapper(engine, value));
            }

            // if an ObjectInstance is passed directly, use it as is
            var instance = value as ObjectInstance;

            if (instance != null)
            {
                // Learn conversion.
                // Learn conversion, racy, worst case we'll try again later
                Interlocked.CompareExchange(ref Engine.TypeMappers, new Dictionary <Type, Func <Engine, object, JsValue> >(typeMappers)
                {
                    [valueType] = (Engine e, object v) => new JsValue((ObjectInstance)v)
                }, typeMappers);
                return(new JsValue(instance));
            }

            var type = value as Type;

            if (type != null)
            {
                var typeReference = TypeReference.CreateTypeReference(engine, type);
                return(new JsValue(typeReference));
            }

            var a = value as System.Array;

            if (a != null)
            {
                Func <Engine, object, JsValue> convert = (Engine e, object v) =>
                {
                    var array = (System.Array)v;

                    var jsArray = engine.Array.Construct(Arguments.Empty);
                    foreach (var item in array)
                    {
                        var jsItem = JsValue.FromObject(engine, item);
                        engine.Array.PrototypeObject.Push(jsArray, Arguments.From(jsItem));
                    }

                    return(jsArray);
                };
                // racy, we don't care, worst case we'll catch up later
                Interlocked.CompareExchange(ref Engine.TypeMappers, new Dictionary <Type, Func <Engine, object, JsValue> >(typeMappers)
                {
                    [valueType] = convert
                }, typeMappers);
                return(convert(engine, a));
            }

            var d = value as Delegate;

            if (d != null)
            {
                return(new DelegateWrapper(engine, d));
            }

            if (value.GetType().IsEnum())
            {
                return(new JsValue(value.ToString()));
            }

            if (IsList(value.GetType()))
            {
                return(new ObjectListWrapper(engine, value));
            }

            // if no known type could be guessed, wrap it as an ObjectInstance
            return(new ObjectWrapper(engine, value));
        }
Ejemplo n.º 54
0
        protected override string GetTypeDeclaration(TypeDefinition type)
        {
            string visibility = GetTypeVisibility(type.Attributes);

            if (visibility == null)
            {
                return(null);
            }

            StringBuilder buf = new StringBuilder();

            buf.Append(visibility);
            buf.Append(" ");

            MemberFormatter full = new CSharpFullMemberFormatter(this.TypeMap);

            if (DocUtils.IsDelegate(type))
            {
                buf.Append("delegate ");
                MethodDefinition invoke = type.GetMethod("Invoke");
                buf.Append(full.GetName(invoke.ReturnType, new DynamicParserContext(invoke.MethodReturnType))).Append(" ");
                buf.Append(GetName(type));
                AppendParameters(buf, invoke, invoke.Parameters);
                AppendGenericTypeConstraints(buf, type);
                buf.Append(";");

                return(buf.ToString());
            }

            if (type.IsAbstract && !type.IsInterface)
            {
                buf.Append("abstract ");
            }
            if (type.IsSealed && !DocUtils.IsDelegate(type) && !type.IsValueType)
            {
                buf.Append("sealed ");
            }
            buf.Replace("abstract sealed", "static");

            buf.Append(GetTypeKind(type));
            buf.Append(" ");
            buf.Append(GetCSharpType(type.FullName) == null
                    ? GetName(type)
                    : type.Name);

            if (!type.IsEnum)
            {
                TypeReference basetype = type.BaseType;
                if (basetype != null && basetype.FullName == "System.Object" || type.IsValueType)   // FIXME
                {
                    basetype = null;
                }

                List <string> interface_names = DocUtils.GetUserImplementedInterfaces(type)
                                                .Select(iface => full.GetName(iface))
                                                .OrderBy(s => s)
                                                .ToList();

                if (basetype != null || interface_names.Count > 0)
                {
                    buf.Append(" : ");
                }

                if (basetype != null)
                {
                    buf.Append(full.GetName(basetype));
                    if (interface_names.Count > 0)
                    {
                        buf.Append(", ");
                    }
                }

                for (int i = 0; i < interface_names.Count; i++)
                {
                    if (i != 0)
                    {
                        buf.Append(", ");
                    }
                    buf.Append(interface_names[i]);
                }
                AppendGenericTypeConstraints(buf, type);
            }

            return(buf.ToString());
        }
Ejemplo n.º 55
0
 public static MethodRefBuilder MethodByNameAndSignature(ModuleDefinition module, TypeReference typeRef, string methodName, int?genericArity, TypeRefBuilder?returnType, IReadOnlyList <TypeRefBuilder> paramTypes)
 => new MethodRefBuilder(module, typeRef, FindMethod(typeRef, methodName, genericArity, returnType, paramTypes ?? throw new ArgumentNullException(nameof(paramTypes))));
Ejemplo n.º 56
0
 /// <summary>
 /// A cecil type reference will be directed to this method.
 /// </summary>
 /// <param name="item">Cecil reference.</param>
 /// <param name="resolvedItem">Output parameter that will be populated with the resolved cecil definition.</param>
 /// <returns><c>true</c></returns>
 private static bool TryResolve(TypeReference item, out object resolvedItem)
 {
     resolvedItem = item.Resolve();
     return(true);
 }
Ejemplo n.º 57
0
        public static MethodReference GetWriteFunc(TypeReference variable, int recursionCount = 0)
        {
            if (writeFuncs.TryGetValue(variable.FullName, out MethodReference foundFunc))
            {
                return(foundFunc);
            }

            MethodDefinition newWriterFunc;

            // Arrays are special,  if we resolve them, we get the element type,
            // so the following ifs might choke on it for scriptable objects
            // or other objects that require a custom serializer
            // thus check if it is an array and skip all the checks.
            if (variable.IsArray)
            {
                newWriterFunc = GenerateArrayWriteFunc(variable, recursionCount);
                RegisterWriteFunc(variable.FullName, newWriterFunc);
                return(newWriterFunc);
            }

            if (variable.IsByReference)
            {
                // error??
                Weaver.Error($"Cannot pass {variable.Name} by reference", variable);
                return(null);
            }
            TypeDefinition td = variable.Resolve();

            if (td == null)
            {
                Weaver.Error($"{variable.Name} is not a supported type. Use a supported type or provide a custom writer", variable);
                return(null);
            }
            if (td.IsDerivedFrom(Weaver.ComponentType))
            {
                Weaver.Error($"Cannot generate writer for component type {variable.Name}. Use a supported type or provide a custom writer", variable);
                return(null);
            }
            if (variable.FullName == Weaver.ObjectType.FullName)
            {
                Weaver.Error($"Cannot generate writer for {variable.Name}. Use a supported type or provide a custom writer", variable);
                return(null);
            }
            if (variable.FullName == Weaver.ScriptableObjectType.FullName)
            {
                Weaver.Error($"Cannot generate writer for {variable.Name}. Use a supported type or provide a custom writer", variable);
                return(null);
            }
            if (td.HasGenericParameters && !td.FullName.StartsWith("System.ArraySegment`1", System.StringComparison.Ordinal))
            {
                Weaver.Error($"Cannot generate writer for generic type {variable.Name}. Use a supported type or provide a custom writer", variable);
                return(null);
            }
            if (td.IsInterface)
            {
                Weaver.Error($"Cannot generate writer for interface {variable.Name}. Use a supported type or provide a custom writer", variable);
                return(null);
            }

            if (variable.Resolve().IsEnum)
            {
                return(GetWriteFunc(variable.Resolve().GetEnumUnderlyingType(), recursionCount));
            }
            else if (variable.FullName.StartsWith("System.ArraySegment`1", System.StringComparison.Ordinal))
            {
                newWriterFunc = GenerateArraySegmentWriteFunc(variable, recursionCount);
            }
            else
            {
                newWriterFunc = GenerateClassOrStructWriterFunction(variable, recursionCount);
            }

            if (newWriterFunc == null)
            {
                return(null);
            }

            RegisterWriteFunc(variable.FullName, newWriterFunc);
            return(newWriterFunc);
        }
Ejemplo n.º 58
0
        static MethodDefinition GenerateClassOrStructWriterFunction(TypeReference variable, int recursionCount)
        {
            if (recursionCount > MaxRecursionCount)
            {
                Weaver.Error($"{variable.Name} can't be serialized because it references itself", variable);
                return(null);
            }

            string functionName = "_Write" + variable.Name + "_";

            if (variable.DeclaringType != null)
            {
                functionName += variable.DeclaringType.Name;
            }
            else
            {
                functionName += "None";
            }
            // create new writer for this type
            MethodDefinition writerFunc = new MethodDefinition(functionName,
                                                               MethodAttributes.Public |
                                                               MethodAttributes.Static |
                                                               MethodAttributes.HideBySig,
                                                               Weaver.voidType);

            writerFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, Weaver.CurrentAssembly.MainModule.ImportReference(Weaver.NetworkWriterType)));
            writerFunc.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, Weaver.CurrentAssembly.MainModule.ImportReference(variable)));

            ILProcessor worker = writerFunc.Body.GetILProcessor();

            uint fields = 0;

            foreach (FieldDefinition field in variable.Resolve().Fields)
            {
                if (field.IsStatic || field.IsPrivate)
                {
                    continue;
                }

                if (field.IsNotSerialized)
                {
                    continue;
                }

                MethodReference writeFunc = GetWriteFunc(field.FieldType, recursionCount + 1);
                if (writeFunc != null)
                {
                    FieldReference fieldRef = Weaver.CurrentAssembly.MainModule.ImportReference(field);

                    fields++;
                    worker.Append(worker.Create(OpCodes.Ldarg_0));
                    worker.Append(worker.Create(OpCodes.Ldarg_1));
                    worker.Append(worker.Create(OpCodes.Ldfld, fieldRef));
                    worker.Append(worker.Create(OpCodes.Call, writeFunc));
                }
                else
                {
                    Weaver.Error($"{field.Name} has unsupported type. Use a type supported by Mirror instead", field);
                    return(null);
                }
            }
            if (fields == 0)
            {
                Log.Warning($" {variable} has no no public or non-static fields to serialize");
            }
            worker.Append(worker.Create(OpCodes.Ret));
            return(writerFunc);
        }
Ejemplo n.º 59
0
        static MethodDefinition GenerateArrayWriteFunc(TypeReference variable, int recursionCount)
        {
            if (!variable.IsArrayType())
            {
                Weaver.Error($"{variable.Name} is an unsupported type. Jagged and multidimensional arrays are not supported", variable);
                return(null);
            }

            TypeReference   elementType      = variable.GetElementType();
            MethodReference elementWriteFunc = GetWriteFunc(elementType, recursionCount + 1);

            if (elementWriteFunc == null)
            {
                return(null);
            }

            string functionName = "_WriteArray" + variable.GetElementType().Name + "_";

            if (variable.DeclaringType != null)
            {
                functionName += variable.DeclaringType.Name;
            }
            else
            {
                functionName += "None";
            }

            // create new writer for this type
            MethodDefinition writerFunc = new MethodDefinition(functionName,
                                                               MethodAttributes.Public |
                                                               MethodAttributes.Static |
                                                               MethodAttributes.HideBySig,
                                                               Weaver.voidType);

            writerFunc.Parameters.Add(new ParameterDefinition("writer", ParameterAttributes.None, Weaver.CurrentAssembly.MainModule.ImportReference(Weaver.NetworkWriterType)));
            writerFunc.Parameters.Add(new ParameterDefinition("value", ParameterAttributes.None, Weaver.CurrentAssembly.MainModule.ImportReference(variable)));

            writerFunc.Body.Variables.Add(new VariableDefinition(Weaver.int32Type));
            writerFunc.Body.Variables.Add(new VariableDefinition(Weaver.int32Type));
            writerFunc.Body.InitLocals = true;

            ILProcessor worker = writerFunc.Body.GetILProcessor();

            // if (value == null)
            // {
            //     writer.WritePackedInt32(-1);
            //     return;
            // }
            Instruction labelNull = worker.Create(OpCodes.Nop);

            worker.Append(worker.Create(OpCodes.Ldarg_1));
            worker.Append(worker.Create(OpCodes.Brtrue, labelNull));

            worker.Append(worker.Create(OpCodes.Ldarg_0));
            worker.Append(worker.Create(OpCodes.Ldc_I4_M1));
            worker.Append(worker.Create(OpCodes.Call, GetWriteFunc(Weaver.int32Type)));
            worker.Append(worker.Create(OpCodes.Ret));

            // int length = value.Length;
            worker.Append(labelNull);
            worker.Append(worker.Create(OpCodes.Ldarg_1));
            worker.Append(worker.Create(OpCodes.Ldlen));
            worker.Append(worker.Create(OpCodes.Stloc_0));

            // writer.WritePackedInt32(length);
            worker.Append(worker.Create(OpCodes.Ldarg_0));
            worker.Append(worker.Create(OpCodes.Ldloc_0));
            worker.Append(worker.Create(OpCodes.Call, GetWriteFunc(Weaver.int32Type)));

            // for (int i=0; i< value.length; i++) {
            worker.Append(worker.Create(OpCodes.Ldc_I4_0));
            worker.Append(worker.Create(OpCodes.Stloc_1));
            Instruction labelHead = worker.Create(OpCodes.Nop);

            worker.Append(worker.Create(OpCodes.Br, labelHead));

            // loop body
            Instruction labelBody = worker.Create(OpCodes.Nop);

            worker.Append(labelBody);
            // writer.Write(value[i]);
            worker.Append(worker.Create(OpCodes.Ldarg_0));
            worker.Append(worker.Create(OpCodes.Ldarg_1));
            worker.Append(worker.Create(OpCodes.Ldloc_1));
            worker.Append(worker.Create(OpCodes.Ldelema, variable.GetElementType()));
            worker.Append(worker.Create(OpCodes.Ldobj, variable.GetElementType()));
            worker.Append(worker.Create(OpCodes.Call, elementWriteFunc));

            worker.Append(worker.Create(OpCodes.Ldloc_1));
            worker.Append(worker.Create(OpCodes.Ldc_I4_1));
            worker.Append(worker.Create(OpCodes.Add));
            worker.Append(worker.Create(OpCodes.Stloc_1));

            // end for loop
            worker.Append(labelHead);
            worker.Append(worker.Create(OpCodes.Ldloc_1));
            worker.Append(worker.Create(OpCodes.Ldarg_1));
            worker.Append(worker.Create(OpCodes.Ldlen));
            worker.Append(worker.Create(OpCodes.Conv_I4));
            worker.Append(worker.Create(OpCodes.Blt, labelBody));

            // return
            worker.Append(worker.Create(OpCodes.Ret));
            return(writerFunc);
        }
Ejemplo n.º 60
0
 /// <summary>
 /// 初始化IL类型
 /// </summary>
 /// <param name="def">MONO返回的类型定义</param>
 /// <param name="domain">ILdomain</param>
 public ILType(TypeReference def, Runtime.Enviorment.AppDomain domain)
 {
     this.typeRef = def;
     RetriveDefinitino(def);
     appdomain = domain;
 }