public static void Test01()
{
var type = env.GetType("TestCase.Test01+TestClass");
var method = type.GetDeclaredMethod("Calc", null, new ILType[] { env.GetType <int>() }, env.GetType <int>());
Assert.AreEquals(method.Name, "Calc");
}
public static void Test01()
{
var type = env.GetType("TestCase.Test01");
Assert.AreEquals(type.FullName, "TestCase.Test01");
Assert.AreEquals(type.BaseType.TypeForCLR, typeof(object));
Assert.AreSame(type.MakeArrayType(), env.GetType("TestCase.Test01[]"));
}
public static void Test01()
{
var type = env.GetType("TestCase.Test01");
var method = type.GetDeclaredMethod("Run2", null, null, env.String);
Assert.AreEquals(method.Invoke(null), "Hello World!");
}
internal static CLRType Create(Type type, ILEnvironment env)
{
if (type.IsPointer)
{
var elementType = env.GetType(type.GetElementType());
return(new CLRPointerType(elementType, type, env));
}
if (type.IsByRef)
{
var elementType = env.GetType(type.GetElementType());
return(new CLRByRefType(elementType, type, env));
}
if (type.IsArray)
{
var elementType = env.GetType(type.GetElementType());
return(new CLRArrayType(elementType, type, env));
}
if (type.IsGenericParameter)
{
if (type.DeclaringType != null)
{
return(new CLRTypeGenericParameterType(type, env));
}
}
if (type.IsGenericType)
{
if (type.IsGenericTypeDefinition)
{
return(new CLRGenericDefinitionType(type, env));
}
var clrGenericArguments = type.GetGenericArguments();
var genericArguments = new FastList <ILType>(clrGenericArguments.Length);
foreach (var generic in clrGenericArguments)
{
genericArguments.Add(env.GetType(generic));
}
var genericTypeDefinition = env.GetType(type.GetGenericTypeDefinition());
return(new CLRGenericSpecificationType(genericTypeDefinition, genericArguments, type, env));
}
return(new CLRDirectType(type, env));
}
private static void Test()
{
var env = new ILEnvironment();
env.LoadAssemblyFromFile(Constant.TestCaseDll);
var type = env.GetType("TestCase.Test01");
var method = type.GetDeclaredMethod("Run3", null, new ILType[] { env.Int }, env.Int);
Console.WriteLine(method.Invoke(null, 10));
//Console.WriteLine(typeof(object).GetConstructors()[0].Invoke(null));
}
public static void Test01()
{
var type = env.GetType(typeof(int));
Assert.AreEquals(type.FullName, "System.Int32");
Assert.AreEquals(type.FullQulifiedName, "System.Int32");
Assert.AreEquals(type.AssemblyQualifiedName, typeof(int).AssemblyQualifiedName);
Assert.AreSame(type, env.GetType("System.Int32"));
Assert.AreSame(type, env.GetType("System.Int32,mscorlib"));
Assert.AreSame(type, env.GetType(typeof(int).AssemblyQualifiedName));
Assert.False(type.IsArray);
Assert.AreEquals(type.ArrayRank, 0);
Assert.False(type.IsPointer);
Assert.False(type.IsByRef);
Assert.False(type.IsGenericTypeDefinition);
Assert.False(type.IsGenericType);
Assert.False(type.IsGenericParameter);
Assert.Null(type.GenericTypeDefinition);
}
public static Instruction Create(Code code, object operand, ILEnvironment env, Dictionary <Mono.Cecil.Cil.Instruction, int> address)
{
var instruction = new Instruction
{
Code = code,
};
switch (code)
{
#region jump
case Code.Leave:
case Code.Leave_S:
case Code.Br:
case Code.Br_S:
case Code.Brtrue:
case Code.Brtrue_S:
case Code.Brfalse:
case Code.Brfalse_S:
case Code.Beq:
case Code.Beq_S:
case Code.Bne_Un:
case Code.Bne_Un_S:
case Code.Bge:
case Code.Bge_S:
case Code.Bge_Un:
case Code.Bge_Un_S:
case Code.Bgt:
case Code.Bgt_S:
case Code.Bgt_Un:
case Code.Bgt_Un_S:
case Code.Ble:
case Code.Ble_S:
case Code.Ble_Un:
case Code.Ble_Un_S:
case Code.Blt:
case Code.Blt_S:
case Code.Blt_Un:
case Code.Blt_Un_S:
instruction.Int32 = address[(Mono.Cecil.Cil.Instruction)operand];
break;
#endregion
#region ldc
case Code.Ldc_I4:
instruction.Int32 = (int)operand;
break;
case Code.Ldc_I4_S:
instruction.Int32 = (sbyte)operand;
break;
case Code.Ldc_I8:
instruction.Int64 = (long)operand;
break;
case Code.Ldstr:
StringPool.Put((string)operand, out instruction.High32, out instruction.Low32);
break;
#endregion
#region call
case Code.Newobj:
case Code.Call:
var methodReference = (MethodReference)operand;
var type = env.GetType(methodReference.DeclaringType);
var method = type.GetDeclaredMethod(methodReference);
instruction.High32 = type.GetHashCode();
instruction.Low32 = method.GetHashCode();
break;
#endregion
}
return(instruction);
}
