protected override void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { bool writeValue; SanityCheck(property, Tail, out writeValue, ctx.NonPublic); if (ExpectedType.IsValueType && valueFrom == null) { throw new InvalidOperationException("Attempt to mutate struct on the head of the stack; changes would be lost"); } ctx.LoadAddress(valueFrom, ExpectedType); // stack is: old-addr if (writeValue && Tail.RequiresOldValue) { // need to read and write ctx.CopyValue(); } // stack is: [old-addr]|old-addr if (Tail.RequiresOldValue) { ctx.LoadValue(property); // stack is: [old-addr]|old-value } ctx.ReadNullCheckedTail(property.PropertyType, Tail, null); // stack is [old-addr]|[new-value] if (writeValue) { // stack is old-addr|new-value ctx.StoreValue(property); } else { // don't want return value; drop it if anything there // stack is [new-value] if (Tail.ReturnsValue) { ctx.DiscardValue(); } } }
protected override void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { using (Compiler.Local oldValue = ctx.GetLocalWithValue(expectedType, valueFrom)) using (Compiler.Local token = new Compiler.Local(ctx, typeof(SubItemToken))) using (Compiler.Local field = new Compiler.Local(ctx, typeof(int))) { ctx.LoadReaderWriter(); ctx.EmitCall(typeof(ProtoReader).GetMethod("StartSubItem")); ctx.StoreValue(token); Compiler.CodeLabel next = ctx.DefineLabel(), processField = ctx.DefineLabel(), end = ctx.DefineLabel(); ctx.MarkLabel(next); ctx.EmitBasicRead("ReadFieldHeader", typeof(int)); ctx.CopyValue(); ctx.StoreValue(field); ctx.LoadValue(Tag); // = 1 - process ctx.BranchIfEqual(processField, true); ctx.LoadValue(field); ctx.LoadValue(1); // < 1 - exit ctx.BranchIfLess(end, false); // default: skip ctx.LoadReaderWriter(); ctx.EmitCall(typeof(ProtoReader).GetMethod("SkipField")); ctx.Branch(next, true); // process ctx.MarkLabel(processField); if (Tail.RequiresOldValue) { if (expectedType.IsValueType) { ctx.LoadAddress(oldValue, expectedType); ctx.EmitCall(expectedType.GetMethod("GetValueOrDefault", Helpers.EmptyTypes)); } else { ctx.LoadValue(oldValue); } } Tail.EmitRead(ctx, null); // note we demanded always returns a value if (expectedType.IsValueType) { ctx.EmitCtor(expectedType, Tail.ExpectedType); // re-nullable<T> it } ctx.StoreValue(oldValue); ctx.Branch(next, false); // outro ctx.MarkLabel(end); ctx.LoadValue(token); ctx.LoadReaderWriter(); ctx.EmitCall(typeof(ProtoReader).GetMethod("EndSubItem")); ctx.LoadValue(oldValue); // load the old value } }
protected override void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { using (Compiler.Local loc = ctx.GetLocalWithValue(ExpectedType, valueFrom)) { if (Tail.RequiresOldValue) { ctx.LoadAddress(loc, ExpectedType); ctx.LoadValue(field); } // value is either now on the stack or not needed ctx.ReadNullCheckedTail(field.FieldType, Tail, null); if (Tail.ReturnsValue) { using (Compiler.Local newVal = new Compiler.Local(ctx, field.FieldType)) { ctx.StoreValue(newVal); if (Helpers.IsValueType(field.FieldType)) { ctx.LoadAddress(loc, ExpectedType); ctx.LoadValue(newVal); ctx.StoreValue(field); } else { Compiler.CodeLabel allDone = ctx.DefineLabel(); ctx.LoadValue(newVal); ctx.BranchIfFalse(allDone, true); // interpret null as "don't assign" ctx.LoadAddress(loc, ExpectedType); ctx.LoadValue(newVal); ctx.StoreValue(field); ctx.MarkLabel(allDone); } } } } }
protected override void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { if (setSpecified == null) { Tail.EmitRead(ctx, valueFrom); return; } using (Compiler.Local loc = ctx.GetLocalWithValue(ExpectedType, valueFrom)) { Tail.EmitRead(ctx, loc); ctx.LoadAddress(loc, ExpectedType); ctx.LoadValue(1); // true ctx.EmitCall(setSpecified); } }
protected override void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { using (Compiler.Local loc = ctx.GetLocalWithValue(ExpectedType, valueFrom)) { ctx.LoadAddress(loc, ExpectedType); if (Tail.RequiresOldValue) { ctx.CopyValue(); ctx.LoadValue(field); } // value is either now on the stack or not needed ctx.ReadNullCheckedTail(field.FieldType, Tail, null); // stack is now the return value ctx.StoreValue(field); } }
protected override void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { if (getSpecified == null) { Tail.EmitWrite(ctx, valueFrom); return; } using (Compiler.Local loc = ctx.GetLocalWithValue(ExpectedType, valueFrom)) { ctx.LoadAddress(loc, ExpectedType); ctx.EmitCall(getSpecified); Compiler.CodeLabel done = ctx.DefineLabel(); ctx.BranchIfFalse(done, false); Tail.EmitWrite(ctx, loc); ctx.MarkLabel(done); } }
protected override void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { using (Compiler.Local loc = ctx.GetLocalWithValue(ExpectedType, valueFrom)) { ctx.LoadAddress(loc, ExpectedType); if (Tail.RequiresOldValue) { ctx.CopyValue(); ctx.LoadValue(field); } // value is either now on the stack or not needed ctx.ReadNullCheckedTail(field.FieldType, Tail, null); if (Tail.ReturnsValue) { if (field.FieldType.IsValueType) { // stack is now the return value ctx.StoreValue(field); } else { Compiler.CodeLabel hasValue = ctx.DefineLabel(), allDone = ctx.DefineLabel(); ctx.CopyValue(); ctx.BranchIfTrue(hasValue, true); // interpret null as "don't assign" // no value, discard ctx.DiscardValue(); ctx.DiscardValue(); ctx.Branch(allDone, true); ctx.MarkLabel(hasValue); ctx.StoreValue(field); ctx.MarkLabel(allDone); } } else { ctx.DiscardValue(); } } }
protected override void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { bool writeValue; SanityCheck(ctx.Model, property, Tail, out writeValue, ctx.NonPublic, ctx.AllowInternal(property)); if (ExpectedType.IsValueType && valueFrom == null) { throw new InvalidOperationException("Attempt to mutate struct on the head of the stack; changes would be lost"); } using (Compiler.Local loc = ctx.GetLocalWithValue(ExpectedType, valueFrom)) { if (Tail.RequiresOldValue) { ctx.LoadAddress(loc, ExpectedType); // stack is: old-addr ctx.LoadValue(property); // stack is: old-value } Type propertyType = property.PropertyType; ctx.ReadNullCheckedTail(propertyType, Tail, null); // stack is [new-value] if (writeValue) { using (Compiler.Local newVal = new Compiler.Local(ctx, property.PropertyType)) { ctx.StoreValue(newVal); // stack is empty Compiler.CodeLabel allDone = new Compiler.CodeLabel(); // <=== default structs if (!propertyType.IsValueType) { // if the tail returns a null, intepret that as *no assign* allDone = ctx.DefineLabel(); ctx.LoadValue(newVal); // stack is: new-value ctx.BranchIfFalse(@allDone, true); // stack is empty } // assign the value ctx.LoadAddress(loc, ExpectedType); // parent-addr ctx.LoadValue(newVal); // parent-obj|new-value if (shadowSetter == null) { ctx.StoreValue(property); // empty } else { ctx.EmitCall(shadowSetter); // empty } if (!propertyType.IsValueType) { ctx.MarkLabel(allDone); } } } else { // don't want return value; drop it if anything there // stack is [new-value] if (Tail.ReturnsValue) { ctx.DiscardValue(); } } } }
public void EmitRead(Compiler.CompilerContext ctx, Compiler.Local incoming) { using (Compiler.Local objValue = ctx.GetLocalWithValue(ExpectedType, incoming)) { Compiler.Local[] locals = new Compiler.Local[members.Length]; try { for (int i = 0; i < locals.Length; i++) { Type type = GetMemberType(i); bool store = true; locals[i] = new Compiler.Local(ctx, type); if (!Helpers.IsValueType(ExpectedType)) { // value-types always read the old value if (Helpers.IsValueType(type)) { switch (Helpers.GetTypeCode(type)) { case ProtoTypeCode.Boolean: case ProtoTypeCode.Byte: case ProtoTypeCode.Int16: case ProtoTypeCode.Int32: case ProtoTypeCode.SByte: case ProtoTypeCode.UInt16: case ProtoTypeCode.UInt32: ctx.LoadValue(0); break; case ProtoTypeCode.Int64: case ProtoTypeCode.UInt64: ctx.LoadValue(0L); break; case ProtoTypeCode.Single: ctx.LoadValue(0.0F); break; case ProtoTypeCode.Double: ctx.LoadValue(0.0D); break; case ProtoTypeCode.Decimal: ctx.LoadValue(0M); break; case ProtoTypeCode.Guid: ctx.LoadValue(Guid.Empty); break; default: ctx.LoadAddress(locals[i], type); ctx.EmitCtor(type); store = false; break; } } else { ctx.LoadNullRef(); } if (store) { ctx.StoreValue(locals[i]); } } } Compiler.CodeLabel skipOld = Helpers.IsValueType(ExpectedType) ? new Compiler.CodeLabel() : ctx.DefineLabel(); if (!Helpers.IsValueType(ExpectedType)) { ctx.LoadAddress(objValue, ExpectedType); ctx.BranchIfFalse(skipOld, false); } for (int i = 0; i < members.Length; i++) { ctx.LoadAddress(objValue, ExpectedType); if (members[i] is FieldInfo) { ctx.LoadValue((FieldInfo)members[i]); } else if (members[i] is PropertyInfo) { ctx.LoadValue((PropertyInfo)members[i]); } ctx.StoreValue(locals[i]); } if (!Helpers.IsValueType(ExpectedType)) ctx.MarkLabel(skipOld); using (Compiler.Local fieldNumber = new Compiler.Local(ctx, ctx.MapType(typeof(int)))) { Compiler.CodeLabel @continue = ctx.DefineLabel(), processField = ctx.DefineLabel(), notRecognised = ctx.DefineLabel(); ctx.Branch(@continue, false); Compiler.CodeLabel[] handlers = new Compiler.CodeLabel[members.Length]; for (int i = 0; i < members.Length; i++) { handlers[i] = ctx.DefineLabel(); } ctx.MarkLabel(processField); ctx.LoadValue(fieldNumber); ctx.LoadValue(1); ctx.Subtract(); // jump-table is zero-based ctx.Switch(handlers); // and the default: ctx.Branch(notRecognised, false); for (int i = 0; i < handlers.Length; i++) { ctx.MarkLabel(handlers[i]); IProtoSerializer tail = tails[i]; Compiler.Local oldValIfNeeded = tail.RequiresOldValue ? locals[i] : null; ctx.ReadNullCheckedTail(locals[i].Type, tail, oldValIfNeeded); if (tail.ReturnsValue) { if (Helpers.IsValueType(locals[i].Type)) { ctx.StoreValue(locals[i]); } else { Compiler.CodeLabel hasValue = ctx.DefineLabel(), allDone = ctx.DefineLabel(); ctx.CopyValue(); ctx.BranchIfTrue(hasValue, true); // interpret null as "don't assign" ctx.DiscardValue(); ctx.Branch(allDone, true); ctx.MarkLabel(hasValue); ctx.StoreValue(locals[i]); ctx.MarkLabel(allDone); } } ctx.Branch(@continue, false); } ctx.MarkLabel(notRecognised); ctx.LoadReaderWriter(); ctx.EmitCall(ctx.MapType(typeof(ProtoReader)).GetMethod("SkipField")); ctx.MarkLabel(@continue); ctx.EmitBasicRead("ReadFieldHeader", ctx.MapType(typeof(int))); ctx.CopyValue(); ctx.StoreValue(fieldNumber); ctx.LoadValue(0); ctx.BranchIfGreater(processField, false); } for (int i = 0; i < locals.Length; i++) { ctx.LoadValue(locals[i]); } ctx.EmitCtor(ctor); ctx.StoreValue(objValue); } finally { for (int i = 0; i < locals.Length; i++) { if (locals[i] != null) locals[i].Dispose(); // release for re-use } } } }
public void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { using (Compiler.Local loc = ctx.GetLocalWithValue(ctor.DeclaringType, valueFrom)) { for (int i = 0; i < tails.Length; i++) { Type type = GetMemberType(i); ctx.LoadAddress(loc, ExpectedType); if (members[i] is FieldInfo) { ctx.LoadValue((FieldInfo)members[i]); } else if (members[i] is PropertyInfo) { ctx.LoadValue((PropertyInfo)members[i]); } ctx.WriteNullCheckedTail(type, tails[i], null); } } }
private void EmitReadArray(Compiler.CompilerContext ctx, Compiler.Local list, Compiler.Local oldArr, Compiler.Local newArr, IProtoSerializer tail, MethodInfo add, Type listType) { Compiler.CodeLabel readPacked = packedWireType == WireType.None ? new Compiler.CodeLabel() : ctx.DefineLabel(); Compiler.CodeLabel @end = ctx.DefineLabel(); if (packedWireType != WireType.None) { ctx.LoadReaderWriter(); ctx.LoadValue(typeof(ProtoReader).GetProperty("WireType")); ctx.LoadValue((int)WireType.String); ctx.BranchIfEqual(readPacked, false); } using (Compiler.Local fieldNumber = new Compiler.Local(ctx, typeof(int))) { // int fieldNumber = source.FieldNumber; ctx.LoadReaderWriter(); ctx.LoadValue(typeof (ProtoReader).GetProperty("FieldNumber")); ctx.StoreValue(fieldNumber); using (Compiler.Local readObject = new Compiler.Local(ctx, typeof (bool))) using (Compiler.Local arrayKey = new Compiler.Local(ctx, typeof (int))) { // bool readObject = true; ctx.LoadValue(true); ctx.StoreValue(readObject); // value = value ?? Array.CreateInstance(itemType, 0); Compiler.CodeLabel @endCreateInstance = ctx.DefineLabel(); ctx.LoadValue(oldArr); ctx.LoadNullRef(); ctx.TestEqual(); ctx.BranchIfFalse(@endCreateInstance, true); ctx.LoadValue(itemType); ctx.LoadValue(0); ctx.EmitCall(typeof(Array).GetMethod("CreateInstance", new Type[] { typeof(Type), typeof(int) })); ctx.StoreValue(oldArr); ctx.MarkLabel(@endCreateInstance); if (AsReference) { using (Compiler.Local objectKey = new Compiler.Local(ctx, typeof(int))) { //int objectKey = source.ReadInt32(); ctx.LoadReaderWriter(); ctx.EmitCall(typeof(ProtoReader).GetMethod("ReadInt32")); ctx.StoreValue(objectKey); Compiler.CodeLabel @ifNotThere = ctx.DefineLabel(); Compiler.CodeLabel @endIf = ctx.DefineLabel(); //if (objectKey > 0) ctx.LoadValue(objectKey); ctx.LoadValue(0); ctx.BranchIfLessOrEqual(@ifNotThere, true); // value = source.NetCache.GetKeyedObject(objectKey); ctx.LoadReaderWriter(); ctx.LoadValue(typeof(ProtoReader).GetProperty("NetCache")); ctx.LoadValue(objectKey); ctx.EmitCall(typeof(NetObjectCache).GetMethod("GetKeyedObject")); ctx.StoreValue(oldArr); //readObject = false; ctx.LoadValue(false); ctx.StoreValue(readObject); //} ctx.Branch(@endIf, true); //else ctx.MarkLabel(@ifNotThere); //bool dummy; //arrayKey = source.NetCache.AddObjectKey(value, out dummy); using (Compiler.Local dummy = new Compiler.Local(ctx, typeof(bool))) { ctx.LoadReaderWriter(); ctx.LoadValue(typeof(ProtoReader).GetProperty("NetCache")); ctx.LoadValue(oldArr); ctx.LoadAddress(dummy, typeof(bool)); ctx.EmitCall(typeof(NetObjectCache).GetMethod("AddObjectKey", new Type[] { typeof(object), typeof(bool).MakeByRefType() })); ctx.StoreValue(arrayKey); } ctx.MarkLabel(@endIf); } } else { using (Compiler.Local readValue = new Compiler.Local(ctx, typeof(int))) { ctx.LoadReaderWriter(); ctx.EmitCall(typeof(ProtoReader).GetMethod("ReadInt32")); ctx.StoreValue(readValue); Compiler.CodeLabel @codeContinues = ctx.DefineLabel(); ctx.LoadValue(readValue); ctx.LoadValue(0); ctx.BranchIfEqual(@codeContinues, true); ctx.LoadValue(oldArr); ctx.Branch(@end, false); ctx.MarkLabel(@codeContinues); } } /* if (readObject) { while (source.TryReadFieldHeader(field)) { list.Add(Tail.Read(null, source)); } */ Compiler.CodeLabel @finishRead = ctx.DefineLabel(); ctx.LoadValue(readObject); ctx.BranchIfFalse(@finishRead, false); Compiler.CodeLabel @beginWhileLoop = ctx.DefineLabel(); Compiler.CodeLabel @endWhileLoop = ctx.DefineLabel(); ctx.MarkLabel(@beginWhileLoop); ctx.LoadReaderWriter(); ctx.LoadValue(fieldNumber); ctx.EmitCall(typeof (ProtoReader).GetMethod("TryReadFieldHeader")); ctx.BranchIfFalse(@endWhileLoop, false); ListDecorator.EmitReadAndAddItem(ctx, list, tail, add, null); ctx.Branch(@beginWhileLoop, false); ctx.MarkLabel(@endWhileLoop); // Array newArray = Array.CreateInstance(itemType, list.Count); ctx.LoadValue(itemType); ctx.LoadValue(list); ctx.LoadValue(listType.GetProperty("Count")); ctx.EmitCall(typeof(Array).GetMethod("CreateInstance", new Type[] { typeof(Type), typeof(int) })); ctx.StoreValue(newArr); // list.CopyTo(newArray, 0); ctx.LoadValue(list); ctx.LoadValue(newArr); ctx.LoadValue(0); ctx.EmitCall(listType.GetMethod("CopyTo", new Type[] { ExpectedType, typeof(int) })); if (AsReference) { //source.NetCache.UpdateKeyedObject(arrayKey, value, newArray); ctx.LoadReaderWriter(); ctx.LoadValue(typeof(ProtoReader).GetProperty("NetCache")); ctx.LoadValue(arrayKey); ctx.LoadValue(oldArr); ctx.LoadValue(newArr); ctx.EmitCall(typeof(NetObjectCache).GetMethod("UpdateKeyedObject")); } //value = newArray; ctx.LoadValue(newArr); ctx.StoreValue(oldArr); ctx.MarkLabel(@finishRead); ctx.LoadValue(oldArr); ctx.MarkLabel(@end); } } if (packedWireType != WireType.None) { Compiler.CodeLabel allDone = ctx.DefineLabel(); ctx.Branch(allDone, false); ctx.MarkLabel(readPacked); ctx.LoadReaderWriter(); ctx.EmitCall(typeof (ProtoReader).GetMethod("StartSubItem")); Compiler.CodeLabel testForData = ctx.DefineLabel(), noMoreData = ctx.DefineLabel(); ctx.MarkLabel(testForData); ctx.LoadValue((int) packedWireType); ctx.LoadReaderWriter(); ctx.EmitCall(typeof (ProtoReader).GetMethod("HasSubValue")); ctx.BranchIfFalse(noMoreData, false); ListDecorator.EmitReadAndAddItem(ctx, list, tail, add, null); ctx.Branch(testForData, false); ctx.MarkLabel(noMoreData); ctx.LoadReaderWriter(); ctx.EmitCall(typeof (ProtoReader).GetMethod("EndSubItem")); EmitReadEndPacked(ctx, list, oldArr, newArr, listType); ctx.MarkLabel(allDone); } }
public void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { Compiler.CodeLabel @end = ctx.DefineLabel(); using (Compiler.Local value = ctx.GetLocalWithValue(ctor.DeclaringType, valueFrom)) { if (!baseTupleAsReference && asReference) { using (Compiler.Local existing = new Compiler.Local(ctx, typeof(bool))) using (Compiler.Local tupleKey = new Compiler.Local(ctx, typeof(int))) { //int tupleKey = dest.NetCache.AddObjectKey(value, out existing); ctx.LoadReaderWriter(); ctx.LoadValue(typeof(ProtoWriter).GetProperty("NetCache")); ctx.LoadValue(value); ctx.CastToObject(ctor.DeclaringType); // HACK : doesn't seem to get boxed from ctx.GetLocalWithValue ctx.LoadAddress(existing, typeof(bool)); ctx.EmitCall(typeof(NetObjectCache).GetMethod("AddObjectKey", new Type[] { typeof(object), typeof(bool).MakeByRefType() })); ctx.StoreValue(tupleKey); //ProtoWriter.WriteUInt32(existing ? (uint) tupleKey : 0, dest); Compiler.CodeLabel @continueBranch = ctx.DefineLabel(); ctx.LoadValue(0); ctx.LoadValue(existing); ctx.BranchIfFalse(@continueBranch, true); ctx.DiscardValue(); ctx.LoadValue(tupleKey); //ctx.CastToObject(typeof(uint)); ctx.MarkLabel(@continueBranch); ctx.LoadReaderWriter(); ctx.EmitCall(typeof(ProtoWriter).GetMethod("WriteUInt32")); //if (existing) { return; } ctx.LoadValue(existing); ctx.BranchIfTrue(@end, false); } } for (int i = 0; i < tails.Length; i++) { Type type = GetMemberType(i); ctx.LoadAddress(value, ExpectedType); switch(members[i].MemberType) { case MemberTypes.Field: ctx.LoadValue((FieldInfo)members[i]); break; case MemberTypes.Property: ctx.LoadValue((PropertyInfo)members[i]); break; } ctx.WriteNullCheckedTail(type, tails[i], null); } } if (forceIssueFakeHeader) { ctx.LoadReaderWriter(); ctx.EmitCall(typeof(ProtoWriter).GetMethod("WriteEndGroupFieldHeaderHack")); } ctx.MarkLabel(@end); }
protected override void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { bool writeValue; SanityCheck(ctx.Model, property, Tail, out writeValue, ctx.NonPublic, ctx.AllowInternal(property)); if (ExpectedType.IsValueType && valueFrom == null) { throw new InvalidOperationException("Attempt to mutate struct on the head of the stack; changes would be lost"); } ctx.LoadAddress(valueFrom, ExpectedType); // stack is: old-addr if (writeValue && Tail.RequiresOldValue) { // need to read and write ctx.CopyValue(); } // stack is: [old-addr]|old-addr if (Tail.RequiresOldValue) { ctx.LoadValue(property); // stack is: [old-addr]|old-value } Type propertyType = property.PropertyType; ctx.ReadNullCheckedTail(propertyType, Tail, null); // stack is [old-addr]|[new-value] if (writeValue) { // stack is old-addr|new-value Compiler.CodeLabel @skip = new Compiler.CodeLabel(), allDone = new Compiler.CodeLabel(); // <=== default structs if (!propertyType.IsValueType) { // if the tail returns a null, intepret that as *no assign* ctx.CopyValue(); // old-addr|new-value|new-value @skip = ctx.DefineLabel(); allDone = ctx.DefineLabel(); ctx.BranchIfFalse(@skip, true); // old-addr|new-value } if (shadowSetter == null) { ctx.StoreValue(property); } else { ctx.EmitCall(shadowSetter); } if (!propertyType.IsValueType) { ctx.Branch(allDone, true); ctx.MarkLabel(@skip); // old-addr|new-value ctx.DiscardValue(); ctx.DiscardValue(); ctx.MarkLabel(allDone); } } else { // don't want return value; drop it if anything there // stack is [new-value] if (Tail.ReturnsValue) { ctx.DiscardValue(); } } }
private static void EmitReadAndAddItem(Compiler.CompilerContext ctx, Compiler.Local list, IProtoSerializer tail, MethodInfo add) { ctx.LoadValue(list); Type itemType = tail.ExpectedType; if (tail.RequiresOldValue) { if (itemType.IsValueType || !tail.ReturnsValue) { // going to need a variable using (Compiler.Local item = new Compiler.Local(ctx, itemType)) { if (itemType.IsValueType) { // initialise the struct ctx.LoadAddress(item, itemType); ctx.EmitCtor(itemType); } else { // assign null ctx.LoadNullRef(); ctx.StoreValue(item); } tail.EmitRead(ctx, item); if (!tail.ReturnsValue) { ctx.LoadValue(item); } } } else { // no variable; pass the null on the stack and take the value *off* the stack ctx.LoadNullRef(); tail.EmitRead(ctx, null); } } else { if (tail.ReturnsValue) { // out only (on the stack); just emit it tail.EmitRead(ctx, null); } else { // doesn't take anything in nor return anything! WTF? throw new InvalidOperationException(); } } // our "Add" is chosen either to take the correct type, or to take "object"; // we may need to box the value Type addParamType = add.GetParameters()[0].ParameterType; if(addParamType != itemType) { if (addParamType == typeof(object)) { ctx.CastToObject(itemType); } else { throw new InvalidOperationException("Conflicting item/add type"); } } ctx.EmitCall(add); if (add.ReturnType != typeof(void)) { ctx.DiscardValue(); } }
void IProtoSerializer.EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { Type type = ExpectedType; if (Helpers.IsValueType(type)) { // note that for structs, we've already asserted that a custom ToString // exists; no need to handle the box/callvirt scenario // force it to a variable if needed, so we can take the address using (Compiler.Local loc = ctx.GetLocalWithValue(type, valueFrom)) { ctx.LoadAddress(loc, type); ctx.EmitCall(GetCustomToString(type)); } } else { ctx.EmitCall(ctx.MapType(typeof(object)).GetMethod("ToString")); } ctx.EmitBasicWrite("WriteString", valueFrom); }
public void EmitRead(Compiler.CompilerContext ctx, Compiler.Local incoming) { bool issueReferenceDirectives = !baseTupleAsReference && asReference; Compiler.CodeLabel @end = ctx.DefineLabel(); using (Compiler.Local tupleKey = new Compiler.Local(ctx, typeof(int))) using (Compiler.Local oldTuple = new Compiler.Local(ctx, typeof(object))) using (Compiler.Local objValue = ctx.GetLocalWithValue(ExpectedType, incoming)) { Compiler.Local[] locals = new Compiler.Local[members.Length]; try { if (issueReferenceDirectives) { //int tupleKey = 0; ctx.LoadValue(0); ctx.StoreValue(tupleKey); //object oldTuple = null; ctx.LoadNullRef(); ctx.StoreValue(oldTuple); //tupleKey = (int)source.ReadUInt32(); ctx.LoadReaderWriter(); ctx.EmitCall(typeof (ProtoReader).GetMethod("ReadUInt32")); //ctx.CastToObject(typeof (int)); ctx.StoreValue(tupleKey); Compiler.CodeLabel @objectNotFound = ctx.DefineLabel(); ctx.LoadValue(tupleKey); ctx.LoadValue(0); ctx.BranchIfEqual(@objectNotFound, true); //// return source.NetCache.GetKeyedObject(tupleKey); ctx.LoadReaderWriter(); ctx.LoadValue(typeof (ProtoReader).GetProperty("NetCache")); ctx.LoadValue(tupleKey); ctx.EmitCall(typeof (NetObjectCache).GetMethod("GetKeyedObject")); ctx.CastFromObject(ExpectedType); ctx.StoreValue(objValue); ctx.Branch(@end, false); ctx.MarkLabel(@objectNotFound); ctx.EmitCtor(typeof (object)); ctx.StoreValue(oldTuple); // tupleKey = source.NetCache.AddObjectKey(oldTuple, out dummy); using (Compiler.Local dummy = new Compiler.Local(ctx, typeof (bool))) { ctx.LoadReaderWriter(); ctx.LoadValue(typeof (ProtoReader).GetProperty("NetCache")); ctx.LoadValue(oldTuple); ctx.LoadAddress(dummy, typeof (bool)); ctx.EmitCall(typeof (NetObjectCache).GetMethod("AddObjectKey", new Type[] { typeof(object), typeof(bool).MakeByRefType() })); ctx.StoreValue(tupleKey); } } for (int i = 0; i < locals.Length; i++) { Type type = GetMemberType(i); bool store = true; locals[i] = new Compiler.Local(ctx, type); if (!ExpectedType.IsValueType) { // value-types always read the old value if (type.IsValueType) { switch (Helpers.GetTypeCode(type)) { case ProtoTypeCode.Boolean: case ProtoTypeCode.Byte: case ProtoTypeCode.Int16: case ProtoTypeCode.Int32: case ProtoTypeCode.SByte: case ProtoTypeCode.UInt16: case ProtoTypeCode.UInt32: ctx.LoadValue(0); break; case ProtoTypeCode.Int64: case ProtoTypeCode.UInt64: ctx.LoadValue(0L); break; case ProtoTypeCode.Single: ctx.LoadValue(0.0F); break; case ProtoTypeCode.Double: ctx.LoadValue(0.0D); break; case ProtoTypeCode.Decimal: ctx.LoadValue(0M); break; case ProtoTypeCode.Guid: ctx.LoadValue(Guid.Empty); break; default: ctx.LoadAddress(locals[i], type); ctx.EmitCtor(type); store = false; break; } } else { ctx.LoadNullRef(); } if (store) { ctx.StoreValue(locals[i]); } } } Compiler.CodeLabel skipOld = ExpectedType.IsValueType ? new Compiler.CodeLabel() : ctx.DefineLabel(); if (!ExpectedType.IsValueType) { ctx.LoadAddress(objValue, ExpectedType); ctx.BranchIfFalse(skipOld, false); } for (int i = 0; i < members.Length; i++) { ctx.LoadAddress(objValue, ExpectedType); switch (members[i].MemberType) { case MemberTypes.Field: ctx.LoadValue((FieldInfo) members[i]); break; case MemberTypes.Property: ctx.LoadValue((PropertyInfo) members[i]); break; } ctx.StoreValue(locals[i]); } if (!ExpectedType.IsValueType) ctx.MarkLabel(skipOld); using (Compiler.Local fieldNumber = new Compiler.Local(ctx, typeof (int))) using (Compiler.Local j = new Compiler.Local(ctx, typeof (int))) { // j = 0 ctx.LoadValue(0); ctx.StoreValue(j); Compiler.CodeLabel @continue = ctx.DefineLabel(), processField = ctx.DefineLabel(), notRecognised = ctx.DefineLabel(), @endWhileLoop = ctx.DefineLabel(); ctx.Branch(@continue, false); Compiler.CodeLabel[] handlers = new Compiler.CodeLabel[members.Length]; for (int i = 0; i < members.Length; i++) { handlers[i] = ctx.DefineLabel(); } ctx.MarkLabel(processField); ctx.LoadValue(fieldNumber); ctx.LoadValue(1); ctx.Subtract(); // jump-table is zero-based ctx.Switch(handlers); // and the default: ctx.Branch(notRecognised, false); for (int i = 0; i < handlers.Length; i++) { ctx.MarkLabel(handlers[i]); IProtoSerializer tail = tails[i]; Compiler.Local oldValIfNeeded = tail.RequiresOldValue ? locals[i] : null; ctx.ReadNullCheckedTail(locals[i].Type, tail, oldValIfNeeded); if (tail.ReturnsValue) { if (locals[i].Type.IsValueType) { ctx.StoreValue(locals[i]); } else { Compiler.CodeLabel hasValue = ctx.DefineLabel(), allDone = ctx.DefineLabel(); ctx.CopyValue(); ctx.BranchIfTrue(hasValue, true); // interpret null as "don't assign" ctx.DiscardValue(); ctx.Branch(allDone, true); ctx.MarkLabel(hasValue); ctx.StoreValue(locals[i]); ctx.MarkLabel(allDone); } } ctx.Branch(@continue, false); } ctx.MarkLabel(notRecognised); ctx.LoadReaderWriter(); ctx.EmitCall(typeof (ProtoReader).GetMethod("SkipField")); ctx.MarkLabel(@continue); // j < values.Length ctx.LoadValue(j); ctx.LoadValue(members.Length); ctx.BranchIfGreaterOrEqual(@endWhileLoop, false); //j++ ctx.LoadValue(j); ctx.LoadValue(1); ctx.Add(); ctx.StoreValue(j); // source.ReadNextFieldHack() > 0 ctx.LoadReaderWriter(); ctx.EmitCall(typeof (ProtoReader).GetMethod("ReadNextFieldHack")); ctx.LoadValue(0); ctx.BranchIfLessOrEqual(@endWhileLoop, true); // field = source.ReadFieldHeader(); ctx.LoadReaderWriter(); ctx.EmitCall(typeof (ProtoReader).GetMethod("ReadFieldHeader")); ctx.StoreValue(fieldNumber); ctx.Branch(processField, false); ctx.MarkLabel(@endWhileLoop); } for (int i = 0; i < locals.Length; i++) { ctx.LoadValue(locals[i]); } ctx.EmitCtor(ctor); ctx.StoreValue(objValue); if (issueReferenceDirectives) { //source.NetCache.UpdateKeyedObject(tupleKey, oldTuple, result); ctx.LoadReaderWriter(); ctx.LoadValue(typeof (ProtoReader).GetProperty("NetCache")); ctx.LoadValue(tupleKey); ctx.LoadValue(oldTuple); ctx.LoadValue(objValue); ctx.CastToObject(ExpectedType); ctx.EmitCall(typeof (NetObjectCache).GetMethod("UpdateKeyedObject")); } if (forceIssueFakeHeader) { //source.ReadEndGroupFieldHeaderHack(); ctx.LoadReaderWriter(); ctx.EmitCall(typeof (ProtoReader).GetMethod("ReadEndGroupFieldHeaderHack")); } ctx.MarkLabel(@end); ctx.LoadValue(objValue); } finally { for (int i = 0; i < locals.Length; i++) { if (locals[i] != null) locals[i].Dispose(); // release for re-use } } } }
protected override void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { ctx.LoadAddress(valueFrom, ExpectedType); ctx.LoadValue(property); ctx.WriteNullCheckedTail(property.PropertyType, Tail, null); }
protected override void EmitWrite(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { using(Compiler.Local valOrNull = ctx.GetLocalWithValue(expectedType, valueFrom)) using(Compiler.Local token = new Compiler.Local(ctx, ctx.MapType(typeof(SubItemToken)))) { ctx.LoadNullRef(); ctx.LoadReaderWriter(); ctx.EmitCall(ctx.MapType(typeof(ProtoWriter)).GetMethod("StartSubItem")); ctx.StoreValue(token); if (Helpers.IsValueType(expectedType)) { ctx.LoadAddress(valOrNull, expectedType); ctx.LoadValue(expectedType.GetProperty("HasValue")); } else { ctx.LoadValue(valOrNull); } Compiler.CodeLabel @end = ctx.DefineLabel(); ctx.BranchIfFalse(@end, false); if (Helpers.IsValueType(expectedType)) { ctx.LoadAddress(valOrNull, expectedType); ctx.EmitCall(expectedType.GetMethod("GetValueOrDefault", Helpers.EmptyTypes)); } else { ctx.LoadValue(valOrNull); } Tail.EmitWrite(ctx, null); ctx.MarkLabel(@end); ctx.LoadValue(token); ctx.LoadReaderWriter(); ctx.EmitCall(ctx.MapType(typeof(ProtoWriter)).GetMethod("EndSubItem")); } }
protected override void EmitRead(Compiler.CompilerContext ctx, Compiler.Local valueFrom) { using (Compiler.Local oldList = AppendToCollection ? ctx.GetLocalWithValue(ExpectedType, valueFrom) : null) using(Compiler.Local builder = new Compiler.Local(ctx, builderFactory.ReturnType)) { ctx.EmitCall(builderFactory); ctx.StoreValue(builder); if(AppendToCollection) { Compiler.CodeLabel done = ctx.DefineLabel(); if(!ExpectedType.IsValueType) { ctx.LoadValue(oldList); ctx.BranchIfFalse(done, false); // old value null; nothing to add } PropertyInfo prop = Helpers.GetProperty(ExpectedType, "Length", false); if(prop == null) prop = Helpers.GetProperty(ExpectedType, "Count", false); #if !NO_GENERICS if (prop == null) prop = Helpers.GetProperty(ResolveIReadOnlyCollection(ExpectedType, Tail.ExpectedType), "Count", false); #endif ctx.LoadAddress(oldList, oldList.Type); ctx.EmitCall(Helpers.GetGetMethod(prop, false, false)); ctx.BranchIfFalse(done, false); // old list is empty; nothing to add Type voidType = ctx.MapType(typeof(void)); if(addRange != null) { ctx.LoadValue(builder); ctx.LoadValue(oldList); ctx.EmitCall(addRange); if (addRange.ReturnType != null && add.ReturnType != voidType) ctx.DiscardValue(); } else { // loop and call Add repeatedly MethodInfo moveNext, current, getEnumerator = GetEnumeratorInfo(ctx.Model, out moveNext, out current); Helpers.DebugAssert(moveNext != null); Helpers.DebugAssert(current != null); Helpers.DebugAssert(getEnumerator != null); Type enumeratorType = getEnumerator.ReturnType; using (Compiler.Local iter = new Compiler.Local(ctx, enumeratorType)) { ctx.LoadAddress(oldList, ExpectedType); ctx.EmitCall(getEnumerator); ctx.StoreValue(iter); using (ctx.Using(iter)) { Compiler.CodeLabel body = ctx.DefineLabel(), next = ctx.DefineLabel(); ctx.Branch(next, false); ctx.MarkLabel(body); ctx.LoadAddress(builder, builder.Type); ctx.LoadAddress(iter, enumeratorType); ctx.EmitCall(current); ctx.EmitCall(add); if (add.ReturnType != null && add.ReturnType != voidType) ctx.DiscardValue(); ctx.MarkLabel(@next); ctx.LoadAddress(iter, enumeratorType); ctx.EmitCall(moveNext); ctx.BranchIfTrue(body, false); } } } ctx.MarkLabel(done); } EmitReadList(ctx, builder, Tail, add, packedWireType, false); ctx.LoadAddress(builder, builder.Type); ctx.EmitCall(finish); if(ExpectedType != finish.ReturnType) { ctx.Cast(ExpectedType); } } }
private void EmitReadEndPacked(Compiler.CompilerContext ctx, Compiler.Local list, Compiler.Local oldArr, Compiler.Local newArr, Type listType) { // leave this "using" here, as it can share the "FieldNumber" local with EmitReadList using(Compiler.Local oldLen = AppendToCollection ? new ProtoBuf.Compiler.Local(ctx, typeof(int)) : null) { Type[] copyToArrayInt32Args = new Type[] { typeof(Array), typeof(int) }; if (AppendToCollection) { ctx.LoadLength(oldArr, true); ctx.CopyValue(); ctx.StoreValue(oldLen); ctx.LoadAddress(list, listType); ctx.LoadValue(listType.GetProperty("Count")); ctx.Add(); ctx.CreateArray(itemType, null); // length is on the stack ctx.StoreValue(newArr); ctx.LoadValue(oldLen); Compiler.CodeLabel nothingToCopy = ctx.DefineLabel(); ctx.BranchIfFalse(nothingToCopy, true); ctx.LoadValue(oldArr); ctx.LoadValue(newArr); ctx.LoadValue(0); // index in target ctx.EmitCall(ExpectedType.GetMethod("CopyTo", copyToArrayInt32Args)); ctx.MarkLabel(nothingToCopy); ctx.LoadValue(list); ctx.LoadValue(newArr); ctx.LoadValue(oldLen); } else { ctx.LoadAddress(list, listType); ctx.LoadValue(listType.GetProperty("Count")); ctx.CreateArray(itemType, null); ctx.StoreValue(newArr); ctx.LoadAddress(list, listType); ctx.LoadValue(newArr); ctx.LoadValue(0); } copyToArrayInt32Args[0] = ExpectedType; // // prefer: CopyTo(T[], int) MethodInfo copyTo = listType.GetMethod("CopyTo", copyToArrayInt32Args); if (copyTo == null) { // fallback: CopyTo(Array, int) copyToArrayInt32Args[1] = typeof(Array); copyTo = listType.GetMethod("CopyTo", copyToArrayInt32Args); } ctx.EmitCall(copyTo); } ctx.LoadValue(newArr); }