C# Compiler.LoadAddress方法代码示例

        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);
//.........这里部分代码省略.........

 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);

//.........这里部分代码省略.........

        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);
 }