Пример #1
0
    static void FillLuaInvokerGenericArguments(MethodDefinition prototypeMethod, bool bIgnoreReturnValue, bool bAppendCoroutineState, ref MethodReference invoker)
    {
        if (invoker.HasGenericParameters)
        {
            GenericInstanceMethod genericInjectMethod = new GenericInstanceMethod(invoker.CloneMethod());

            if (prototypeMethod.HasThis)
            {
                genericInjectMethod.GenericArguments.Add(prototypeMethod.DeclaringType);
            }
            foreach (ParameterDefinition parameter in prototypeMethod.Parameters)
            {
                var paramType = parameter.ParameterType.IsByReference ? ElementType.For(parameter.ParameterType) : parameter.ParameterType;
                genericInjectMethod.GenericArguments.Add(paramType);
            }
            if (bAppendCoroutineState)
            {
                genericInjectMethod.GenericArguments.Add(intTypeRef);
            }
            if (prototypeMethod.GotPassedByReferenceParam())
            {
                genericInjectMethod.GenericArguments.Add(luaTableTypeDef);
            }
            else if (!bIgnoreReturnValue && !prototypeMethod.ReturnVoid())
            {
                genericInjectMethod.GenericArguments.Add(prototypeMethod.ReturnType);
            }

            invoker = genericInjectMethod;
        }
    }
Пример #2
0
 public static string GetTypeName(TypeReference t, bool bFull = false)
 {
     if (t.IsArray)
     {
         string str = GetTypeName(ElementType.For(t));
         str += GetArrayRank(t);
         return(str);
     }
     else if (t.IsByReference)
     {
         //t = t.GetElementType();
         return(GetTypeName(ElementType.For(t)) + "&");
     }
     else if (t.IsGenericInstance)
     {
         return(GetGenericName(t, bFull));
     }
     else if (t.MetadataType == MetadataType.Void)
     {
         return("void");
     }
     else
     {
         string name = GetPrimitiveTypeStr(t, bFull);
         return(name.Replace('+', '.'));
     }
 }
Пример #3
0
    static void ParseArgumentReference(MethodDefinition target, Instruction endPoint, int paramIndex)
    {
        ParameterDefinition param = null;
        ILProcessor         il    = target.Body.GetILProcessor();

        if (target.HasThis)
        {
            if (paramIndex > 0)
            {
                param = target.Parameters[paramIndex - 1];
            }
            else if (target.DeclaringType.IsValueType)
            {
                il.InsertBefore(endPoint, il.Create(OpCodes.Ldobj, target.DeclaringType));
            }
        }
        else if (!target.HasThis)
        {
            param = target.Parameters[paramIndex];
        }

        if (param != null && param.ParameterType.IsByReference)
        {
            TypeReference paramType = ElementType.For(param.ParameterType);
            if (paramType.IsValueType)
            {
                il.InsertBefore(endPoint, il.Create(OpCodes.Ldobj, paramType));
            }
            else
            {
                il.InsertBefore(endPoint, il.Create(OpCodes.Ldind_Ref));
            }
        }
    }
Пример #4
0
    public static bool IsGenericTypeDefinition(this TypeReference type)
    {
        if (type.HasGenericParameters)
        {
            return(true);
        }
        else if (type.IsByReference || type.IsArray)
        {
            return(ElementType.For(type).IsGenericTypeDefinition());
        }
        else if (type.IsNested)
        {
            var parent = type.DeclaringType;
            while (parent != null)
            {
                if (parent.IsGenericTypeDefinition())
                {
                    return(true);
                }

                if (parent.IsNested)
                {
                    parent = parent.DeclaringType;
                }
                else
                {
                    break;
                }
            }
        }

        return(type.IsGenericParameter);
    }
Пример #5
0
        public static bool IsAssignableTo(this TypeReference typeRef, string typeName)
        {
            bool result;

            try
            {
                if (typeRef.IsGenericInstance)
                {
                    result = ElementType.For(typeRef).IsAssignableTo(typeName);
                }
                else if (typeRef.FullName == typeName)
                {
                    result = true;
                }
                else
                {
                    result = typeRef.CheckedResolve().IsSubclassOf(typeName);
                }
            }
            catch (AssemblyResolutionException)
            {
                result = false;
            }
            return(result);
        }
Пример #6
0
 public static bool IsAssignableTo(this TypeReference typeRef, string typeName)
 {
     try
     {
         if (typeRef.IsGenericInstance)
         {
             return(ElementType.For(typeRef).IsAssignableTo(typeName));
         }
         return((typeRef.FullName == typeName) || typeRef.CheckedResolve().IsSubclassOf(typeName));
     }
     catch (AssemblyResolutionException)
     {
         return(false);
     }
 }
Пример #7
0
    static void UpdatePassedByReferenceParams(MethodDefinition target, bool bConfirmPopReturnValue)
    {
        if (!target.GotPassedByReferenceParam())
        {
            return;
        }

        int                updateCount         = 0;
        ILProcessor        il                  = target.Body.GetILProcessor();
        VariableDefinition luaTable            = GetResultTable(target);
        var                rawGetGenericMethod = luaTableTypeDef.Methods.Single(method => method.Name == "RawGetIndex");

        foreach (var param in target.Parameters)
        {
            if (!param.ParameterType.IsByReference)
            {
                continue;
            }

            var paramType = ElementType.For(param.ParameterType);
            il.InsertBefore(cursor, il.Create(OpCodes.Ldarg, param));
            il.InsertBefore(cursor, il.Create(OpCodes.Ldloc, luaTable));
            il.InsertBefore(cursor, il.Create(OpCodes.Ldc_I4, ++updateCount));
            il.InsertBefore(cursor, il.Create(OpCodes.Call, rawGetGenericMethod.MakeGenericMethod(paramType)));
            if (paramType.IsValueType)
            {
                il.InsertBefore(cursor, il.Create(OpCodes.Stobj, paramType));
            }
            else
            {
                il.InsertBefore(cursor, il.Create(OpCodes.Stind_Ref));
            }
        }

        if (!bConfirmPopReturnValue && !target.ReturnVoid())
        {
            il.InsertBefore(cursor, il.Create(OpCodes.Ldloc, luaTable));
            il.InsertBefore(cursor, il.Create(OpCodes.Ldc_I4, ++updateCount));
            il.InsertBefore(cursor, il.Create(OpCodes.Call, rawGetGenericMethod.MakeGenericMethod(target.ReturnType)));
        }
    }
        public static bool IsAssignableTo(this TypeReference typeRef, string typeName)
        {
            try
            {
                if (typeRef.IsGenericInstance)
                {
                    return(ElementType.For(typeRef).IsAssignableTo(typeName));
                }

                if (typeRef.FullName == typeName)
                {
                    return(true);
                }

                return(typeRef.CheckedResolve().IsSubclassOf(typeName));
            }
            catch (AssemblyResolutionException) // If we can't resolve our typeref or one of its base types,
            {                                   // let's assume it is not assignable to our target type
                return(false);
            }
        }