Ejemplo n.º 1
0
        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;
		}
Ejemplo n.º 4
0
        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);
        }
Ejemplo n.º 5
0
        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;
        }
Ejemplo n.º 6
0
		public static Type MakeByRef (Type t)
		{
			var mt = t as MetadataType;
			if (mt != null) {
				mt.m_isByRef = true;
				return mt;
			}
			return t.MakeByRefType ();
		}
Ejemplo n.º 7
0
        /// <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;
        }
Ejemplo n.º 8
0
        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);
        }
Ejemplo n.º 9
0
        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];
        }
Ejemplo n.º 10
0
        /// <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);
        }
Ejemplo n.º 11
0
        /// <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;
        }
Ejemplo n.º 14
0
		/// <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);
		}
Ejemplo n.º 15
0
        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);
        }
Ejemplo n.º 17
0
 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);
 }
Ejemplo n.º 18
0
        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;
        }
Ejemplo n.º 19
0
		/// <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);
			}
		}
Ejemplo n.º 20
0
        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));
        }
Ejemplo n.º 22
0
        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);
        }
Ejemplo n.º 23
0
        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;
        }
Ejemplo n.º 24
0
        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));
        }
Ejemplo n.º 25
0
		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;
		}
Ejemplo n.º 26
0
        // 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;
        }
Ejemplo n.º 27
0
        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;
        }
Ejemplo n.º 28
0
        /// <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;
        }
Ejemplo n.º 29
0
        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;
            }
        }
Ejemplo n.º 30
0
 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()));
 }
Ejemplo n.º 32
0
        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);
        }
Ejemplo n.º 33
0
        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;
		}
Ejemplo n.º 35
0
        // 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
        }