private static void SomeMethod(TypeBuilder tb, SilmMI nb, OnlyMI target)
{
Type[] vs = nb.ParaTypes;
ILGenerator g = tb.DefineMethod(nb.Name, mattrb, cc, nb.RetType, vs).GetILGenerator();
int max = nb.ParaLength;
for (int x = 0; x < max;)
{
if (vs[x].IsByRef)
{
g.Emit_Ldarga(++x); // instance
}
else
{
g.Emit_Ldarg(++x);
}
}
g.Emit(OpCodes.Call, target.Info);
g.Emit(OpCodes.Ret);
}
public bool Equals(SilmMI other)
{
if (VName != other.VName ||
RetType != other.RetType ||
ParaLength != other.ParaLength)
{
return(false);
}
int x = ParaLength;
Type[] me = ParaTypes;
Type[] ot = other.ParaTypes;
while (--x >= 0)
{
if (me[x] != ot[x])
{
return(false);
}
}
return(true);
}
/// <exception cref="Exception">Thrown when TargetField attribute cannot be found in the property</exception>
/// <exception cref="InvalidOperationException">Thrown when try to invalid operation</exception>
/// <summary>
/// Create an interface implementation for dynamic type <paramref name="t"/>
/// </summary>
/// <typeparam name="T">Interface type</typeparam>
/// <param name="t">
/// Find only public static fields and methods
/// Using static types(as opposed to dynamic types) is inefficient
/// </param>
/// <returns>Is not null if the method succeeds</returns>
public static T Make <T>(Type t) where T : class
{
Type temp = typeof(T);
if (!temp.IsInterface || temp.IsNotPublic || t == null || !(t.IsAbstract && t.IsSealed))
{
return(null);
}
if (cached.TryGetValue(t, out object obj))
{
return((T)obj);
}
PropertyInfo[] implPpt = temp.GetProperties(flag_i);
SpMI[] impl = Array.ConvertAll(temp.GetMethods(flag_i), CONV_SPI);
OnlyMI[] code = Array.ConvertAll(t.GetMethods(flag_s), CONV_OMI);
int init_x = impl.Length;
int init_p = implPpt.Length;
if (init_x == 0 && init_p == 0)
{
return(null);
}
CHashSet <int> xdone =
init_x == 0
? null
: new CHashSet <int>(init_x);
StringBuilder sb = new StringBuilder(t.FullName);
sb.Append("__ClassWrapper__");
sb.Append(cached.Count);
TypeBuilder tb = mdb.DefineType(sb.ToString(), tattrb, null, new Type[1] {
temp
});
int clen = code.Length;
int z = 0;
for (; z < init_x; z++)
{
SilmMI k = impl[z];
int x = clen;
while (--x >= 0)
{
if (code[x].Equals(k) && xdone.Add(x))
{
SomeMethod(tb, k, code[x]);
break;
}
}
}
if (xdone != null && init_x != xdone.Count)
{
throw new InvalidOperationException("Some methods could not be implemented", GETMOREINFO(temp, init_x, xdone));
}
for (z = 0; z < init_p; z++)
{
if (implPpt[z].GetCustomAttribute <TargetFieldAttribute>() is TargetFieldAttribute tfa)
{
PropertyInfo pp = implPpt[z];
temp = pp.PropertyType;
if (tfa.refm ^ temp.IsByRef)
{
throw new InvalidOperationException("Incorrect attribute declare", GETMOREINFO(temp.IsByRef));
}
else if (pp.GetSetMethod() != null)
{
throw new InvalidOperationException("use ref return type instead of set accessor", GETMOREINFO());
}
if (t.GetField(pp.GetCustomAttribute <TargetFunctionAttribute>()?.name ?? tfa.name, flag_sa) is FieldInfo fd)
{
FieldMethod(tb, pp.GetGetMethod(false), fd, tfa.refm);
}
else
{
throw new InvalidOperationException($"Field not found: {tfa.name}");
}
}
else
{
throw new Exception("Missing attribute");
}
}
obj = FormatterServices.GetUninitializedObject(tb.CreateType());
cached.Add(t, obj);
return((T)obj);
}
