public static bool GetPrimitives(Type containerType, Type type, out MethodInfo writer, out MethodInfo reader) { if (type.IsEnum) type = Enum.GetUnderlyingType(type); if (type.IsGenericType == false) { writer = containerType.GetMethod("WritePrimitive", BindingFlags.Static | BindingFlags.Public | BindingFlags.ExactBinding, null, new Type[] { typeof(Stream), type }, null); reader = containerType.GetMethod("ReadPrimitive", BindingFlags.Static | BindingFlags.Public | BindingFlags.ExactBinding, null, new Type[] { typeof(Stream), type.MakeByRefType() }, null); } else { var genType = type.GetGenericTypeDefinition(); writer = GetGenWriter(containerType, genType); reader = GetGenReader(containerType, genType); } if (writer == null && reader == null) return false; else if (writer != null && reader != null) return true; else throw new InvalidOperationException(String.Format("Missing a {0}Primitive() for {1}", reader == null ? "Read" : "Write", type.FullName)); }
private static void InitializeTypes(Action<string> errorHandler) { if (_typesInitialized) { return; } try { Assembly extensionManagerAssembly = AppDomain.CurrentDomain.GetAssemblies() .First(a => a.FullName.StartsWith("Microsoft.VisualStudio.ExtensionManager,")); _sVsExtensionManagerType = extensionManagerAssembly.GetType("Microsoft.VisualStudio.ExtensionManager.SVsExtensionManager"); _iVsExtensionManagerType = extensionManagerAssembly.GetType("Microsoft.VisualStudio.ExtensionManager.IVsExtensionManager"); _iInstalledExtensionType = extensionManagerAssembly.GetType("Microsoft.VisualStudio.ExtensionManager.IInstalledExtension"); _tryGetInstalledExtensionMethod = _iVsExtensionManagerType.GetMethod("TryGetInstalledExtension", new[] { typeof(string), _iInstalledExtensionType.MakeByRefType() }); _installPathProperty = _iInstalledExtensionType.GetProperty("InstallPath", typeof(string)); if (_installPathProperty == null || _tryGetInstalledExtensionMethod == null || _sVsExtensionManagerType == null) { throw new Exception(); } _typesInitialized = true; } catch { // if any of the types or methods cannot be loaded throw an error. this indicates that some API in // Microsoft.VisualStudio.ExtensionManager got changed. errorHandler(VsResources.PreinstalledPackages_ExtensionManagerError); } }
public static MethodBuilder GenerateStaticDeserializerStub(TypeBuilder tb, Type type) { var mb = tb.DefineMethod("Deserialize", MethodAttributes.Public | MethodAttributes.Static, null, new Type[] { typeof(Stream), type.MakeByRefType() }); mb.DefineParameter(1, ParameterAttributes.None, "stream"); mb.DefineParameter(2, ParameterAttributes.Out, "value"); return mb; }
private static Tuple<MethodInfo, Redirector> RedirectMethod(Type targetType, MethodInfo detour, bool reverse) { var parameters = detour.GetParameters(); Type[] types; if (parameters.Length > 0 && ( (!targetType.IsValueType && parameters[0].ParameterType == targetType) || (targetType.IsValueType && parameters[0].ParameterType == targetType.MakeByRefType()))) { types = parameters.Skip(1).Select(p => p.ParameterType).ToArray(); } else { types = parameters.Select(p => p.ParameterType).ToArray(); } MethodInfo originalMethod = originalMethod = targetType.GetMethod(detour.Name, MethodFlags, null, types, null); if (originalMethod == null && detour.Name.EndsWith("Alt")) { originalMethod = targetType.GetMethod(detour.Name.Substring(0, detour.Name.Length - 3), MethodFlags, null, types, null); } var redirector = reverse ? new Redirector(detour, originalMethod) : new Redirector(originalMethod, detour); redirector.Apply(); return Tuple.New(originalMethod, redirector); }
static DynamicMethod GenerateDynamicDeserializerStub(Type type) { var dm = new DynamicMethod("Deserialize", null, new Type[] { typeof(Stream), type.MakeByRefType() }, typeof(Serializer), true); dm.DefineParameter(1, ParameterAttributes.None, "stream"); dm.DefineParameter(2, ParameterAttributes.Out, "value"); return dm; }
public static Type MakeByRef (Type t) { var mt = t as MetadataType; if (mt != null) { mt.m_isByRef = true; return mt; } return t.MakeByRefType (); }
/// <summary> /// Initializes a new instance of the <see cref="TrampolineParameter"/> class. /// </summary> /// <param name="type">The type of the parameter.</param> /// <param name="flags">Flags specifying the behavior of the parameter.</param> public TrampolineParameter(Type type, TrampolineParameterFlags flags) { if (type == null) throw new ArgumentNullException("type"); if (flags.HasFlag(TrampolineParameterFlags.Reference)) Type = type.MakeByRefType(); else Type = type; }
public void GetStaticMethods(Type type, out MethodInfo writer, out MethodInfo reader) { writer = typeof(CustomSerializers).GetMethod("WritePrimitive", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.ExactBinding, null, new Type[] { typeof(Stream), type }, null); reader = typeof(CustomSerializers).GetMethod("ReadPrimitive", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.ExactBinding, null, new Type[] { typeof(Stream), type.MakeByRefType() }, null); }
public object Parse(Type type, XObject config, bool isAssignableTypeAllowed, XmlLocation childLocation, IContext context) { var value = config.Value(); var m = type.GetMethod("TryParse", new Type[] { typeof(string), type.MakeByRefType() }); object[] args = { value, null }; var r = (bool)m.Invoke(null, args); if (!r) throw new TypeCastException(value, type, config); return args[1]; }
/// <summary> /// Class constructor. /// </summary> public ReflectionOptimizer(System.Type mappedType, IGetter[] getters, ISetter[] setters) { // save off references this.mappedType = mappedType; typeOfThis = mappedType.IsValueType ? mappedType.MakeByRefType() : mappedType; //this.getters = getters; //this.setters = setters; GetPropertyValuesInvoker getInvoker = GenerateGetPropertyValuesMethod(getters); SetPropertyValuesInvoker setInvoker = GenerateSetPropertyValuesMethod(setters); accessOptimizer = new AccessOptimizer(getInvoker, setInvoker, getters, setters); createInstanceMethod = CreateCreateInstanceMethod(mappedType); }
/// <summary> /// Tries to convert string to given type if TryParse method exists in the type /// </summary> /// <param name="str"></param> /// <param name="t"></param> /// <param name="res"></param> /// <returns>TryParse was present && string was successfully parsed</returns> public static bool TryTryParse(string str, Type t, out object res) { var parseMethod = t.GetMethod("TryParse", new Type[] { typeof(string), t.MakeByRefType() }); if (parseMethod != null) { object objectArgument = null; object[] tryParseParams = new object[] { str, objectArgument }; if ((bool)parseMethod.Invoke(t, tryParseParams)) { res = Convert.ChangeType(tryParseParams[1], t); return true; } } res = null; return false; }
public static Tuple<MethodInfo, RedirectCallsState> RedirectMethod(Type targetType, MethodInfo detour) { var parameters = detour.GetParameters(); Type[] types; if (parameters.Length > 0 && ( (!targetType.IsValueType && parameters[0].ParameterType == targetType) || (targetType.IsValueType && parameters[0].ParameterType == targetType.MakeByRefType()))){ types = parameters.Skip(1).Select(p => p.ParameterType).ToArray(); } else { types = parameters.Select(p => p.ParameterType).ToArray(); } var originalMethod = targetType.GetMethod(detour.Name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static, null, types, null); var redirectCallsState = RedirectionHelper.RedirectCalls(originalMethod, detour); return Tuple.New(originalMethod, redirectCallsState); }
static MethodBuilder GenerateDeserializerClass(TypeBuilder typeBuilder, Type objType, Type ownerType = null) { MethodBuilder method; var suffix = ownerType == objType ? "Method" : string.Empty; var key = objType.FullName + suffix; var methodPrefix = objType.Name + suffix; if (ReaderMethodBuilders.TryGetValue(key, out method)) return method; var methodName = String.Intern("Read") + methodPrefix; method = typeBuilder.DefineMethod(methodName, MethodAttribute, typeof(void), new[] { objType.IsValueType ? objType.MakeByRefType() : objType, ByteArrayType, typeof(int).MakeByRefType() }); ReaderMethodBuilders[key] = method; var methodIL = method.GetILGenerator(); WriteDeserializerClass(typeBuilder, methodIL, objType, tag: 0, setMethod: null, callerType: objType); methodIL.Emit(OpCodes.Ret); return method; }
/// <summary> /// Class constructor. /// </summary> public ReflectionOptimizer( System.Type mappedType, IGetter[] getters, ISetter[] setters) { // save off references this.mappedType = mappedType; this.typeOfThis = mappedType.IsValueType ? mappedType.MakeByRefType() : mappedType; //this.getters = getters; //this.setters = setters; GetPropertyValuesInvoker getInvoker = GenerateGetPropertyValuesMethod(getters); SetPropertyValuesInvoker setInvoker = GenerateSetPropertyValuesMethod(getters, setters); this.accessOptimizer = new AccessOptimizer( getInvoker, setInvoker, getters, setters); this.createInstanceMethod = CreateCreateInstanceMethod(mappedType); }
public override bool IsMatched(MethodInfo method, string id, Type testedType = null) { if (!base.IsMatched(method, id)) { return false; } bool isSignatureMatches; var parameters = method.GetParameters(); if (testedType == null) { isSignatureMatches = (parameters.Count() == 0); } else { isSignatureMatches = (parameters.Count() == 1 && parameters.First().ParameterType.IsByRef && parameters.First().ParameterType == testedType.MakeByRefType()); } return isSignatureMatches && method.ReturnType == typeof(void); }
/// <summary> /// Class constructor. /// </summary> public ReflectionOptimizer( System.Type mappedType, IGetter[] getters, ISetter[] setters, IGetter specializedGetter, ISetter specializedSetter) { // save off references this.mappedType = mappedType; typeOfThis = mappedType.IsValueType ? mappedType.MakeByRefType() : mappedType; //this.getters = getters; //this.setters = setters; GetPropertyValuesInvoker getInvoker = GenerateGetPropertyValuesMethod(getters); SetPropertyValuesInvoker setInvoker = GenerateSetPropertyValuesMethod(setters); var getMethods = new GetPropertyValueInvoker[getters.Length]; for (var i = 0; i < getters.Length; i++) { getMethods[i] = GenerateGetPropertyValueMethod(getters[i]); } var setMethods = new SetPropertyValueInvoker[setters.Length]; for (var i = 0; i < setters.Length; i++) { setMethods[i] = GenerateSetPropertyValueMethod(setters[i]); } accessOptimizer = new AccessOptimizer( getInvoker, setInvoker, getMethods, setMethods, GenerateGetPropertyValueMethod(specializedGetter), GenerateSetPropertyValueMethod(specializedSetter) ); createInstanceMethod = CreateCreateInstanceMethod(mappedType); }
public static MethodInfo GetReaderPrimitive(Type type) { return typeof(Primitives).GetMethod("ReadPrimitive", BindingFlags.Static | BindingFlags.Public | BindingFlags.ExactBinding, null, new Type[] { typeof(Stream), type.MakeByRefType() }, null); }
static Type fixType(TypeReference typeReference, Type type) { while (typeReference is TypeSpecification) { var ts = (TypeSpecification)typeReference; if (typeReference is ArrayType) { var arrayType = (ArrayType)typeReference; if (arrayType.IsVector) type = type.MakeArrayType(); else type = type.MakeArrayType(arrayType.Rank); } else if (typeReference is ByReferenceType) { type = type.MakeByRefType(); } else if (typeReference is PointerType) { type = type.MakePointerType(); } else if (typeReference is GenericInstanceType) { var git = (GenericInstanceType)typeReference; var args = new Type[git.GenericArguments.Count]; bool isGenericTypeDef = true; for (int i = 0; i < args.Length; i++) { var typeRef = git.GenericArguments[i]; if (!(typeRef.GetElementType() is GenericParameter)) isGenericTypeDef = false; args[i] = Resolver.resolve(typeRef); } if (!isGenericTypeDef) type = type.MakeGenericType(args); } typeReference = ts.ElementType; } return type; }
/// <summary> /// Stack transition: ..., field-ref => ... /// </summary> void EmitReadValueType(ILGenerator il, LocalBuilder reader, Type valType) { Debug.Assert(valType.IsValueType); Debug.Assert(!(valType.IsEnum || valType.IsPrimitive)); var fieldRef = il.DeclareLocal(valType.MakeByRefType()); il.Emit(OpCodes.Stloc, fieldRef); foreach (FieldInfo field in GetSerializableFields(valType)) { EmitReadField(il, reader, fieldRef, field); } }
public static void TryParseMatches(Type svo, SingleValueObjectAttribute attr) { var staticMethods = svo.GetMethods(BindingFlags.Public | BindingFlags.Static); // The out parameter. var byrefSvo = svo.MakeByRefType(); var tryParse = staticMethods.SingleOrDefault(method => method.Name == "TryParse" && method.GetParameters().Length == 2 && method.GetParameters()[0].ParameterType == typeof(String) && method.GetParameters()[1].ParameterType == byrefSvo && method.GetParameters()[1].IsOut && method.ReturnType == typeof(Boolean)); var tryParseCulture = staticMethods.SingleOrDefault(method => method.Name == "TryParse" && method.GetParameters().Length == 3 && method.GetParameters()[0].ParameterType == typeof(String) && method.GetParameters()[1].ParameterType == typeof(IFormatProvider) && method.GetParameters()[2].ParameterType == byrefSvo && method.GetParameters()[2].IsOut && method.ReturnType == typeof(Boolean)); if (attr.StaticOptions.HasFlag(SingleValueStaticOptions.TryParse)) { Assert.IsNotNull(tryParse, "{0} should contain a static TryParse method.", svo); if (attr.StaticOptions.HasFlag(SingleValueStaticOptions.CultureDependent)) { Assert.IsNotNull(tryParseCulture, "{0} should contain a static TryParse method with an IFormatProvider parameter.", svo); } else { Assert.IsNull(tryParseCulture, "{0} should not contain a static TryParse method with an IFormatProvider parameter.", svo); } } else { Assert.IsNull(tryParse, "{0} should not contain a static TryParse method.", svo); Assert.IsNull(tryParseCulture, "{0} should not contain a static TryParse method with an IFormatProvider parameter.", svo); } }
static Expression GenerateConversion(Expression expr, Type type, int errorPos) { Type exprType = expr.Type; if (exprType == type) return expr; if (exprType.IsValueType && type.IsValueType) { if ((IsNullableType(exprType) || IsNullableType(type)) && GetNonNullableType(exprType) == GetNonNullableType(type)) return Expression.Convert(expr, type); if ((IsNumericType(exprType) || IsEnumType(exprType)) && (IsNumericType(type)) || IsEnumType(type)) return Expression.ConvertChecked(expr, type); } if (exprType.IsAssignableFrom(type) || type.IsAssignableFrom(exprType) || exprType.IsInterface || type.IsInterface) return Expression.Convert(expr, type); // Try to Parse the string rather that just generate the convert statement // if (expr.NodeType == ExpressionType.Constant && exprType == typeof(string)) { string text = (string)((ConstantExpression)expr).Value; // DateTime is parsed as UTC time. // DateTime dateTime; if (type == typeof(DateTime) && DateTime.TryParse(text, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime)) return Expression.Constant(dateTime, type); object[] arguments = { text, null }; MethodInfo method = type.GetMethod("TryParse", BindingFlags.Public | BindingFlags.Static, null, new Type[] { typeof(string), type.MakeByRefType() }, null); if (method != null && (bool)method.Invoke(null, arguments)) return Expression.Constant(arguments[1], type); } throw ParseError(errorPos, Res.CannotConvertValue, GetTypeName(exprType), GetTypeName(type)); }
internal static unsafe Type GetTypeHelper(Type typeStart, Type[] genericArgs, IntPtr pModifiers, int cModifiers) { Type type = typeStart; if (genericArgs != null) { type = type.MakeGenericType(genericArgs); } if (cModifiers > 0) { int *numPtr = (int *)pModifiers.ToPointer(); for (int index = 0; index < cModifiers; ++index) { type = (int)(byte)Marshal.ReadInt32((IntPtr)((void *)numPtr), index * 4) != 15 ? ((int)(byte)Marshal.ReadInt32((IntPtr)((void *)numPtr), index * 4) != 16 ? ((int)(byte)Marshal.ReadInt32((IntPtr)((void *)numPtr), index * 4) != 29 ? type.MakeArrayType(Marshal.ReadInt32((IntPtr)((void *)numPtr), ++index * 4)) : type.MakeArrayType()) : type.MakeByRefType()) : type.MakePointerType(); } } return(type); }
internal Type MakeElementTypes(Type type) { for (int i = m_elementTypes.Length - 1; i >= 0; i --) { if (m_elementTypes[i] == SzArray) { type = type.MakeArrayType(); } else if (m_elementTypes[i] == Array) { type = type.MakeArrayType(m_elementTypes[--i]); } else if ((m_elementTypes[i] == Pointer)) { type = type.MakePointerType(); } else if ((m_elementTypes[i] == ByRef)) { type = type.MakeByRefType(); } } return type; }
private static Tuple <MethodInfo, Redirector> RedirectMethod( System.Type targetType, MethodInfo detour, bool reverse) { ParameterInfo[] parameters = detour.GetParameters(); System.Type[] types = parameters.Length == 0 || (targetType.IsValueType || parameters[0].ParameterType != targetType) && (!targetType.IsValueType || parameters[0].ParameterType != targetType.MakeByRefType()) ? ((IEnumerable <ParameterInfo>)parameters).Select <ParameterInfo, System.Type>((Func <ParameterInfo, System.Type>)(p => p.ParameterType)).ToArray <System.Type>() : ((IEnumerable <ParameterInfo>)parameters).Skip <ParameterInfo>(1).Select <ParameterInfo, System.Type>((Func <ParameterInfo, System.Type>)(p => p.ParameterType)).ToArray <System.Type>(); MethodInfo method = targetType.GetMethod(detour.Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, (Binder)null, types, (ParameterModifier[])null); if (method == null && detour.Name.EndsWith("Alt")) { method = targetType.GetMethod(detour.Name.Substring(0, detour.Name.Length - 3), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, (Binder)null, types, (ParameterModifier[])null); } Redirector second = reverse ? new Redirector(detour, method) : new Redirector(method, detour); second.Apply(); return(Tuple.New <MethodInfo, Redirector>(method, second)); }
static Type FixType(IType typeRef, Type type) { var sig = typeRef as TypeSig; if (sig == null) { var ts = typeRef as TypeSpec; if (ts != null) sig = ts.TypeSig; } while (sig != null) { switch (sig.ElementType) { case ElementType.SZArray: type = type.MakeArrayType(); break; case ElementType.Array: type = type.MakeArrayType((int)((ArraySig)sig).Rank); break; case ElementType.ByRef: type = type.MakeByRefType(); break; case ElementType.Ptr: type = type.MakePointerType(); break; case ElementType.GenericInst: var git = (GenericInstSig)sig; var args = new Type[git.GenericArguments.Count]; bool isGenericTypeDef = true; for (int i = 0; i < args.Length; i++) { var arg = git.GenericArguments[i]; if (!(arg is GenericSig)) isGenericTypeDef = false; args[i] = Resolver.Resolve(arg); } if (!isGenericTypeDef) type = type.MakeGenericType(args); break; default: break; } sig = sig.Next; } return type; }
// Returns true if the DryadLinqSerialization classes define // the type's Read and Write methods. For now we only support // generic types with at most 3 type parameters. private static string GetGenericSerializationClassName(Type type) { Type[] genericArgs = type.GetGenericArguments(); if (genericArgs.Length > 2) { return null; } Type refType = type.MakeByRefType(); if (genericArgs.Length == 1) { Type[] typeArgs = new Type[] { genericArgs[0], typeof(DryadLinqSerializer<>).MakeGenericType(genericArgs[0]) }; Type dsType = typeof(DryadLinqSerialization<,>).MakeGenericType(typeArgs); MethodInfo readMethod = TypeSystem.FindStaticMethod(dsType, "Read", new Type[]{ typeof(DryadLinqBinaryReader), refType }); MethodInfo writeMethod = TypeSystem.FindStaticMethod(dsType, "Write", new Type[]{ typeof(DryadLinqBinaryWriter), type }); if (readMethod != null && writeMethod != null) { return "DryadLinqSerialization"; } if (typeArgs[0].IsValueType) { dsType = typeof(StructDryadLinqSerialization<,>).MakeGenericType(typeArgs); readMethod = TypeSystem.FindStaticMethod(dsType, "Read", new Type[] { typeof(DryadLinqBinaryReader), refType }); writeMethod = TypeSystem.FindStaticMethod(dsType, "Write", new Type[] { typeof(DryadLinqBinaryWriter), type }); if (readMethod != null && writeMethod != null) { return "StructDryadLinqSerialization"; } } } else if (genericArgs.Length == 2) { Type[] typeArgs = new Type[] { genericArgs[0], genericArgs[1], typeof(DryadLinqSerializer<>).MakeGenericType(genericArgs[0]), typeof(DryadLinqSerializer<>).MakeGenericType(genericArgs[1]) }; Type dsType = typeof(DryadLinqSerialization<,,,>).MakeGenericType(typeArgs); MethodInfo readMethod = TypeSystem.FindStaticMethod(dsType, "Read", new Type[]{ typeof(DryadLinqBinaryReader), refType }); MethodInfo writeMethod = TypeSystem.FindStaticMethod(dsType, "Write", new Type[]{ typeof(DryadLinqBinaryWriter), type }); if (readMethod != null && writeMethod != null) { return "DryadLinqSerialization"; } if (typeArgs[0].IsValueType && typeArgs[1].IsValueType) { dsType = typeof(StructDryadLinqSerialization<,,,>).MakeGenericType(typeArgs); readMethod = TypeSystem.FindStaticMethod(dsType, "Read", new Type[] { typeof(DryadLinqBinaryReader), refType }); writeMethod = TypeSystem.FindStaticMethod(dsType, "Write", new Type[] { typeof(DryadLinqBinaryWriter), type }); if (readMethod != null && writeMethod != null) { return "StructDryadLinqSerialization"; } } } else if (genericArgs.Length == 3) { Type[] typeArgs = new Type[] { genericArgs[0], genericArgs[1], genericArgs[2], typeof(DryadLinqSerializer<>).MakeGenericType(genericArgs[0]), typeof(DryadLinqSerializer<>).MakeGenericType(genericArgs[1]), typeof(DryadLinqSerializer<>).MakeGenericType(genericArgs[2]) }; Type dsType = typeof(DryadLinqSerialization<,,,,,>).MakeGenericType(typeArgs); MethodInfo readMethod = TypeSystem.FindStaticMethod(dsType, "Read", new Type[] { typeof(DryadLinqBinaryReader), refType }); MethodInfo writeMethod = TypeSystem.FindStaticMethod(dsType, "Write", new Type[] { typeof(DryadLinqBinaryWriter), type }); if (readMethod != null && writeMethod != null) { return "DryadLinqSerialization"; } } return null; }
public LocalBuilder PinArray(Type elementType, Action<MyILGenerator> load) { var pointerVar = DeclareLocal(elementType.MakeByRefType(), true); load(this); Ldc_I4(0); Ldelema(elementType); Stloc(pointerVar); return pointerVar; }
/// <summary> /// Constructs a type descriptor. /// </summary> /// <param name="cilType">CLI type</param> /// <param name="asPointer">whether to construct a pointer type</param> /// <param name="asReference">whether to construct a reference type</param> public TypeDescriptor(Type cilType, bool asPointer = false, bool asReference = false) { CILType = cilType; if (asReference) CILType = CILType.MakeByRefType(); if (asPointer) CILType = CILType.MakePointerType(); InitTypeParams(); ComputeDependentTypes(); Owner = RootTypeLibrary.Instance; }
private void GetReturnType(Cci.ISignature signature, out Type returnType, out Type[] reqMods, out Type[] optMods) { returnType = ResolveType(signature.GetType(_context)); if (signature.ReturnValueIsByRef) { returnType = returnType.MakeByRefType(); } // TODO (tomat, Dev12): this doesn't handle types constructed from modified types, we need Ref.Emit supporte for that: if (signature.ReturnValueCustomModifiers.Any()) { ResolveCustomModifiers(signature.ReturnValueCustomModifiers, out reqMods, out optMods); } else { reqMods = optMods = null; } }
public void GetStaticMethods(Type type, out MethodInfo writer, out MethodInfo reader) { writer = typeof(SfmlTypeSerializer).GetMethod("Write", new Type[] { typeof(Stream), type }); reader = typeof(SfmlTypeSerializer).GetMethod("Read", new Type[] { typeof(Stream), type.MakeByRefType() }); }
private bool AreTypesCompatible(Type argumentType, Type typeArgSpecIsFor) { return argumentType.IsAssignableFrom(typeArgSpecIsFor) || (argumentType.IsByRef && !typeArgSpecIsFor.IsByRef && argumentType.IsAssignableFrom(typeArgSpecIsFor.MakeByRefType())); }
private void ConvertNestedInMethodFunctionHeader(ICommonNestedInFunctionFunctionNode func, Type decl_type) { num_scope++; //увеличиваем глубину обл. видимости TypeBuilder tb = null, tmp_type = cur_type; Frame frm = null; //func.functions_nodes.Length > 0 - имеет вложенные //funcs.Count > 0 - сама вложенная frm = MakeAuxType(func);//создаем запись активации tb = frm.tb; cur_type = tb; Type ret_type = null; //получаем тип возвр. значения if (func.return_value_type == null) ret_type = TypeFactory.VoidType; else ret_type = helper.GetTypeReference(func.return_value_type).tp; //получаем типы параметров Type[] tmp_param_types = GetParamTypes(func); Type[] param_types = new Type[tmp_param_types.Length + 1]; if (decl_type.IsValueType) param_types[0] = decl_type.MakeByRefType(); else param_types[0] = decl_type; tmp_param_types.CopyTo(param_types, 1); MethodAttributes attrs = MethodAttributes.Public | MethodAttributes.Static; //определяем саму процедуру/функцию MethodBuilder methb = null; methb = tb.DefineMethod(func.name, attrs, ret_type, param_types); MethInfo mi = null; if (smi.Count != 0) mi = helper.AddMethod(func, methb, smi.Peek()); else mi = helper.AddMethod(func, methb); mi.num_scope = num_scope; mi.disp = frm; mi.is_in_class = true;//процедура вложена в метод smi.Push(mi); ParameterBuilder pb = null; int num = 0; ILGenerator tmp_il = il; il = methb.GetILGenerator(); //if (ret_type != typeof(void)) mi.ret_val = il.DeclareLocal(ret_type); mi.nested = true; methb.DefineParameter(1, ParameterAttributes.None, "$obj$"); methb.DefineParameter(2, ParameterAttributes.None, "$up$"); num = 2; IParameterNode[] parameters = func.parameters; // FieldBuilder[] fba = new FieldBuilder[parameters.Length]; for (int i = 0; i < parameters.Length; i++) { //if (func.parameters[i].parameter_type == parameter_type.var) // pb = methb.DefineParameter(i + num + 1, ParameterAttributes.Retval, func.parameters[i].name); //else pb = methb.DefineParameter(i + num + 1, ParameterAttributes.None, parameters[i].name); if (parameters[i].is_params) pb.SetCustomAttribute(TypeFactory.ParamArrayAttributeConstructor, new byte[] { 0x1, 0x0, 0x0, 0x0 }); if (func.functions_nodes.Length > 0) { FieldBuilder fb = null; if (parameters[i].parameter_type == parameter_type.value) fb = frm.tb.DefineField(parameters[i].name, param_types[i + num], FieldAttributes.Public); else { Type pt = param_types[i + num].Module.GetType(param_types[i + num].FullName.Substring(0, param_types[i + num].FullName.IndexOf('&')) + "*"); if (pt == null) mb.GetType(param_types[i + num].FullName.Substring(0, param_types[i + num].FullName.IndexOf('&')) + "*"); fb = frm.tb.DefineField(parameters[i].name, pt, FieldAttributes.Public); } helper.AddGlobalParameter(parameters[i], fb).meth = smi.Peek(); fba[i] = fb; } else helper.AddParameter(parameters[i], pb).meth = smi.Peek(); } LocalBuilder frame = il.DeclareLocal(cur_type); mi.frame = frame; if (doc != null) frame.SetLocalSymInfo("$disp$"); il.Emit(OpCodes.Ldarg_1); il.Emit(OpCodes.Newobj, frm.cb); il.Emit(OpCodes.Stloc, frame); //инициализация полей записи активации нелокальными параметрами if (func.functions_nodes.Length > 0) for (int j = 0; j < fba.Length; j++) { il.Emit(OpCodes.Ldloc_0); if (parameters[j].parameter_type == parameter_type.value) { il.Emit(OpCodes.Ldarg_S, (byte)(j + 2)); } else { il.Emit(OpCodes.Ldarga_S, (byte)(j + 2)); } il.Emit(OpCodes.Stfld, fba[j]); } funcs.Add(func); MethodBuilder tmp = cur_meth; cur_meth = methb; //переводим переменные как нелокальные ConvertNonLocalVariables(func.var_definition_nodes, frm.mb); //переводим описания вложенных процедур ConvertNestedInMethodFunctionHeaders(func.functions_nodes, decl_type); foreach (ICommonNestedInFunctionFunctionNode f in func.functions_nodes) ConvertFunctionBody(f); if (frm != null) frm.mb.GetILGenerator().Emit(OpCodes.Ret); cur_type = tmp_type; num_scope--; smi.Pop(); funcs.RemoveAt(funcs.Count - 1); }
internal Type Resolve(Func <AssemblyName, Assembly> assemblyResolver, Func <Assembly, string, bool, Type> typeResolver, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark) { Assembly asm = null; if (assemblyResolver == null && typeResolver == null) { return(RuntimeType.GetType(DisplayFullName, throwOnError, ignoreCase, false, ref stackMark)); } if (assembly_name != null) { if (assemblyResolver != null) { asm = assemblyResolver(new AssemblyName(assembly_name)); } else { asm = Assembly.Load(assembly_name); } if (asm == null) { if (throwOnError) { throw new FileNotFoundException("Could not resolve assembly '" + assembly_name + "'"); } return(null); } } Type type = null; if (typeResolver != null) { type = typeResolver(asm, name.DisplayName, ignoreCase); } else { type = asm.GetType(name.DisplayName, false, ignoreCase); } if (type == null) { if (throwOnError) { throw new TypeLoadException("Could not resolve type '" + name + "'"); } return(null); } if (nested != null) { foreach (var n in nested) { var tmp = type.GetNestedType(n.DisplayName, BindingFlags.Public | BindingFlags.NonPublic); if (tmp == null) { if (throwOnError) { throw new TypeLoadException("Could not resolve type '" + n + "'"); } return(null); } type = tmp; } } if (generic_params != null) { Type[] args = new Type [generic_params.Count]; for (int i = 0; i < args.Length; ++i) { var tmp = generic_params [i].Resolve(assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark); if (tmp == null) { if (throwOnError) { throw new TypeLoadException("Could not resolve type '" + generic_params [i].name + "'"); } return(null); } args [i] = tmp; } type = type.MakeGenericType(args); } if (modifier_spec != null) { foreach (var md in modifier_spec) { type = md.Resolve(type); } } if (is_byref) { type = type.MakeByRefType(); } return(type); }
internal Type MakeElementTypes(Type type) { for (int i = this.m_elementTypes.Length - 1; i >= 0; i--) { if (this.m_elementTypes[i] == 3) { type = type.MakeArrayType(); } else { if (this.m_elementTypes[i] == 2) { type = type.MakeArrayType(this.m_elementTypes[--i]); } else { if (this.m_elementTypes[i] == 1) { type = type.MakePointerType(); } else { if (this.m_elementTypes[i] == 4) { type = type.MakeByRefType(); } } } } } return type; }
// Only called on Primitive types, as these all have a TryParse method private static object GetPrimitive(Type type, string value) { // Get the TryParse method MethodInfo tryParse = type.GetMethod("TryParse", new Type[] { typeof(string), type.MakeByRefType() }); System.Diagnostics.Debug.Assert(tryParse != null, "TryParse method not found."); object[] parameters = { value, null }; // null will be filled by TryParse if ((bool)tryParse.Invoke(null, parameters)) { return parameters[1]; } return null; // Failed to convert }