private ITest BuildCall()
{
var typeBuilder = Module.DefineType(Guid.NewGuid().ToString(), TypeAttributes.Class | TypeAttributes.Public);
var doNothingMethod = typeBuilder.DefineMethod("DoNothingImpl", MethodAttributes.Public, typeof(void), Type.EmptyTypes);
using (var il = new GroboIL(doNothingMethod))
{
il.Ldfld(xField);
il.Ldc_I4(1);
il.Add();
il.Stfld(xField);
il.Ret();
}
var method = typeBuilder.DefineMethod("DoNothing", MethodAttributes.Public | MethodAttributes.Virtual, typeof(void), Type.EmptyTypes);
using (var il = new GroboIL(method))
{
il.Ldarg(0);
il.Call(doNothingMethod);
il.Ret();
}
typeBuilder.DefineMethodOverride(method, typeof(ITest).GetMethod("DoNothing"));
typeBuilder.AddInterfaceImplementation(typeof(ITest));
var type = typeBuilder.CreateType();
return((ITest)Activator.CreateInstance(type));
}
public void GetWriteILCode(PropertyData prop, BinaryStruct currentStruct, GroboIL il, GroboIL.Local binaryStruct, GroboIL.Local value, GroboIL.Local typeSize, GroboIL.Local buffer, GroboIL.Local offset, bool listValue)
{
BinaryStruct.WriteSizeChecker(il, buffer, offset, 2);
var arr = il.DeclareLocal(typeof(byte[]));
il.Ldloc(value);
if (!listValue)
{
il.Call(prop.Getter);
}
il.Dup();
il.Pop();
il.Call(writeBitConverterMethodInfo);
il.Stloc(arr);
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldloc(arr);
il.Ldc_I4(0);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
for (int i = 1; i < 2; i++)
{
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldc_I4(i);
il.Add();
il.Ldloc(arr);
il.Ldc_I4(i);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
}
BinaryStruct.WriteOffsetAppend(il, offset, 2);
}
public static void WriteOffsetAppend(GroboIL il, GroboIL.Local offset, int len)
{
il.Ldloc(offset);
il.Ldc_I4(len);
il.Add();
il.Stloc(offset);
}
private Func <TestClassA, int> Build1()
{
var typeBuilder = Module.DefineType(Guid.NewGuid().ToString(), TypeAttributes.Class | TypeAttributes.Public);
var method = typeBuilder.DefineMethod("zzz", MethodAttributes.Public | MethodAttributes.Static, typeof(int), new[] { typeof(TestClassA) });
using (var il = new GroboIL(method))
{
il.Ldarg(0);
il.Ldfld(typeof(TestClassA).GetField("Y"));
var y = il.DeclareLocal(typeof(int));
il.Stloc(y);
il.Ldarg(0);
il.Ldfld(typeof(TestClassA).GetField("Z"));
var z = il.DeclareLocal(typeof(int));
il.Stloc(z);
il.Ldloc(y);
il.Ldloc(z);
il.Add();
il.Ret();
}
var type = typeBuilder.CreateType();
var dynamicMethod = new DynamicMethod(Guid.NewGuid().ToString(), MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, typeof(Func <TestClassA, int>), Type.EmptyTypes, Module, true);
using (var il = new GroboIL(dynamicMethod))
{
il.Ldnull();
il.Ldftn(type.GetMethod("zzz"));
il.Newobj(typeof(Func <TestClassA, int>).GetConstructor(new[] { typeof(object), typeof(IntPtr) }));
il.Ret();
}
return(((Func <Func <TestClassA, int> >)dynamicMethod.CreateDelegate(typeof(Func <Func <TestClassA, int> >)))());
}
private void TestSuccess(Type type1, Type type2)
{
var method = new DynamicMethod(Guid.NewGuid().ToString(), typeof(void), new[] { type1, type2, }.Where(type => type != null).ToArray(), typeof(string), true);
using (var il = new GroboIL(method))
{
int index = 0;
if (type1 != null)
{
il.Ldarg(index++);
}
else
{
il.Ldnull();
}
if (type2 != null)
{
il.Ldarg(index++);
}
else
{
il.Ldnull();
}
il.Add();
il.Pop();
il.Ret();
Console.WriteLine(il.GetILCode());
}
}
private static void EmitOp(GroboIL il, ExpressionType nodeType, Type type)
{
switch (nodeType)
{
case ExpressionType.Add:
il.Add();
break;
case ExpressionType.AddChecked:
il.Add_Ovf(type.Unsigned());
break;
case ExpressionType.Subtract:
il.Sub();
break;
case ExpressionType.SubtractChecked:
il.Sub_Ovf(type.Unsigned());
break;
case ExpressionType.Multiply:
il.Mul();
break;
case ExpressionType.MultiplyChecked:
il.Mul_Ovf(type.Unsigned());
break;
case ExpressionType.Divide:
il.Div(type.Unsigned());
break;
case ExpressionType.Modulo:
il.Rem(type.Unsigned());
break;
case ExpressionType.LeftShift:
il.Shl();
break;
case ExpressionType.RightShift:
il.Shr(type.Unsigned());
break;
case ExpressionType.And:
il.And();
break;
case ExpressionType.Or:
il.Or();
break;
case ExpressionType.ExclusiveOr:
il.Xor();
break;
default:
throw new NotSupportedException("Node type '" + nodeType + "' is not supported");
}
}
public void GetWriteILCode(PropertyData prop, BinaryStruct currentStruct, GroboIL il, GroboIL.Local binaryStruct, GroboIL.Local value, GroboIL.Local typeSize, GroboIL.Local buffer, GroboIL.Local offset, bool listValue)
{
BinaryStruct.WriteSizeChecker(il, buffer, offset, 8);
var arr = il.DeclareLocal(typeof(byte[]));
var v = il.DeclareLocal(typeof(DateTime));
var t = il.DeclareLocal(typeof(TimeSpan));
if (!listValue)
{
il.Ldloc(value);
var v1 = il.DeclareLocal(typeof(DateTime));
il.Call(prop.Getter);
il.Stloc(v1);
il.Ldloca(v1);
}
else
{
il.Ldloca(value);
}
il.Ldloca(v);
il.Ldc_I4(1970);
il.Ldc_I4(1);
il.Ldc_I4(1);
il.Ldc_I4(0);
il.Ldc_I4(0);
il.Ldc_I4(0);
il.Ldc_I4(0);
il.Call(datetimeConstructor);
il.Ldloc(v);
il.Call(substractMethod);
il.Stloc(t);
il.Ldloca(t);
il.Call(propertyGetter);
il.Call(writeBitConverterMethodInfo);
il.Stloc(arr);
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldloc(arr);
il.Ldc_I4(0);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
for (int i = 1; i < 8; i++)
{
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldc_I4(i);
il.Add();
il.Ldloc(arr);
il.Ldc_I4(i);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
}
BinaryStruct.WriteOffsetAppend(il, offset, 8);
}
public static void WriteOffsetAppend(GroboIL il, GroboIL.Local offset, GroboIL.Local typeSize)
{
il.Ldloc(offset);
il.Ldloc(typeSize);
il.Add();
il.Stloc(offset);
}
private static void EmitXPlusPlus(this GroboIL il, GroboIL.Local intLocal)
{
il.Ldloc(intLocal);
il.Dup();
il.Ldc_I4(1);
il.Add();
il.Stloc(intLocal);
}
public void GetReadILCode(PropertyData prop, BinaryStruct currentStruct, GroboIL il, GroboIL.Local binaryStruct, GroboIL.Local buffer, GroboIL.Local result, GroboIL.Local typeSize, GroboIL.Local offset, bool listValue)
{
var r = il.DeclareLocal(typeof(Vector3));
if (listValue)
{
il.Ldloca(result);
}
else
{
il.Ldloca(r);
}
il.Ldloc(buffer);
il.Ldloc(offset);
il.Call(readBitConverterMethodInfo);
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldc_I4(4);
il.Add();
il.Call(readBitConverterMethodInfo);
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldc_I4(8);
il.Add();
il.Call(readBitConverterMethodInfo);
il.Call(initialConstructor);
//if (listValue)
// il.Stloc(result);
//else
// il.Stloc(r);
BinaryStruct.WriteOffsetAppend(il, offset, 12);
if (!listValue)
{
il.Ldloc(result);
il.Ldloc(r);
il.Call(prop.Setter, isVirtual: true);
}
}
private static Tuple <Delegate, IntPtr> EmitListResizer <T>()
{
var method = new DynamicMethod(Guid.NewGuid().ToString(), typeof(void), new[] { typeof(List <T>), typeof(int) }, typeof(string), true);
using (var il = new GroboIL(method))
{
il.Ldarg(0); // stack: [list]
il.Ldarg(1); // stack: [list, arrayIndex]
il.Ldc_I4(1); // stack: [list, arrayIndex, 1]
il.Add(); // stack: [list, arrayIndex + 1]
il.Call(typeof(List <T>).GetMethod("EnsureCapacity", BindingFlags.Instance | BindingFlags.NonPublic)); // list.EnsureCapacity(arrayIndex + 1); stack: []
il.Ldarg(0); // stack: [list]
il.Ldarg(1); // stack: [list, arrayIndex]
il.Ldc_I4(1); // stack: [list, arrayIndex, 1]
il.Add(); // stack: [list, arrayIndex + 1]
il.Stfld(typeof(List <T>).GetField("_size", BindingFlags.Instance | BindingFlags.NonPublic)); // list.Count = arrayIndex + 1; stack: []
il.Ret();
}
return(new Tuple <Delegate, IntPtr>((Action <List <T>, int>)method.CreateDelegate(typeof(Action <List <T>, int>)), DynamicMethodInvokerBuilder.DynamicMethodPointerExtractor(method)));
}
public void BuildSizeCounter(SizeCounterBuilderContext sizeCounterBuilderContext)
{
var method = new DynamicMethod("Count_" + Type.Name + "_" + Guid.NewGuid(), typeof(int), new[] { Type, typeof(bool), typeof(WriterContext) }, sizeCounterBuilderContext.Module, true);
sizeCounterBuilderContext.SetSizeCounterMethod(Type, method);
using (var il = new GroboIL(method))
{
var context = new SizeCounterMethodBuilderContext(sizeCounterBuilderContext, il);
var notEmptyLabel = il.DefineLabel("notEmpty");
if (CheckEmpty(context, notEmptyLabel)) // Check if obj is empty
{
context.ReturnForNull(); // return for null
}
il.MarkLabel(notEmptyLabel); // Now we know that obj is not empty
if (!Type.IsValueType && IsReference && sizeCounterBuilderContext.GroBufWriter.Options.HasFlag(GroBufOptions.PackReferences))
{
// Pack reference
var index = il.DeclareLocal(typeof(int));
context.LoadContext(); // stack: [context]
il.Dup(); // stack: [context, context]
il.Ldfld(WriterContext.IndexField); // stack: [context, context.index]
il.Stloc(index); // index = context.index; stack: [context]
il.Ldfld(WriterContext.ObjectsField); // stack: [context.objects]
context.LoadObj(); // stack: [context.objects, obj]
il.Call(HackHelpers.GetMethodDefinition <Dictionary <object, int> >(dict => dict.ContainsKey(null))); // stack: [context.object.ContainsKey(obj)]
var storeLocationLabel = il.DefineLabel("storeLocation");
il.Brfalse(storeLocationLabel); // if(!context.objects.ContainsKey(obj)) goto storeLocation; stack: []
context.LoadContext(); // stack: [context]
il.Dup(); // stack: [context, context]
il.Ldfld(WriterContext.ReferencesField); // stack: [context, context.references]
il.Ldc_I4(1); // stack: [context, context.references, 1]
il.Add(); // stack: [context, context.references + 1]
il.Stfld(WriterContext.ReferencesField); // context.references += 1; stack: []
il.Ldc_I4(5); // stack: [5]
il.Ret(); // return 5
il.MarkLabel(storeLocationLabel);
context.LoadContext(); // stack: [context]
il.Ldfld(typeof(WriterContext).GetField("objects", BindingFlags.Public | BindingFlags.Instance)); // stack: [context.objects]
context.LoadObj(); // stack: [context.objects, obj]
il.Ldloc(index); // stack: [context.objects, obj, index]
il.Call(HackHelpers.GetMethodDefinition <Dictionary <object, int> >(dict => dict.Add(null, 0))); // context.objects.Add(obj, index);
}
CountSizeNotEmpty(context); // Count size
il.Ret();
}
var @delegate = method.CreateDelegate(typeof(SizeCounterDelegate <>).MakeGenericType(Type));
var pointer = GroBufHelpers.ExtractDynamicMethodPointer(method);
sizeCounterBuilderContext.SetSizeCounterPointer(Type, pointer, @delegate);
}
public void TestAPlusB()
{
var method = new DynamicMethod(Guid.NewGuid().ToString(), typeof(int), new[] { typeof(int), typeof(int) }, typeof(Test));
using (var il = new GroboIL(method))
{
il.Ldarg(0);
il.Ldarg(1);
il.Add();
il.Ret();
Console.Write(il.GetILCode());
}
}
private Tuple <Action, MethodInfo> Build()
{
var dynamicMethod = new DynamicMethod(Guid.NewGuid().ToString(), MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, typeof(void), Type.EmptyTypes, Module, true);
using (var il = new GroboIL(dynamicMethod))
{
il.Ldfld(xField);
il.Ldc_I4(1);
il.Add();
il.Stfld(xField);
il.Ret();
}
return(new Tuple <Action, MethodInfo>((Action)dynamicMethod.CreateDelegate(typeof(Action)), dynamicMethod));
}
public void Simple()
{
var dynamicMethod = new DynamicMethod(Guid.NewGuid().ToString(), typeof(int), new[] { typeof(int), typeof(int) }, typeof(string), true);
using (var il = new GroboIL(dynamicMethod, false))
{
il.Ldarg(0);
il.Ldarg(1);
il.Add();
il.Ret();
}
DynamicMethodTracingInstaller.InstallTracing(dynamicMethod);
var func = (Func <int, int, int>)dynamicMethod.CreateDelegate(typeof(Func <int, int, int>));
Console.WriteLine(func(2, 3));
}
public void TestZ()
{
var method = new DynamicMethod(Guid.NewGuid().ToString(), typeof(int), new[] { typeof(bool), typeof(float), typeof(double) }, typeof(Test));
using (var il = new GroboIL(method))
{
il.Ldarg(0);
var label1 = il.DefineLabel("label");
il.Brfalse(label1);
il.Ldarg(1);
var label2 = il.DefineLabel("label");
il.Br(label2);
il.MarkLabel(label1);
il.Ldarg(2);
il.MarkLabel(label2);
il.Ldc_I4(1);
il.Conv <float>();
il.Add();
il.Conv <int>();
il.Ret();
Console.Write(il.GetILCode());
}
}
protected override bool EmitInternal(UnaryExpression node, EmittingContext context, GroboIL.Label returnDefaultValueLabel, ResultType whatReturn, bool extend, out Type resultType)
{
Type operandType;
var result = ExpressionEmittersCollection.Emit(node.Operand, context, returnDefaultValueLabel, ResultType.Value, extend, out operandType);
GroboIL il = context.Il;
if (node.NodeType == ExpressionType.IsTrue || node.NodeType == ExpressionType.IsFalse)
{
if (!operandType.IsNullable())
{
if (node.Method != null)
{
il.Call(node.Method);
}
else if (operandType == typeof(bool))
{
if (node.NodeType == ExpressionType.IsFalse)
{
il.Ldc_I4(1);
il.Xor();
}
}
else
{
throw new InvalidOperationException("Cannot perform operation '" + node.NodeType + "' to a type '" + operandType + "'");
}
}
else
{
using (var temp = context.DeclareLocal(operandType))
{
il.Stloc(temp);
il.Ldloca(temp);
context.EmitHasValueAccess(operandType);
var returnFalseLabel = il.DefineLabel("returnFalse");
il.Brfalse(returnFalseLabel);
il.Ldloca(temp);
context.EmitValueAccess(operandType);
if (node.Method != null)
{
il.Call(node.Method);
}
else if (operandType == typeof(bool?))
{
if (node.NodeType == ExpressionType.IsFalse)
{
il.Ldc_I4(1);
il.Xor();
}
}
else
{
throw new InvalidOperationException("Cannot perform operation '" + node.NodeType + "' to a type '" + operandType + "'");
}
var doneLabel = il.DefineLabel("done");
il.Br(doneLabel);
context.MarkLabelAndSurroundWithSP(returnFalseLabel);
il.Ldc_I4(0);
context.MarkLabelAndSurroundWithSP(doneLabel);
}
}
}
else
{
if (!operandType.IsNullable())
{
if (node.Method != null)
{
il.Call(node.Method);
}
else
{
if (operandType.IsStruct())
{
throw new InvalidOperationException("Cannot perform operation '" + node.NodeType + "' to a struct '" + operandType + "'");
}
switch (node.NodeType)
{
case ExpressionType.UnaryPlus:
break;
case ExpressionType.Negate:
il.Neg();
break;
case ExpressionType.NegateChecked:
using (var temp = context.DeclareLocal(operandType))
{
il.Stloc(temp);
il.Ldc_I4(0);
context.EmitConvert(typeof(int), operandType);
il.Ldloc(temp);
il.Sub_Ovf(operandType.Unsigned());
}
break;
case ExpressionType.Increment:
il.Ldc_I4(1);
context.EmitConvert(typeof(int), operandType);
il.Add();
break;
case ExpressionType.Decrement:
il.Ldc_I4(1);
context.EmitConvert(typeof(int), operandType);
il.Sub();
break;
case ExpressionType.OnesComplement:
il.Not();
break;
default:
throw new InvalidOperationException("Node type '" + node.NodeType + "' invalid at this point");
}
}
}
else
{
using (var temp = context.DeclareLocal(operandType))
{
il.Stloc(temp);
il.Ldloca(temp);
context.EmitHasValueAccess(operandType);
var returnNullLabel = il.DefineLabel("returnLabel");
il.Brfalse(returnNullLabel);
Type argumentType = operandType.GetGenericArguments()[0];
if (node.Method != null)
{
il.Ldloca(temp);
context.EmitValueAccess(operandType);
il.Call(node.Method);
}
else
{
switch (node.NodeType)
{
case ExpressionType.UnaryPlus:
il.Ldloca(temp);
context.EmitValueAccess(operandType);
break;
case ExpressionType.Negate:
il.Ldloca(temp);
context.EmitValueAccess(operandType);
il.Neg();
break;
case ExpressionType.NegateChecked:
il.Ldc_I4(0);
context.EmitConvert(typeof(int), argumentType);
il.Ldloca(temp);
context.EmitValueAccess(operandType);
il.Sub_Ovf(argumentType.Unsigned());
break;
case ExpressionType.Increment:
il.Ldloca(temp);
context.EmitValueAccess(operandType);
il.Ldc_I4(1);
context.EmitConvert(typeof(int), argumentType);
il.Add();
break;
case ExpressionType.Decrement:
il.Ldloca(temp);
context.EmitValueAccess(operandType);
il.Ldc_I4(1);
context.EmitConvert(typeof(int), argumentType);
il.Sub();
break;
case ExpressionType.OnesComplement:
il.Ldloca(temp);
context.EmitValueAccess(operandType);
il.Not();
break;
default:
throw new InvalidOperationException("Node type '" + node.NodeType + "' invalid at this point");
}
}
il.Newobj(operandType.GetConstructor(new[] { argumentType }));
var doneLabel = il.DefineLabel("done");
il.Br(doneLabel);
context.MarkLabelAndSurroundWithSP(returnNullLabel);
context.EmitLoadDefaultValue(operandType);
context.MarkLabelAndSurroundWithSP(doneLabel);
}
}
}
resultType = node.Type;
return(result);
}
private KeyValuePair <Delegate, IntPtr> BuildPrimitiveValueReader(ModuleBuilder module, GroBufTypeCode typeCode)
{
var method = new DynamicMethod("Read_" + Type.Name + "_from_" + typeCode + "_" + Guid.NewGuid(), typeof(void), new[] { typeof(IntPtr), Type.MakeByRefType() }, module, true);
using (var il = new GroboIL(method))
{
var expectedTypeCode = GroBufTypeCodeMap.GetTypeCode(Type);
il.Ldarg(1); // stack: [ref result]
if (typeCode == GroBufTypeCode.Decimal)
{
if (expectedTypeCode == GroBufTypeCode.Boolean)
{
il.Ldarg(0); // stack: [ref result, &temp, address]
il.Ldind(typeof(long)); // stack: [ref result, &temp, (long)*address]
il.Ldarg(0); // stack: [ref result, &temp + 8, address]
il.Ldc_I4(8); // stack: [ref result, &temp + 8, address, 8]
il.Add(); // stack: [ref result, &temp + 8, address + 8]
il.Ldind(typeof(long)); // stack: [ref result, &temp + 8, (long)*(address + 8)]
il.Or();
il.Ldc_I4(0); // stack: [ref result, value, 0]
il.Conv <long>();
il.Ceq(); // stack: [ref result, value == 0]
il.Ldc_I4(1); // stack: [ref result, value == 0, 1]
il.Xor(); // stack: [ref result, value != 0]
}
else
{
var temp = il.DeclareLocal(typeof(decimal));
il.Ldloca(temp); // stack: [ref result, &temp]
il.Ldarg(0); // stack: [ref result, &temp, address]
il.Ldind(typeof(long)); // stack: [ref result, &temp, (long)*address]
il.Stind(typeof(long)); // *temp = *address;
il.Ldloca(temp); // stack: [ref result, &temp]
il.Ldc_I4(8); // stack: [ref result, &temp, 8]
il.Add(); // stack: [ref result, &temp + 8]
il.Ldarg(0); // stack: [ref result, &temp + 8, address]
il.Ldc_I4(8); // stack: [ref result, &temp + 8, address, 8]
il.Add(); // stack: [ref result, &temp + 8, address + 8]
il.Ldind(typeof(long)); // stack: [ref result, &temp + 8, (long)*(address + 8)]
il.Stind(typeof(long)); // *(temp + 8) = *(address + 8);
il.Ldloc(temp); // stack: [ref result, ref temp]
switch (expectedTypeCode)
{
case GroBufTypeCode.Int8:
il.Call(decimalToInt8Method); // stack: [ref result, (sbyte)temp]
break;
case GroBufTypeCode.UInt8:
il.Call(decimalToUInt8Method); // stack: [ref result, (byte)temp]
break;
case GroBufTypeCode.Int16:
il.Call(decimalToInt16Method); // stack: [ref result, (short)temp]
break;
case GroBufTypeCode.UInt16:
il.Call(decimalToUInt16Method); // stack: [ref result, (ushort)temp]
break;
case GroBufTypeCode.Int32:
il.Call(decimalToInt32Method); // stack: [ref result, (int)temp]
break;
case GroBufTypeCode.UInt32:
il.Call(decimalToUInt32Method); // stack: [ref result, (uint)temp]
break;
case GroBufTypeCode.Int64:
il.Call(decimalToInt64Method); // stack: [ref result, (long)temp]
break;
case GroBufTypeCode.UInt64:
il.Call(decimalToUInt64Method); // stack: [ref result, (ulong)temp]
break;
case GroBufTypeCode.Single:
il.Call(decimalToSingleMethod); // stack: [ref result, (float)temp]
break;
case GroBufTypeCode.Double:
il.Call(decimalToDoubleMethod); // stack: [ref result, (double)temp]
break;
case GroBufTypeCode.Decimal:
break;
default:
throw new NotSupportedException("Type with type code '" + expectedTypeCode + "' is not supported");
}
}
}
else
{
il.Ldarg(0); // stack: [ref result, address]
EmitReadPrimitiveValue(il, Type == typeof(bool) ? GetTypeCodeForBool(typeCode) : typeCode); // stack: [ref result, value]
if (Type == typeof(bool))
{
il.Conv <long>();
il.Ldc_I4(0); // stack: [ref result, value, 0]
il.Conv <long>();
il.Ceq(); // stack: [ref result, value == 0]
il.Ldc_I4(1); // stack: [ref result, value == 0, 1]
il.Xor(); // stack: [ref result, value != 0]
}
else
{
EmitConvertValue(il, typeCode, expectedTypeCode);
}
}
switch (expectedTypeCode)
{
case GroBufTypeCode.Int8:
case GroBufTypeCode.UInt8:
case GroBufTypeCode.Boolean:
il.Stind(typeof(byte)); // result = value
break;
case GroBufTypeCode.Int16:
case GroBufTypeCode.UInt16:
il.Stind(typeof(short)); // result = value
break;
case GroBufTypeCode.Int32:
case GroBufTypeCode.UInt32:
il.Stind(typeof(int)); // result = value
break;
case GroBufTypeCode.Int64:
case GroBufTypeCode.UInt64:
il.Stind(typeof(long)); // result = value
break;
case GroBufTypeCode.Single:
il.Stind(typeof(float)); // result = value
break;
case GroBufTypeCode.Double:
il.Stind(typeof(double)); // result = value
break;
case GroBufTypeCode.Decimal:
il.Stobj(typeof(decimal)); // result = value
break;
default:
throw new NotSupportedException("Type with type code '" + expectedTypeCode + "' is not supported");
}
il.Ret();
}
var @delegate = method.CreateDelegate(typeof(PrimitiveValueReaderDelegate <>).MakeGenericType(Type));
return(new KeyValuePair <Delegate, IntPtr>(@delegate, GroBufHelpers.ExtractDynamicMethodPointer(method)));
}
public void TestZzz2()
{
var asm = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("foo"), AssemblyBuilderAccess.RunAndSave);
var mod = asm.DefineDynamicModule("mymod", "tmp.dll", true);
var type = mod.DefineType("baz", TypeAttributes.Public | TypeAttributes.Class);
var meth = type.DefineMethod("go", MethodAttributes.Public | MethodAttributes.Static, typeof(int), new[] { typeof(int) });
var document = mod.DefineDocument("TestDebug2.txt", Guid.Empty, Guid.Empty, Guid.Empty); //Expression.SymbolDocument("TestDebug2.txt");
//var di = Expression.DebugInfo(sdi, 2, 2, 2, 13);
//var exp = Expression.Divide(Expression.Constant(2), Expression.Subtract(Expression.Constant(4), Expression.Constant(4)));
//var block = Expression.Block(di, exp);
using (var il = new GroboIL(meth))
{
// nop // []
// nop // []
// ldc.i4.1 // [Int32]
// brfalse ifFalse_7 // []
// nop // []
// ldarg.0 // [Int32]
// br done_10 // [Int32]
//ifFalse_7: // []
// nop // []
// ldarg.0 // [Int32]
//done_10: // [Int32]
// stloc local_0 // []
// nop // []
// ldloc local_0 // [Int32]
// ret // []
// var tst = Expression.Block(Expression.DebugInfo(sdi, 6, 20, 6, 27), Expression.Constant(true));
// var iftrue = Expression.Block(Expression.DebugInfo(sdi, 10, 20, 10, 26), variable);
// var iffalse = Expression.Block(Expression.DebugInfo(sdi, 14, 20, 14, 26), variable);
// var exp = Expression.Condition(tst, iftrue, iffalse);
//
// /*
// var returnTarget = Expression.Label(typeof(int));
// var returnExpression = Expression.Return(returnTarget, exp, typeof(int));
// var returnLabel = Expression.Label(returnTarget, Expression.Constant(0));
// */
//
// var block = Expression.Block(typeof(int), new[] { temp },
// Expression.DebugInfo(sdi, 4, 15, 4, 16), Expression.Assign(temp, exp), Expression.DebugInfo(sdi, 17, 16, 17, 21), temp);
// //var block = Expression.Block(Expression.DebugInfo(sdi, 4, 16, 17, 10), Expression.Assign(temp, exp)));
// var kek = Expression.Lambda(block, variable);
il.MarkSequencePoint(document, 4, 15, 4, 16);
il.Nop();
il.Nop();
il.Ldc_I4(1);
il.MarkSequencePoint(document, 6, 20, 6, 27);
var brFalse = il.DefineLabel("brFalse");
il.Brfalse(brFalse);
il.MarkSequencePoint(document, 10, 20, 10, 26);
il.Nop();
il.Ldarg(0);
il.Ldc_I4(100);
il.Add();
var doneLabel = il.DefineLabel("done");
il.Br(doneLabel);
il.MarkSequencePoint(document, 14, 20, 14, 26);
il.MarkLabel(brFalse);
il.Nop();
il.Ldarg(0);
il.Ldc_I4(10);
il.Add();
il.MarkLabel(doneLabel);
il.MarkSequencePoint(document, 16, 16, 16, 21);
var local = il.DeclareLocal(typeof(int));
il.Stloc(local);
il.Nop();
il.MarkSequencePoint(document, 17, 16, 17, 21);
il.Ldloc(local);
il.Ret();
}
var newtype = type.CreateType();
asm.Save("tmp.dll");
newtype.GetMethod("go").Invoke(null, new object[] { 0 });
//meth.Invoke(null, new object[0]);
//lambda.DynamicInvoke(new object[0]);
Console.WriteLine(" ");
}
public void TestZzz()
{
var asm = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("foo"), AssemblyBuilderAccess.RunAndSave);
var mod = asm.DefineDynamicModule("mymod", "tmp.dll", true);
var type = mod.DefineType("baz", TypeAttributes.Public | TypeAttributes.Class);
var meth = type.DefineMethod("go", MethodAttributes.Public | MethodAttributes.Static, typeof(int), new[] { typeof(int) });
var document = mod.DefineDocument("TestDebug2.txt", Guid.Empty, Guid.Empty, Guid.Empty); //Expression.SymbolDocument("TestDebug2.txt");
meth.DefineParameter(1, ParameterAttributes.In, "$x");
//var di = Expression.DebugInfo(sdi, 2, 2, 2, 13);
//var exp = Expression.Divide(Expression.Constant(2), Expression.Subtract(Expression.Constant(4), Expression.Constant(4)));
//var block = Expression.Block(di, exp);
using (var il = new GroboIL(meth))
{
// var tst = Expression.Block(Expression.DebugInfo(sdi, 6, 20, 6, 27), Expression.Equal(variable, zero));
// var iftrue = Expression.Block(Expression.DebugInfo(sdi, 10, 20, 10, 26), Expression.Add(variable, two));
// var iffalse = Expression.Block(Expression.DebugInfo(sdi, 14, 20, 14, 26), Expression.Divide(variable, two));
// var exp = Expression.Condition(tst, iftrue, iffalse);
// var block = Expression.Block(Expression.DebugInfo(sdi, 4, 16, 15, 10), exp);
// nop // []
// nop // []
// ldarg.0 // [Int32]
// ldc.i4.0 // [Int32, Int32]
// ceq // [Int32]
// brfalse ifFalse_5 // []
// nop // []
// ldarg.0 // [Int32]
// ldc.i4.2 // [Int32, Int32]
// add // [Int32]
// br done_8 // [Int32]
//ifFalse_5: // []
// nop // []
// ldarg.0 // [Int32]
// ldc.i4.2 // [Int32, Int32]
// div // [Int32]
//done_8: // [Int32]
// ret // []
il.MarkSequencePoint(document, 3, 9, 3, 15);
il.Nop();
il.MarkSequencePoint(document, 4, 13, 4, 19);
il.Nop();
il.Ldarg(0);
il.Ldc_I4(0);
il.Ceq();
var label = il.DefineLabel("ifFalse");
il.Brfalse(label);
il.MarkSequencePoint(document, 7, 13, 7, 19);
il.Nop();
il.Ldarg(0);
il.Ldc_I4(2);
il.Add();
var doneLabel = il.DefineLabel("done");
il.Br(doneLabel);
il.MarkLabel(label);
il.MarkSequencePoint(document, 10, 13, 10, 19);
il.Nop();
il.Ldarg(0);
il.Ldc_I4(2);
il.Mul();
il.MarkLabel(doneLabel);
il.MarkSequencePoint(document, 12, 5, 12, 6);
il.Nop();
il.Ret();
}
var newtype = type.CreateType();
asm.Save("tmp.dll");
newtype.GetMethod("go").Invoke(null, new object[] { 0 });
//meth.Invoke(null, new object[0]);
//lambda.DynamicInvoke(new object[0]);
Console.WriteLine(" ");
}
public void GetReadILCode(PropertyData prop, BinaryStruct currentStruct, GroboIL il, GroboIL.Local binaryStruct, GroboIL.Local buffer, GroboIL.Local result, GroboIL.Local typeSize, GroboIL.Local offset, bool listValue)
{
var exitLabel = il.DefineLabel("exit");
BinaryStruct.ReadObjectNull(il, exitLabel, buffer, offset, typeSize);
var len = il.DeclareLocal(typeof(int));
var list = il.DeclareLocal(prop.PropertyInfo.PropertyType);
il.Ldloc(buffer);
il.Ldloc(offset);
il.Call(readBitConverterMethodInfo);
il.Stloc(len);
BinaryStruct.WriteOffsetAppend(il, offset, 4);
il.Newobj(BinaryStruct.GetConstructor(prop.PropertyInfo.PropertyType, null));
il.Stloc(list);
il.Ldloc(result);
il.Ldloc(list);
il.Call(prop.Setter, isVirtual: true);
il.Ldloc(len);
il.Ldc_I4(0);
il.Ceq();
il.Brtrue(exitLabel);
var typeKey = prop.PropertyInfo.PropertyType.GetGenericArguments()[0];
var typeValue = prop.PropertyInfo.PropertyType.GetGenericArguments()[1];
var ivar = il.DeclareLocal(typeof(int));
var currentItemKey = il.DeclareLocal(typeKey);
var currentItemValue = il.DeclareLocal(typeValue);
var point = il.DefineLabel("for_label");
il.Ldc_I4(0);
il.Stloc(ivar);
il.MarkLabel(point);
//body
//key
if (typeof(IBasicType).IsAssignableFrom(prop.BinaryAttr.Type.GetGenericArguments()[0]))
{
IBasicType t = (IBasicType)Activator.CreateInstance(prop.BinaryAttr.Type.GetGenericArguments()[0]);
t.GetReadILCode(prop, currentStruct, il, binaryStruct, buffer, currentItemKey, typeSize, offset, true);
}
else
{
var constr = BinaryStruct.GetConstructor(typeKey, null);
if (constr == null)
{
throw new Exception($"Type {typeKey} not have constructor with not parameters");
}
il.Newobj(constr);
il.Stloc(currentItemKey);
BinaryStruct.CompileReader(currentStruct.CurrentStorage.GetTypeInfo(typeKey, currentStruct.Scheme), il, binaryStruct, buffer, offset, currentItemKey, typeSize);
}
//value
if (typeof(IBasicType).IsAssignableFrom(prop.BinaryAttr.Type.GetGenericArguments()[1]))
{
IBasicType t = (IBasicType)Activator.CreateInstance(prop.BinaryAttr.Type.GetGenericArguments()[1]);
t.GetReadILCode(prop, currentStruct, il, binaryStruct, buffer, currentItemValue, typeSize, offset, true);
}
else
{
var constr = BinaryStruct.GetConstructor(typeValue, null);
if (constr == null)
{
throw new Exception($"Type {typeValue} not have constructor with not parameters");
}
il.Newobj(constr);
il.Stloc(currentItemValue);
BinaryStruct.CompileReader(currentStruct.CurrentStorage.GetTypeInfo(typeValue, currentStruct.Scheme), il, binaryStruct, buffer, offset, currentItemValue, typeSize);
}
il.Ldloc(list);
il.Ldloc(currentItemKey);
il.Ldloc(currentItemValue);
il.Call(prop.PropertyInfo.PropertyType.GetMethod("Add"), isVirtual: true);
//end body
il.Ldc_I4(1);
il.Ldloc(ivar);
il.Add();
il.Stloc(ivar);
il.Ldloc(ivar);
il.Ldloc(len);
il.Clt(false);
il.Brtrue(point);
il.MarkLabel(exitLabel);
}
public void GetWriteILCode(PropertyData prop, BinaryStruct currentStruct, GroboIL il, GroboIL.Local binaryStruct, GroboIL.Local value, GroboIL.Local typeSize, GroboIL.Local buffer, GroboIL.Local offset, bool listValue)
{
var arr = il.DeclareLocal(prop.PropertyInfo.PropertyType);
var len = il.DeclareLocal(typeof(int));
if (prop.PropertyInfo != null)
{
il.Ldloc(value);
il.Call(prop.ArraySizeProperty.Getter);
il.Stloc(len);
}
else
{
il.Ldc_I4(prop.ArraySize);
il.Stloc(len);
}
il.Ldloc(value);
il.Call(prop.Getter);
il.Stloc(arr);
var typeKey = prop.PropertyInfo.PropertyType.GetGenericArguments()[0];
var typeValue = prop.PropertyInfo.PropertyType.GetGenericArguments()[1];
var ivar = il.DeclareLocal(typeof(int));
var currentItemKey = il.DeclareLocal(typeKey);
var currentItemValue = il.DeclareLocal(typeValue);
var point = il.DefineLabel("for_label");
il.Ldc_I4(0);
il.Stloc(ivar);
var enumeratorMethod = prop.PropertyInfo.PropertyType.GetMethod("GetEnumerator");
var enumerator = il.DeclareLocal(enumeratorMethod.ReturnType);
var moveNext = enumerator.Type.GetMethod("MoveNext");
var getCurrent = enumerator.Type.GetMethod("get_Current");
var temp = il.DeclareLocal(getCurrent.ReturnType);
var exist = il.DeclareLocal(typeof(bool));
il.Ldloc(arr);
il.Call(enumeratorMethod, isVirtual: true);
il.Stloc(enumerator);
var keyGetter = getCurrent.ReturnType.GetMethod("get_Key");
var valueGetter = getCurrent.ReturnType.GetMethod("get_Value");
il.MarkLabel(point);
//body
il.Ldloca(enumerator);
il.Call(moveNext, enumerator.Type);
il.Stloc(exist);
il.Ldloca(enumerator);
//il.Calli(CallingConventions.Any, typeof(KeyValuePair<int, int>),new Type[] { typeof(int),typeof(int) });
il.Call(getCurrent, enumerator.Type);
il.Stloc(temp);
il.Ldloca(temp);
il.Call(keyGetter, typeof(int));
il.Stloc(currentItemKey);
if (typeof(IBasicType).IsAssignableFrom(prop.BinaryAttr.Type.GetGenericArguments()[0]))
{
IBasicType t = (IBasicType)Activator.CreateInstance(prop.BinaryAttr.Type.GetGenericArguments()[0]);
t.GetWriteILCode(prop, currentStruct, il, binaryStruct, currentItemKey, typeSize, buffer, offset, true);
}
else
{
BinaryStruct.CompileWriter(currentStruct.CurrentStorage.GetTypeInfo(typeKey, currentStruct.Scheme), il, binaryStruct, currentItemKey, buffer, offset, typeSize);
}
il.Ldloca(temp);
il.Call(valueGetter);
il.Stloc(currentItemValue);
if (typeof(IBasicType).IsAssignableFrom(prop.BinaryAttr.Type.GetGenericArguments()[1]))
{
IBasicType t = (IBasicType)Activator.CreateInstance(prop.BinaryAttr.Type.GetGenericArguments()[1]);
t.GetWriteILCode(prop, currentStruct, il, binaryStruct, currentItemValue, typeSize, buffer, offset, true);
}
else
{
BinaryStruct.CompileWriter(currentStruct.CurrentStorage.GetTypeInfo(typeValue, currentStruct.Scheme), il, binaryStruct, currentItemValue, buffer, offset, typeSize);
}
//end body
il.Ldc_I4(1);
il.Ldloc(ivar);
il.Add();
il.Stloc(ivar);
il.Ldloc(ivar);
il.Ldloc(len);
il.Clt(false);
il.Brtrue(point);
}
public void GetWriteILCode(PropertyData prop, BinaryStruct currentStruct, GroboIL il, GroboIL.Local binaryStruct, GroboIL.Local value, GroboIL.Local typeSize, GroboIL.Local buffer, GroboIL.Local offset, bool listValue)
{
var arr = il.DeclareLocal(prop.PropertyInfo.PropertyType);
var len = il.DeclareLocal(typeof(int));
if (prop.PropertyInfo != null)
{
il.Ldloc(value);
il.Call(prop.ArraySizeProperty.Getter);
il.Stloc(len);
}
else
{
il.Ldc_I4(prop.ArraySize);
il.Stloc(len);
}
il.Ldloc(value);
il.Call(prop.Getter);
il.Stloc(arr);
var type = prop.PropertyInfo.PropertyType.GetGenericArguments()[0];
var ivar = il.DeclareLocal(typeof(int));
var currentValue = il.DeclareLocal(type);
var point = il.DefineLabel("for_label");
il.Ldc_I4(0);
il.Stloc(ivar);
il.MarkLabel(point);
//body
il.Ldloc(arr);
il.Ldloc(ivar);
il.Call(prop.PropertyInfo.PropertyType.GetMethod("get_Item"), isVirtual: true);
il.Stloc(currentValue);
if (typeof(IBasicType).IsAssignableFrom(prop.BinaryAttr.Type.GetGenericArguments()[0]))
{
IBasicType t = (IBasicType)Activator.CreateInstance(prop.BinaryAttr.Type.GetGenericArguments()[0]);
t.GetWriteILCode(prop, currentStruct, il, binaryStruct, currentValue, typeSize, buffer, offset, true);
}
else
{
BinaryStruct.CompileWriter(currentStruct.CurrentStorage.GetTypeInfo(type, currentStruct.Scheme), il, binaryStruct, currentValue, buffer, offset, typeSize);
}
//end body
il.Ldc_I4(1);
il.Ldloc(ivar);
il.Add();
il.Stloc(ivar);
il.Ldloc(ivar);
il.Ldloc(len);
il.Clt(false);
il.Brtrue(point);
}
public void GetWriteILCode(PropertyData prop, BinaryStruct currentStruct, GroboIL il, GroboIL.Local binaryStruct, GroboIL.Local value, GroboIL.Local typeSize, GroboIL.Local buffer, GroboIL.Local offset, bool listValue)
{
var arr = il.DeclareLocal(prop.PropertyInfo.PropertyType);
il.Ldloc(value);
il.Call(prop.Getter);
il.Stloc(arr);
var exitLabel = il.DefineLabel("exit");
BinaryStruct.WriteSizeChecker(il, buffer, offset, 5);
BinaryStruct.WriteObjectNull(il, exitLabel, arr, buffer, offset, typeSize);
var arrSize = il.DeclareLocal(typeof(byte[]));
var len = il.DeclareLocal(typeof(int));
il.Ldloc(value);
il.Call(prop.Getter);
il.Call(typeof(ICollection).GetProperty("Count").GetMethod);
il.Stloc(len);
il.Ldloc(len);
il.Call(writeBitConverterMethodInfo);
il.Stloc(arrSize);
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldloc(arrSize);
il.Ldc_I4(0);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
for (int i = 1; i < 4; i++)
{
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldc_I4(i);
il.Add();
il.Ldloc(arrSize);
il.Ldc_I4(i);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
}
BinaryStruct.WriteOffsetAppend(il, offset, 4);
il.Ldloc(len);
il.Ldc_I4(0);
il.Ceq();
il.Brtrue(exitLabel);
var type = prop.PropertyInfo.PropertyType.GetElementType();
var ivar = il.DeclareLocal(typeof(int));
var currentValue = il.DeclareLocal(type);
var point = il.DefineLabel("for_label");
il.Ldc_I4(0);
il.Stloc(ivar);
il.MarkLabel(point);
//body
il.Ldloc(arr);
il.Ldloc(ivar);
il.Ldelem(type);
//il.Call(prop.PropertyInfo.PropertyType.GetMethod("Get"), isVirtual: true);
il.Stloc(currentValue);
if (typeof(IBasicType).IsAssignableFrom(prop.BinaryAttr.Type.GetGenericArguments()[0]))
{
IBasicType t = (IBasicType)Activator.CreateInstance(prop.BinaryAttr.Type.GetGenericArguments()[0]);
t.GetWriteILCode(prop, currentStruct, il, binaryStruct, currentValue, typeSize, buffer, offset, true);
}
else
{
BinaryStruct.CompileWriter(currentStruct.CurrentStorage.GetTypeInfo(type, currentStruct.Scheme), il, binaryStruct, currentValue, buffer, offset, typeSize);
}
//end body
il.Ldc_I4(1);
il.Ldloc(ivar);
il.Add();
il.Stloc(ivar);
il.Ldloc(ivar);
il.Ldloc(len);
il.Clt(false);
il.Brtrue(point);
il.MarkLabel(exitLabel);
}
internal static void Resize(GroboIL il, GroboIL.Local buffer, GroboIL.Local offset /*, GroboIL.Local len*/)
{
var totalLen = il.DeclareLocal(typeof(int));
//offset add typesize = minSize
il.Ldloc(offset);
il.Add();
il.Stloc(totalLen);
var exit = il.DefineLabel("exit");
//Compare if minSize < buffer.len
il.Ldloc(totalLen);
il.Ldloc(buffer);
il.Ldlen();
il.Clt(false);
il.Brtrue(exit);
var avar = il.DeclareLocal(typeof(byte));
il.Ldc_I4(2);
il.Stloc(avar);
var point = il.DefineLabel("for_label");
il.MarkLabel(point);
//body
il.Ldloc(avar);
il.Ldc_I4(2);
il.Mul();
il.Stloc(avar);
//end body
il.Ldloc(buffer);
il.Ldlen();
il.Ldloc(avar);
il.Mul();
//OutputValue(il,typeof(int));
il.Ldloc(totalLen);
//OutputValue(il, typeof(int));
il.Clt(false);
//OutputValue(il, typeof(bool));
il.Brtrue(point);
il.Ldloca(buffer);
il.Ldloc(avar);
il.Ldloc(buffer);
il.Ldlen();
il.Mul();
//OutputValue(il, typeof(int));
il.Call(typeof(Array).GetMethod("Resize", BindingFlags.Public | BindingFlags.Static).MakeGenericMethod(typeof(byte)));
il.MarkLabel(exit);
}
public static bool Emit(Expression zarr, Expression zindex, EmittingContext context, GroboIL.Label returnDefaultValueLabel, ResultType whatReturn, bool extend, out Type resultType)
{
var arrayType = zarr.Type;
var isArray = arrayType.IsArray;
if (!isArray && !arrayType.IsList())
{
throw new InvalidOperationException("Unable to perform array index operator to type '" + arrayType + "'");
}
var itemType = isArray ? arrayType.GetElementType() : arrayType.GetGenericArguments()[0];
GroboIL il = context.Il;
EmittingContext.LocalHolder arrayIndex = null;
bool extendArray = extend && (CanAssign(zarr) || !isArray);
bool extendArrayElement = extend && itemType.IsClass;
var result = false;
if (!extendArray)
{
result |= ExpressionEmittersCollection.Emit(zarr, context, returnDefaultValueLabel, ResultType.Value, extend, out arrayType); // stack: [array]
if (context.Options.HasFlag(CompilerOptions.CheckNullReferences))
{
result = true;
il.Dup(); // stack: [array, array]
il.Brfalse(returnDefaultValueLabel); // if(array == null) goto returnDefaultValue; stack: [array]
}
EmitLoadIndex(zindex, context, arrayType); // stack: [array, arrayIndex]
if (context.Options.HasFlag(CompilerOptions.CheckArrayIndexes))
{
result = true;
arrayIndex = context.DeclareLocal(typeof(int));
il.Stloc(arrayIndex); // arrayIndex = index; stack: [array]
il.Dup(); // stack: [array, array]
if (isArray)
{
il.Ldlen(); // stack: [array, array.Length]
}
else
{
EmitLoadField(context, arrayType, arrayType.GetField("_size", BindingFlags.Instance | BindingFlags.NonPublic));
}
il.Ldloc(arrayIndex); // stack: [array, array.Length, arrayIndex]
il.Ble(returnDefaultValueLabel, false); // if(array.Length <= arrayIndex) goto returnDefaultValue; stack: [array]
il.Ldloc(arrayIndex); // stack: [array, arrayIndex]
il.Ldc_I4(0); // stack: [array, arrayIndex, 0]
il.Blt(returnDefaultValueLabel, false); // if(arrayIndex < 0) goto returnDefaultValue; stack: [array]
}
else if (extendArrayElement || !isArray)
{
arrayIndex = context.DeclareLocal(typeof(int));
il.Stloc(arrayIndex); // arrayIndex = index; stack: [array]
}
}
else
{
EmittingContext.LocalHolder arrayOwner = null;
switch (zarr.NodeType)
{
case ExpressionType.Parameter:
case ExpressionType.ArrayIndex:
case ExpressionType.Index:
Type type;
ExpressionEmittersCollection.Emit(zarr, context, returnDefaultValueLabel, ResultType.ByRefAll, true, out type); // stack: [ref array]
arrayOwner = context.DeclareLocal(type);
il.Dup(); // stack: [ref array, ref array]
il.Stloc(arrayOwner); // arrayOwner = ref array; stack: [ref array]
il.Ldind(zarr.Type); // stack: [array]
break;
case ExpressionType.MemberAccess:
var memberExpression = (MemberExpression)zarr;
Type memberType;
context.EmitMemberAccess(memberExpression, returnDefaultValueLabel, context.Options.HasFlag(CompilerOptions.CheckNullReferences), true, ResultType.ByRefValueTypesOnly, out memberType, out arrayOwner); // stack: [array]
break;
default:
throw new InvalidOperationException("Cannot extend array for expression with node type '" + zarr.NodeType + "'");
}
if (context.Options.HasFlag(CompilerOptions.CheckNullReferences))
{
il.Dup(); // stack: [array, array]
il.Brfalse(returnDefaultValueLabel); // if(array == null) goto returnDefaultValue; stack: [array]
}
EmitLoadIndex(zindex, context, arrayType);
result = true;
arrayIndex = context.DeclareLocal(typeof(int));
il.Stloc(arrayIndex); // arrayIndex = index; stack: [array]
il.Ldloc(arrayIndex); // stack: [array, arrayIndex]
il.Ldc_I4(0); // stack: [array, arrayIndex, 0]
il.Blt(returnDefaultValueLabel, false); // if(arrayIndex < 0) goto returnDefaultValue; stack: [array]
il.Dup(); // stack: [array, array]
if (isArray)
{
il.Ldlen(); // stack: [array, array.Length]
}
else
{
EmitLoadField(context, arrayType, arrayType.GetField("_size", BindingFlags.Instance | BindingFlags.NonPublic));
}
il.Ldloc(arrayIndex); // stack: [array, array.Length, arrayIndex]
var bigEnoughLabel = il.DefineLabel("bigEnough");
il.Bgt(bigEnoughLabel, false); // if(array.Length > arrayIndex) goto bigEnough; stack: [array]
using (var array = context.DeclareLocal(arrayType))
{
il.Stloc(array); // stack: []
if (!isArray)
{
EnsureCount(context, array, arrayIndex, arrayType);
}
else
{
il.Ldloca(array); // stack: [ref array]
il.Ldloc(arrayIndex); // stack: [ref array, arrayIndex]
il.Ldc_I4(1); // stack: [ref array, arrayIndex, 1]
il.Add(); // stack: [ref array, arrayIndex + 1]
il.Call(arrayResizeMethod.MakeGenericMethod(arrayType.GetElementType())); // Array.Resize(ref array, 1 + arrayIndex); stack: []
switch (zarr.NodeType)
{
case ExpressionType.Parameter:
case ExpressionType.ArrayIndex:
case ExpressionType.Index:
il.Ldloc(arrayOwner); // stack: [ref parameter]
il.Ldloc(array); // stack: [ref parameter, array]
il.Stind(arrayType); // parameter = array; stack: []
break;
case ExpressionType.MemberAccess:
var memberExpression = (MemberExpression)zarr;
if (memberExpression.Expression != null)
{
il.Ldloc(arrayOwner);
}
il.Ldloc(array);
switch (memberExpression.Member.MemberType)
{
case MemberTypes.Field:
il.Stfld((FieldInfo)memberExpression.Member);
break;
case MemberTypes.Property:
var propertyInfo = (PropertyInfo)memberExpression.Member;
var setter = propertyInfo.GetSetMethod(context.SkipVisibility);
if (setter == null)
{
throw new MissingMethodException(propertyInfo.ReflectedType.ToString(), "set_" + propertyInfo.Name);
}
il.Call(setter, memberExpression.Expression == null ? null : memberExpression.Expression.Type);
break;
default:
throw new NotSupportedException("Member type '" + memberExpression.Member.MemberType + "' is not supported");
}
break;
default:
throw new InvalidOperationException("Unable to assign array to an expression with node type '" + zarr.NodeType);
}
}
il.Ldloc(array);
context.MarkLabelAndSurroundWithSP(bigEnoughLabel);
}
}
if (!isArray)
{
// TODO: это злобно, лист при всех операциях меняет _version, а мы нет
EmitLoadField(context, arrayType, arrayType.GetField("_items", BindingFlags.Instance | BindingFlags.NonPublic));
arrayType = itemType.MakeArrayType();
}
if (extendArrayElement)
{
// stack: [array]
var constructor = itemType.GetConstructor(Type.EmptyTypes);
if (itemType.IsArray || constructor != null)
{
using (var array = context.DeclareLocal(arrayType))
{
il.Dup(); // stack: [array, array]
il.Stloc(array); // stack: [array]
il.Ldloc(arrayIndex); // stack: [array, arrayIndex]
il.Ldelem(itemType); // stack: [array[arrayIndex]]
var elementIsNotNullLabel = il.DefineLabel("elementIsNotNull");
il.Brtrue(elementIsNotNullLabel);
il.Ldloc(array);
il.Ldloc(arrayIndex);
context.Create(itemType);
il.Stelem(itemType);
context.MarkLabelAndSurroundWithSP(elementIsNotNullLabel);
il.Ldloc(array);
}
}
}
if (arrayIndex != null)
{
il.Ldloc(arrayIndex);
arrayIndex.Dispose();
}
switch (whatReturn)
{
case ResultType.ByRefAll:
il.Ldelema(itemType);
resultType = itemType.MakeByRefType();
break;
case ResultType.ByRefValueTypesOnly:
if (itemType.IsValueType)
{
il.Ldelema(itemType);
resultType = itemType.MakeByRefType();
}
else
{
il.Ldelem(itemType); // stack: [array[arrayIndex]]
resultType = itemType;
}
break;
default:
il.Ldelem(itemType); // stack: [array[arrayIndex]]
resultType = itemType;
break;
}
return(result);
}
public void TestLocalloc()
{
// private static unsafe int GetSum(byte length)
// {
// byte* bytes = stackalloc byte[length];
// for (byte i = 0; i < length; ++i)
// {
// bytes[i] = i;
// }
// int sum = 0;
// for (byte i = 0; i < length; ++i)
// {
// sum += bytes[i];
// }
// return sum;
// }
var method = new DynamicMethod(Guid.NewGuid().ToString(), typeof(int), new[] { typeof(byte) }, typeof(Test));
using (var il = new GroboIL(method))
{
il.Ldarg(0); // stack: [length]
il.Conv <UIntPtr>();
il.Localloc(); // stack: [*pointer]
var pointer = il.DeclareLocal(typeof(UIntPtr));
il.Stloc(pointer); // pointer = value; stack: []
il.Ldc_I4(0); // stack: [0]
var i = il.DeclareLocal(typeof(byte));
il.Stloc(i); // i = 0; stack: []
var loop1Start = il.DefineLabel("loop1_start");
var loop1End = il.DefineLabel("loop1_end");
il.MarkLabel(loop1Start);
{
il.Ldloc(i); // stack: [i]
il.Ldarg(0); // stack: [i, length]
il.Bge(loop1End, unsigned: true); // if (i >= length) goto end; stack: []
il.Ldloc(pointer); //stack: [pointer]
il.Ldloc(i); // stack: [pointer, i]
il.Add(); // stack: [pointer + i]
il.Ldloc(i); // stack: [pointer + i, i]
il.Stind(typeof(byte)); // *(pointer + i) = i; stack: []
il.Ldloc(i); // stack: [i]
il.Ldc_I4(1); // stack: [i, 1]
il.Add(); // stack: [i + 1]
il.Conv <byte>();
il.Stloc(i); // i = i + 1; stack: []
il.Br(loop1Start);
}
il.MarkLabel(loop1End);
il.Ldc_I4(0); // stack: [0]
il.Dup(); // stack: [0, 0]
var sum = il.DeclareLocal(typeof(int));
il.Stloc(sum); // sum = 0; stack: [0]
il.Stloc(i); // i = 0; stack: []
var loop2Start = il.DefineLabel("loop2_start");
var loop2End = il.DefineLabel("loop2_end");
il.MarkLabel(loop2Start);
{
il.Ldloc(i); // stack: [i]
il.Ldarg(0); // stack: [i, length]
il.Bge(loop2End, unsigned: true); // if i >= length goto end; stack:[]
il.Ldloc(pointer); // stack: [pointer]
il.Ldloc(i); // stack: [pointer, i]
il.Add(); // stack: [pointer + i]
il.Ldind(typeof(byte)); // stack: [*(pointer + i)]
il.Ldloc(sum); // stack: [*(pointer + i), sum]
il.Add(); // stack: [*(pointer + i) + sum]
il.Stloc(sum); // sum = *(pointer + i) + sum; stack: []
il.Ldloc(i); // stack: [i]
il.Ldc_I4(1); // stack: [i, 1]
il.Add(); // stack: [i + 1]
il.Conv <byte>();
il.Stloc(i); // i = (i + 1); // stack: []
il.Br(loop2Start);
}
il.MarkLabel(loop2End);
il.Ldloc(sum); // stack: [sum]
il.Ret();
}
var func = (Func <byte, int>)method.CreateDelegate(typeof(Func <byte, int>));
Assert.That(func(6), Is.EqualTo(15));
}
public void BuildReader(ReaderTypeBuilderContext readerTypeBuilderContext)
{
var method = new DynamicMethod("Read_" + Type.Name + "_" + Guid.NewGuid(), typeof(void),
new[]
{
typeof(IntPtr), typeof(int).MakeByRefType(), Type.MakeByRefType(), typeof(ReaderContext)
}, readerTypeBuilderContext.Module, true);
readerTypeBuilderContext.SetReaderMethod(Type, method);
using (var il = new GroboIL(method))
{
var context = new ReaderMethodBuilderContext(readerTypeBuilderContext, il, !Type.IsValueType && IsReference);
ReadTypeCodeAndCheck(context); // Read TypeCode and check
if (!Type.IsValueType && IsReference)
{
// Read reference
context.LoadContext(); // stack: [context]
il.Ldfld(ReaderContext.ObjectsField); // stack: [context.objects]
var notReadLabel = il.DefineLabel("notRead");
il.Brfalse(notReadLabel);
context.LoadIndex(); // stack: [external index]
context.LoadContext(); // stack: [external index, context]
il.Ldfld(ReaderContext.StartField); // stack: [external index, context.start]
il.Sub(); // stack: [external index - context.start]
il.Stloc(context.Index); // index = external index - context.start; stack: []
context.LoadContext(); // stack: [context]
il.Ldfld(ReaderContext.ObjectsField); // stack: [context.objects]
il.Ldloc(context.Index); // stack: [context.objects, index]
var obj = il.DeclareLocal(typeof(object));
il.Ldloca(obj);
object dummy;
il.Call(HackHelpers.GetMethodDefinition <Dictionary <int, object> >(dict => dict.TryGetValue(0, out dummy))); // stack: [context.objects.TryGetValue(index, out obj)]
il.Brfalse(notReadLabel); // if(!context.objects.TryGetValue(index, out obj)) goto notRead;
context.LoadResultByRef(); // stack: [ref result]
il.Ldloc(obj); // stack: [ref result, obj]
il.Castclass(Type); // stack: [ref result, (Type)obj]
il.Stind(Type); // result = (Type)obj; stack: []
context.IncreaseIndexBy1(); // Skip type code
context.SkipValue(); // Skip value - it has already been read
il.Ret();
il.MarkLabel(notReadLabel);
il.Ldloc(context.TypeCode); // stack: [typeCode]
il.Ldc_I4((int)GroBufTypeCode.Reference); // stack: [typeCode, GroBufTypeCode.Reference]
var readUsualLabel = il.DefineLabel("readUsual");
il.Bne_Un(readUsualLabel); // if(typeCode != GroBufTypeCode.Reference) goto readUsual; stack: []
context.LoadContext(); // stack: [context]
il.Ldfld(ReaderContext.ObjectsField); // stack: [context.objects]
var objectsIsNotNullLabel = il.DefineLabel("objectsIsNotNull");
il.Brtrue(objectsIsNotNullLabel); // if(context.objects != null) goto objectsIsNotNull; stack: [context.objects]
il.Ldstr("Reference is not valid at this point");
il.Newobj(typeof(DataCorruptedException).GetConstructor(new[] { typeof(string) }));
il.Throw();
il.MarkLabel(objectsIsNotNullLabel);
context.IncreaseIndexBy1(); // index = index + 1; stack: []
il.Ldc_I4(4);
context.AssertLength();
context.GoToCurrentLocation();
var reference = il.DeclareLocal(typeof(int));
il.Ldind(typeof(int)); // stack: [*(int*)data[index]]
il.Stloc(reference); // reference = *(int*)data[index]; stack: []
context.IncreaseIndexBy4(); // index = index + 4; stack: []
il.Ldloc(context.Index); // stack: [index]
il.Ldloc(reference); // stack: [index, reference]
var goodReferenceLabel = il.DefineLabel("goodReference");
il.Bgt(goodReferenceLabel, false); // if(index > reference) goto goodReference; stack: []
il.Ldstr("Bad reference");
il.Newobj(typeof(DataCorruptedException).GetConstructor(new[] { typeof(string) }));
il.Throw();
il.MarkLabel(goodReferenceLabel);
context.LoadContext(); // stack: [context]
il.Ldfld(ReaderContext.ObjectsField); // stack: [context.objects]
il.Ldloc(reference); // stack: [context.objects, reference]
il.Ldloca(obj); // stack: [context.objects, reference, ref obj]
il.Call(HackHelpers.GetMethodDefinition <Dictionary <int, object> >(dict => dict.TryGetValue(0, out dummy))); // stack: [context.objects.TryGetValue(reference, out obj)]
var readObjectLabel = il.DefineLabel("readObject");
il.Brfalse(readObjectLabel); // if(!context.objects.TryGetValue(reference, out obj)) goto readObjects; stack: []
context.LoadResultByRef(); // stack: [ref result]
il.Ldloc(obj); // stack: [ref result, obj]
il.Castclass(Type); // stack: [ref result, (Type)obj]
il.Stind(Type); // result = (Type)obj; stack: []
il.Ret();
il.MarkLabel(readObjectLabel);
// Referenced object has not been read - this means that the object reference belongs to is a property that had been deleted
context.LoadData(); // stack: [data]
il.Ldloc(reference); // stack: [data, reference]
context.LoadContext(); // stack: [data, reference, context]
il.Ldfld(ReaderContext.StartField); // stack: [data, reference, context.start]
il.Add(); // stack: [data, reference + context.start]
il.Stloc(reference); // reference += context.start; stack: [data]
il.Ldloca(reference); // stack: [data, ref reference]
context.LoadResultByRef(); // stack: [data, ref reference, ref result]
context.LoadContext(); // stack: [data, ref reference, ref result, context]
context.CallReader(Type);
il.Ret();
il.MarkLabel(readUsualLabel);
}
ReadNotEmpty(context); // Read obj
il.Ret();
}
var @delegate = method.CreateDelegate(typeof(ReaderDelegate <>).MakeGenericType(Type));
var pointer = GroBufHelpers.ExtractDynamicMethodPointer(method);
readerTypeBuilderContext.SetReaderPointer(Type, pointer, @delegate);
}
public void GetWriteILCode(PropertyData prop, BinaryStruct currentStruct, GroboIL il, GroboIL.Local binaryStruct, GroboIL.Local value, GroboIL.Local typeSize, GroboIL.Local buffer, GroboIL.Local offset, bool listValue)
{
var arr = il.DeclareLocal(prop.PropertyInfo.PropertyType);
il.Ldloc(value);
il.Call(prop.Getter);
il.Stloc(arr);
var exitLabel = il.DefineLabel("exit");
BinaryStruct.WriteSizeChecker(il, buffer, offset, 3);
BinaryStruct.WriteObjectNull(il, exitLabel, arr, buffer, offset, typeSize);
var arrSize = il.DeclareLocal(typeof(byte[]));
var len = il.DeclareLocal(typeof(short));
il.Ldloc(value);
il.Call(prop.Getter);
il.Call(typeof(ICollection).GetProperty("Count").GetMethod);
il.Stloc(len);
il.Ldloc(len);
il.Call(writeBitConverterMethodInfo);
il.Stloc(arrSize);
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldloc(arrSize);
il.Ldc_I4(0);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
for (int i = 1; i < 2; i++)
{
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldc_I4(i);
il.Add();
il.Ldloc(arrSize);
il.Ldc_I4(i);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
}
BinaryStruct.WriteOffsetAppend(il, offset, 2);
il.Ldloc(len);
il.Ldc_I4(0);
il.Ceq();
il.Brtrue(exitLabel);
var typeKey = prop.PropertyInfo.PropertyType.GetGenericArguments()[0];
var typeValue = prop.PropertyInfo.PropertyType.GetGenericArguments()[1];
var ivar = il.DeclareLocal(typeof(int));
var currentItemKey = il.DeclareLocal(typeKey);
var currentItemValue = il.DeclareLocal(typeValue);
var point = il.DefineLabel("for_label");
il.Ldc_I4(0);
il.Stloc(ivar);
var enumeratorMethod = prop.PropertyInfo.PropertyType.GetMethod("GetEnumerator");
var enumerator = il.DeclareLocal(enumeratorMethod.ReturnType);
var moveNext = enumerator.Type.GetMethod("MoveNext");
var getCurrent = enumerator.Type.GetMethod("get_Current");
var temp = il.DeclareLocal(getCurrent.ReturnType);
var exist = il.DeclareLocal(typeof(bool));
il.Ldloc(arr);
il.Call(enumeratorMethod, isVirtual: true);
il.Stloc(enumerator);
var keyGetter = getCurrent.ReturnType.GetMethod("get_Key");
var valueGetter = getCurrent.ReturnType.GetMethod("get_Value");
il.MarkLabel(point);
//body
il.Ldloca(enumerator);
il.Call(moveNext, enumerator.Type);
il.Stloc(exist);
il.Ldloca(enumerator);
il.Call(getCurrent, enumerator.Type);
il.Stloc(temp);
il.Ldloca(temp);
il.Call(keyGetter, typeof(int));
il.Stloc(currentItemKey);
if (typeof(IBasicType).IsAssignableFrom(prop.BinaryAttr.Type.GetGenericArguments()[0]))
{
IBasicType t = (IBasicType)Activator.CreateInstance(prop.BinaryAttr.Type.GetGenericArguments()[0]);
t.GetWriteILCode(prop, currentStruct, il, binaryStruct, currentItemKey, typeSize, buffer, offset, true);
}
else
{
BinaryStruct.CompileWriter(currentStruct.CurrentStorage.GetTypeInfo(typeKey, currentStruct.Scheme), il, binaryStruct, currentItemKey, buffer, offset, typeSize);
}
il.Ldloca(temp);
il.Call(valueGetter);
il.Stloc(currentItemValue);
if (typeof(IBasicType).IsAssignableFrom(prop.BinaryAttr.Type.GetGenericArguments()[1]))
{
IBasicType t = (IBasicType)Activator.CreateInstance(prop.BinaryAttr.Type.GetGenericArguments()[1]);
t.GetWriteILCode(prop, currentStruct, il, binaryStruct, currentItemValue, typeSize, buffer, offset, true);
}
else
{
BinaryStruct.CompileWriter(currentStruct.CurrentStorage.GetTypeInfo(typeValue, currentStruct.Scheme), il, binaryStruct, currentItemValue, buffer, offset, typeSize);
}
//end body
il.Ldc_I4(1);
il.Ldloc(ivar);
il.Add();
il.Stloc(ivar);
il.Ldloc(ivar);
il.Ldloc(len);
il.Clt(false);
il.Brtrue(point);
il.MarkLabel(exitLabel);
}
public void GetWriteILCode(PropertyData prop, BinaryStruct currentStruct, GroboIL il, GroboIL.Local binaryStruct, GroboIL.Local value, GroboIL.Local typeSize, GroboIL.Local buffer, GroboIL.Local offset, bool listValue)
{
BinaryStruct.WriteSizeChecker(il, buffer, offset, 5);
var arr = il.DeclareLocal(typeof(byte[]));
var arrSize = il.DeclareLocal(typeof(byte[]));
var temp = il.DeclareLocal(typeof(string));
var exitLabel = il.DefineLabel("exit");
il.Ldloc(value);
if (!listValue)
{
il.Call(prop.Getter);
}
il.Stloc(temp);
il.Ldloc(temp);
BinaryStruct.WriteObjectNull(il, exitLabel, buffer, offset, typeSize);
il.Ldloc(temp);
il.Call(typeof(string).GetProperty("Length").GetMethod);
il.Stloc(typeSize);
il.Ldarg(1);
il.Call(codingMethodInfo);
il.Ldloc(temp);
il.Call(currentStruct.Coding.GetType().GetMethod("GetBytes", new Type[] { typeof(string) }));
il.Stloc(arr);
il.Ldloc(arr);
il.Call(typeof(byte[]).GetProperty("Length").GetMethod);
il.Stloc(typeSize);
il.Ldloc(typeSize);
il.Call(writeBitConverterMethodInfo);
il.Stloc(arrSize);
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldloc(arrSize);
il.Ldc_I4(0);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
for (int i = 1; i < 4; i++)
{
il.Ldloc(buffer);
il.Ldloc(offset);
il.Ldc_I4(i);
il.Add();
il.Ldloc(arrSize);
il.Ldc_I4(i);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
}
BinaryStruct.WriteOffsetAppend(il, offset, 4);
il.Ldloc(typeSize);
il.Ldc_I4(0);
il.Ceq();
il.Brtrue(exitLabel);
BinaryStruct.WriteSizeChecker(il, buffer, offset, typeSize);
var ivar = il.DeclareLocal(typeof(int));
var point = il.DefineLabel("for_label");
il.Ldc_I4(0);
il.Stloc(ivar);
il.MarkLabel(point);
//body
il.Ldloc(buffer);
il.Ldloc(ivar);
il.Ldloc(offset);
il.Add();
il.Ldloc(arr);
il.Ldloc(ivar);
il.Ldelem(typeof(byte));
il.Stelem(typeof(byte));
//end body
il.Ldc_I4(1);
il.Ldloc(ivar);
il.Add();
il.Stloc(ivar);
il.Ldloc(ivar);
il.Ldloc(typeSize);
il.Clt(false);
il.Brtrue(point);
BinaryStruct.WriteOffsetAppend(il, offset, typeSize);
il.MarkLabel(exitLabel);
}
