// 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 ("*"); }
public VariableDefinition(string name, int index, MethodDefinition method, TypeReference variable) : this(variable) { m_name = name; m_index = index; m_method = method; }
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"); } }
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)); }
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)); }
public FieldDefinition(ClassDefinition owner, string name, TypeReference fieldType) : this() { Owner = owner; Name = name; Type = fieldType; }
//===================================================================== /// <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; }
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")); }
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(); }
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); } }
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; }
internal void AddAppliesToType(string typeName) { TypeReference item = new TypeReference { name = typeName }; this.referenceList.Add(item); }
//===================================================================== /// <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; }
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; }
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); }
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; }
internal void AddAppliesToType(string typeName) { TypeReference tr = new TypeReference(); tr.name = typeName; this.referenceList.Add(tr); }
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(); }
/// <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)); }
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); }
public static string GetName(TypeReference type) { if (type.IsNested) return GetName (type.DeclaringType) + "+" + type.Name; return type.Name; }
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); }
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(); }
TypeDefinition ToDefinition(TypeReference typeReference) { if (typeReference.IsDefinition) { return (TypeDefinition) typeReference; } return typeResolver.Resolve(typeReference); }
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; }
public static void Register(TypeReference dataType, MethodReference methodReference) { writeFuncs[dataType.FullName] = methodReference; }
public VariableDefinition(string name, int index, MethodDefinition method, TypeReference variableType) : base(name, index, variableType) { m_method = method; }
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(); }
public ParameterDefinition(string name, int seq, ParameterAttributes attrs, TypeReference paramType) : base(name, seq, paramType) { m_attributes = attrs; }
public Instruction Create(OpCode opcode, TypeReference type) { return(Instruction.Create(opcode, type)); }
protected abstract void HandleMemberType(TypeReference memberType, string codeNamespace, StringBuilder sb = null);
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); } }
public static bool IsTypeOf(this TypeReference self, Type other) => self.FullName == other.FullName;
public static MethodRefBuilder MethodByName(ModuleDefinition module, TypeReference typeRef, string methodName) => new MethodRefBuilder(module, typeRef, FindMethod(typeRef, methodName, null, null, null));
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); }
protected abstract bool TryConvertMap(IReferenceMap referenceMap, TypeReference elementType, object value, out object result);
internal static void Register(TypeReference dataType, MethodReference methodReference) { readFuncs[dataType.FullName] = methodReference; }
/// <summary> /// Returns whether the project contains a given type. /// </summary> public bool Contains(TypeReference type) { string name = type.GetScopeName(); return(assemblyMap.ContainsKey(name)); }
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); }
public ParameterDefinition(TypeReference paramType) : this(string.Empty, -1, (ParameterAttributes)0, paramType) { }
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); } }
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."); }
public VariableDefinition(TypeReference variableType) : base(variableType) { }
protected override StringBuilder AppendGenericTypeConstraints(StringBuilder buf, TypeReference type) { if (type.GenericParameters.Count == 0) { return(buf); } return(AppendConstraints(buf, type.GenericParameters)); }
/// <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)); }
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()); }
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))));
/// <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); }
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); }
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); }
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); }
/// <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; }