public override void Emit(EmitContext ec)
{
// TODO: Should guard against multiple emits
base.Emit(ec);
// Release temporary variable when used
if (variable != null)
{
variable.Release(ec);
}
}
public void EmitAwaitOnCompletedDynamic(EmitContext ec, FieldExpr awaiter)
{
var critical = Module.PredefinedTypes.ICriticalNotifyCompletion;
if (!critical.Define())
{
throw new NotImplementedException();
}
var temp_critical = new LocalTemporary(critical.TypeSpec);
var label_critical = ec.DefineLabel();
var label_end = ec.DefineLabel();
//
// Special path for dynamic awaiters
//
// var awaiter = this.$awaiter as ICriticalNotifyCompletion;
// if (awaiter == null) {
// var completion = (INotifyCompletion) this.$awaiter;
// this.$builder.AwaitOnCompleted (ref completion, ref this);
// } else {
// this.$builder.AwaitUnsafeOnCompleted (ref awaiter, ref this);
// }
//
awaiter.Emit(ec);
ec.Emit(OpCodes.Isinst, critical.TypeSpec);
temp_critical.Store(ec);
temp_critical.Emit(ec);
ec.Emit(OpCodes.Brtrue_S, label_critical);
var temp = new LocalTemporary(Module.PredefinedTypes.INotifyCompletion.TypeSpec);
awaiter.Emit(ec);
ec.Emit(OpCodes.Castclass, temp.Type);
temp.Store(ec);
EmitOnCompleted(ec, temp, false);
temp.Release(ec);
ec.Emit(OpCodes.Br_S, label_end);
ec.MarkLabel(label_critical);
EmitOnCompleted(ec, temp_critical, true);
ec.MarkLabel(label_end);
temp_critical.Release(ec);
}
static TypeSpec EmitCallInstance(EmitContext ec, Expression instance, TypeSpec declaringType, OpCode callOpcode)
{
var instance_type = instance.Type;
//
// Push the instance expression
//
if ((instance_type.IsStruct && (callOpcode == OpCodes.Callvirt || (callOpcode == OpCodes.Call && declaringType.IsStruct))) ||
instance_type.IsGenericParameter || declaringType.IsNullableType)
{
//
// If the expression implements IMemoryLocation, then
// we can optimize and use AddressOf on the
// return.
//
// If not we have to use some temporary storage for
// it.
var iml = instance as IMemoryLocation;
if (iml != null)
{
iml.AddressOf(ec, AddressOp.Load);
}
else
{
LocalTemporary temp = new LocalTemporary(instance_type);
instance.Emit(ec);
temp.Store(ec);
temp.AddressOf(ec, AddressOp.Load);
temp.Release(ec);
}
return(ReferenceContainer.MakeType(ec.Module, instance_type));
}
if (instance_type.IsEnum || instance_type.IsStruct)
{
instance.Emit(ec);
ec.Emit(OpCodes.Box, instance_type);
return(ec.BuiltinTypes.Object);
}
instance.Emit(ec);
return(instance_type);
}
void DoEmitStringSwitch (LocalTemporary value, EmitContext ec)
{
Label l_initialized = ec.DefineLabel ();
//
// Skip initialization when value is null
//
value.EmitBranchable (ec, null_target, false);
//
// Check if string dictionary is initialized and initialize
//
switch_cache_field.EmitBranchable (ec, l_initialized, true);
string_dictionary.EmitStatement (ec);
ec.MarkLabel (l_initialized);
LocalTemporary string_switch_variable = new LocalTemporary (TypeManager.int32_type);
ResolveContext rc = new ResolveContext (ec.MemberContext);
if (TypeManager.generic_ienumerable_type != null) {
Arguments get_value_args = new Arguments (2);
get_value_args.Add (new Argument (value));
get_value_args.Add (new Argument (string_switch_variable, Argument.AType.Out));
Expression get_item = new Invocation (new MemberAccess (switch_cache_field, "TryGetValue", loc), get_value_args).Resolve (rc);
if (get_item == null)
return;
//
// A value was not found, go to default case
//
get_item.EmitBranchable (ec, default_target, false);
} else {
Arguments get_value_args = new Arguments (1);
get_value_args.Add (new Argument (value));
Expression get_item = new ElementAccess (switch_cache_field, get_value_args, loc).Resolve (rc);
if (get_item == null)
return;
LocalTemporary get_item_object = new LocalTemporary (TypeManager.object_type);
get_item_object.EmitAssign (ec, get_item, true, false);
ec.Emit (OpCodes.Brfalse, default_target);
ExpressionStatement get_item_int = (ExpressionStatement) new SimpleAssign (string_switch_variable,
new Cast (new TypeExpression (TypeManager.int32_type, loc), get_item_object, loc)).Resolve (rc);
get_item_int.EmitStatement (ec);
get_item_object.Release (ec);
}
TableSwitchEmit (ec, string_switch_variable);
string_switch_variable.Release (ec);
}
static TypeSpec EmitCallInstance (EmitContext ec, Expression instance, TypeSpec declaringType, OpCode callOpcode)
{
var instance_type = instance.Type;
//
// Push the instance expression
//
if ((instance_type.IsStruct && (callOpcode == OpCodes.Callvirt || (callOpcode == OpCodes.Call && declaringType.IsStruct))) ||
instance_type.IsGenericParameter || declaringType.IsNullableType) {
//
// If the expression implements IMemoryLocation, then
// we can optimize and use AddressOf on the
// return.
//
// If not we have to use some temporary storage for
// it.
var iml = instance as IMemoryLocation;
if (iml != null) {
iml.AddressOf (ec, AddressOp.Load);
} else {
LocalTemporary temp = new LocalTemporary (instance_type);
instance.Emit (ec);
temp.Store (ec);
temp.AddressOf (ec, AddressOp.Load);
temp.Release (ec);
}
return ReferenceContainer.MakeType (ec.Module, instance_type);
}
if (instance_type.IsEnum || instance_type.IsStruct) {
instance.Emit (ec);
ec.Emit (OpCodes.Box, instance_type);
return ec.BuiltinTypes.Object;
}
instance.Emit (ec);
return instance_type;
}
//
// source is ignored, because we already have a copy of it from the
// LValue resolution and we have already constructed a pre-cached
// version of the arguments (ea.set_arguments);
//
public void EmitAssign (EmitContext ec, Expression source, bool leave_copy, bool prepare_for_load)
{
prepared = prepare_for_load;
Expression value = set_expr;
if (prepared) {
Invocation.EmitCall (ec, is_base_indexer, instance_expr, get,
arguments, loc, true, false);
prepared_value = new LocalTemporary (type);
prepared_value.Store (ec);
source.Emit (ec);
prepared_value.Release (ec);
if (leave_copy) {
ec.ig.Emit (OpCodes.Dup);
temp = new LocalTemporary (Type);
temp.Store (ec);
}
} else if (leave_copy) {
temp = new LocalTemporary (Type);
source.Emit (ec);
temp.Store (ec);
value = temp;
}
if (!prepared)
arguments.Add (new Argument (value));
Invocation.EmitCall (ec, is_base_indexer, instance_expr, set, arguments, loc, false, prepared);
if (temp != null) {
temp.Emit (ec);
temp.Release (ec);
}
}
