protected T machine_initializer;
int resume_pc;
ExceptionStatement inside_try_block;
+ TryCatch inside_catch_block;
protected YieldStatement (Expression expr, Location l)
{
machine_initializer = bc.CurrentAnonymousMethod as T;
inside_try_block = bc.CurrentTryBlock;
+ inside_catch_block = bc.CurrentTryCatch;
return true;
}
public void RegisterResumePoint ()
{
+ if (resume_pc != 0)
+ return;
+
if (inside_try_block == null) {
resume_pc = machine_initializer.AddResumePoint (this);
} else {
- resume_pc = inside_try_block.AddResumePoint (this, resume_pc, machine_initializer);
+ resume_pc = inside_try_block.AddResumePoint (this, resume_pc, machine_initializer, inside_catch_block);
unwind_protect = true;
inside_try_block = null;
}
protected override void CloneTo (CloneContext clonectx, Statement target)
{
- throw new NotSupportedException ();
}
protected override bool DoResolve (BlockContext bc)
Field pc_field;
StateMachineMethod method;
- int local_name_idx;
protected StateMachine (ParametersBlock block, TypeDefinition parent, MemberBase host, TypeParameters tparams, string name, MemberKind kind)
: base (block, parent, host, tparams, name, kind)
return base.DoDefineMembers ();
}
- protected override string GetVariableMangledName (LocalVariable local_info)
+ protected override string GetVariableMangledName (ResolveContext rc, LocalVariable local_info)
{
if (local_info.IsCompilerGenerated)
- return base.GetVariableMangledName (local_info);
+ return base.GetVariableMangledName (rc, local_info);
- return "<" + local_info.Name + ">__" + local_name_idx++.ToString ("X");
+ //
+ // Special format which encodes original variable name and
+ // it's scope to support lifted variables debugging. This
+ // is same what csc does and allows to correctly set fields
+ // scope information (like ambiguity, out of scope, etc).
+ //
+ var id = rc.CurrentBlock.Explicit.GetDebugSymbolScopeIndex ();
+ return "<" + local_info.Name + ">__" + id;
}
}
//
// The state as we generate the machine
//
- Label move_next_ok;
- Label iterator_body_end;
+ protected Label move_next_ok;
protected Label move_next_error;
LocalBuilder skip_finally;
protected LocalBuilder current_pc;
#region Properties
- public Label BodyEnd {
- get {
- return iterator_body_end;
- }
- }
+ public Label BodyEnd { get; set; }
public LocalBuilder CurrentPC
{
// We only care if the PC is zero (start executing) or non-zero (don't do anything)
ec.Emit (OpCodes.Brtrue, move_next_error);
- iterator_body_end = ec.DefineLabel ();
+ BodyEnd = ec.DefineLabel ();
+
+ var async_init = this as AsyncInitializer;
+ if (async_init != null)
+ ec.BeginExceptionBlock ();
block.EmitEmbedded (ec);
- ec.MarkLabel (iterator_body_end);
+ if (async_init != null)
+ async_init.EmitCatchBlock (ec);
+
+ ec.MarkLabel (BodyEnd);
EmitMoveNextEpilogue (ec);
ec.EmitInt (0);
ec.Emit (OpCodes.Ret);
}
+
+ ec.MarkLabel (move_next_ok);
}
void EmitMoveNext (EmitContext ec)
ec.MarkLabel (labels[0]);
- iterator_body_end = ec.DefineLabel ();
+ BodyEnd = ec.DefineLabel ();
block.EmitEmbedded (ec);
- ec.MarkLabel (iterator_body_end);
+ ec.MarkLabel (BodyEnd);
if (async_init != null) {
- var catch_value = LocalVariable.CreateCompilerGenerated (ec.Module.Compiler.BuiltinTypes.Exception, block, Location);
-
- ec.BeginCatchBlock (catch_value.Type);
- catch_value.EmitAssign (ec);
-
- ec.EmitThis ();
- ec.EmitInt ((int) IteratorStorey.State.After);
- ec.Emit (OpCodes.Stfld, storey.PC.Spec);
-
- ((AsyncTaskStorey) async_init.Storey).EmitSetException (ec, new LocalVariableReference (catch_value, Location));
-
- ec.Emit (OpCodes.Leave, move_next_ok);
- ec.EndExceptionBlock ();
+ async_init.EmitCatchBlock (ec);
}
ec.Mark (Block.Original.EndLocation);
method.Block = new ToplevelBlock (method.Compiler, method.ParameterInfo, loc,
ToplevelBlock.Flags.CompilerGenerated | ToplevelBlock.Flags.NoFlowAnalysis);
+
method.Block.AddStatement (new TryFinallyBlockProxyStatement (this, block));
// Cannot it add to storey because it'd be emitted before nested
return;
if (!CheckType (ret, parent, out iterator_type, out is_enumerable)) {
- parent.Compiler.Report.Error (1624, method.Location,
- "The body of `{0}' cannot be an iterator block " +
- "because `{1}' is not an iterator interface type",
- method.GetSignatureForError (),
- ret.GetSignatureForError ());
+ if (ret.Kind == MemberKind.ByRef) {
+ parent.Compiler.Report.Error (8154, method.Location,
+ "The body of `{0}' cannot be an iterator block because the method returns by reference",
+ method.GetSignatureForError ());
+ } else {
+ parent.Compiler.Report.Error (1624, method.Location,
+ "The body of `{0}' cannot be an iterator block because `{1}' is not an iterator interface type",
+ method.GetSignatureForError (), ret.GetSignatureForError ());
+ }
return;
}
}
if ((modifiers & Modifiers.UNSAFE) != 0) {
- parent.Compiler.Report.Error (1629, method.Location, "Unsafe code may not appear in iterators");
+ Expression.UnsafeInsideIteratorError (parent.Compiler.Report, method.Location);
}
method.Block = method.Block.ConvertToIterator (method, parent, iterator_type, is_enumerable);
projects / mono.git / blobdiff