X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fiterators.cs;h=cbf983c856f35415037a809edd3143a6dcc8a7ee;hb=732841a4f171062563a831fb8cd3165be1ddfd6e;hp=1d8d50f6244cbe55fdc46f1a01210f632b161be3;hpb=7dbb973a996579e750103bf1ff888d542278fe42;p=mono.git diff --git a/mcs/mcs/iterators.cs b/mcs/mcs/iterators.cs index 1d8d50f6244..cbf983c856f 100644 --- a/mcs/mcs/iterators.cs +++ b/mcs/mcs/iterators.cs @@ -15,7 +15,7 @@ // using System; -using System.Collections; +using System.Collections.Generic; using System.Reflection; using System.Reflection.Emit; @@ -24,7 +24,7 @@ namespace Mono.CSharp { public class Yield : ResumableStatement { Expression expr; bool unwind_protect; - + Iterator iterator; int resume_pc; public Yield (Expression expr, Location l) @@ -33,22 +33,14 @@ namespace Mono.CSharp { loc = l; } - public static bool CheckContext (EmitContext ec, Location loc, bool isYieldBreak) + public static bool CheckContext (ResolveContext ec, Location loc) { - for (Block block = ec.CurrentBlock; block != null; block = block.Parent) { - if (!block.Unsafe) - continue; - - Report.Error (1629, loc, "Unsafe code may not appear in iterators"); - return false; - } - // // We can't use `ec.InUnsafe' here because it's allowed to have an iterator // inside an unsafe class. See test-martin-29.cs for an example. // if (!ec.CurrentAnonymousMethod.IsIterator) { - Report.Error (1621, loc, + ec.Report.Error (1621, loc, "The yield statement cannot be used inside " + "anonymous method blocks"); return false; @@ -57,12 +49,7 @@ namespace Mono.CSharp { return true; } - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) - { - expr.MutateHoistedGenericType (storey); - } - - public override bool Resolve (EmitContext ec) + public override bool Resolve (BlockContext ec) { expr = expr.Resolve (ec); if (expr == null) @@ -71,10 +58,10 @@ namespace Mono.CSharp { Report.Debug (64, "RESOLVE YIELD #1", this, ec, expr, expr.GetType (), ec.CurrentAnonymousMethod, ec.CurrentIterator); - if (!CheckContext (ec, loc, false)) + if (!CheckContext (ec, loc)) return false; - Iterator iterator = ec.CurrentIterator; + iterator = ec.CurrentIterator; if (expr.Type != iterator.OriginalIteratorType) { expr = Convert.ImplicitConversionRequired ( ec, expr, iterator.OriginalIteratorType, loc); @@ -82,14 +69,15 @@ namespace Mono.CSharp { return false; } - unwind_protect = ec.CurrentBranching.AddResumePoint (this, loc, out resume_pc); + if (!ec.CurrentBranching.CurrentUsageVector.IsUnreachable) + unwind_protect = ec.CurrentBranching.AddResumePoint (this, loc, out resume_pc); return true; } protected override void DoEmit (EmitContext ec) { - ec.CurrentIterator.MarkYield (ec, expr, resume_pc, unwind_protect, resume_point); + iterator.MarkYield (ec, expr, resume_pc, unwind_protect, resume_point); } protected override void CloneTo (CloneContext clonectx, Statement t) @@ -100,30 +88,34 @@ namespace Mono.CSharp { } } - public class YieldBreak : ExitStatement { + public class YieldBreak : ExitStatement + { + Iterator iterator; + public YieldBreak (Location l) { loc = l; } - public override void Error_FinallyClause () + public override void Error_FinallyClause (Report Report) { Report.Error (1625, loc, "Cannot yield in the body of a finally clause"); } - protected override bool DoResolve (EmitContext ec) + protected override void CloneTo (CloneContext clonectx, Statement target) { - return Yield.CheckContext (ec, loc, true); + throw new NotSupportedException (); } - protected override void DoEmit (EmitContext ec) + protected override bool DoResolve (BlockContext ec) { - ec.CurrentIterator.EmitYieldBreak (ec.ig, unwind_protect); + iterator = ec.CurrentIterator; + return Yield.CheckContext (ec, loc); } - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) + protected override void DoEmit (EmitContext ec) { - // nothing to do + iterator.EmitYieldBreak (ec, unwind_protect); } } @@ -133,16 +125,23 @@ namespace Mono.CSharp { class IteratorStatement : Statement { Iterator iterator; - ExplicitBlock original_block; + Block original_block; - public IteratorStatement (Iterator iterator, ExplicitBlock original_block) + public IteratorStatement (Iterator iterator, Block original_block) { this.iterator = iterator; this.original_block = original_block; this.loc = iterator.Location; } - public override bool Resolve (EmitContext ec) + protected override void CloneTo (CloneContext clonectx, Statement target) + { + IteratorStatement t = (IteratorStatement) target; + t.original_block = (ExplicitBlock) original_block.Clone (clonectx); + t.iterator = (Iterator) iterator.Clone (clonectx); + } + + public override bool Resolve (BlockContext ec) { ec.StartFlowBranching (iterator); bool ok = original_block.Resolve (ec); @@ -154,16 +153,223 @@ namespace Mono.CSharp { { iterator.EmitMoveNext (ec, original_block); } - - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) - { - original_block.MutateHoistedGenericType (storey); - iterator.MutateHoistedGenericType (storey); - } } public class IteratorStorey : AnonymousMethodStorey { + class IteratorMethod : Method + { + readonly IteratorStorey host; + + public IteratorMethod (IteratorStorey host, FullNamedExpression returnType, Modifiers mod, MemberName name) + : base (host, null, returnType, mod | Modifiers.DEBUGGER_HIDDEN | Modifiers.COMPILER_GENERATED, + name, ParametersCompiled.EmptyReadOnlyParameters, null) + { + this.host = host; + + Block = new ToplevelBlock (Compiler, host.Iterator.Container.Toplevel, ParametersCompiled.EmptyReadOnlyParameters, Location); + } + + public override EmitContext CreateEmitContext (ILGenerator ig) + { + EmitContext ec = new EmitContext (this, ig, MemberType); + + ec.CurrentAnonymousMethod = host.Iterator; + return ec; + } + } + + class GetEnumeratorMethod : IteratorMethod + { + sealed class GetEnumeratorStatement : Statement + { + IteratorStorey host; + IteratorMethod host_method; + + Expression new_storey; + + public GetEnumeratorStatement (IteratorStorey host, IteratorMethod host_method) + { + this.host = host; + this.host_method = host_method; + loc = host_method.Location; + } + + protected override void CloneTo (CloneContext clonectx, Statement target) + { + throw new NotSupportedException (); + } + + public override bool Resolve (BlockContext ec) + { + TypeExpression storey_type_expr = new TypeExpression (host.Definition, loc); + List init = null; + if (host.hoisted_this != null) { + init = new List (host.hoisted_params == null ? 1 : host.HoistedParameters.Count + 1); + HoistedThis ht = host.hoisted_this; + FieldExpr from = new FieldExpr (ht.Field, loc); + from.InstanceExpression = CompilerGeneratedThis.Instance; + init.Add (new ElementInitializer (ht.Field.Name, from, loc)); + } + + if (host.hoisted_params != null) { + if (init == null) + init = new List (host.HoistedParameters.Count); + + for (int i = 0; i < host.hoisted_params.Count; ++i) { + HoistedParameter hp = (HoistedParameter) host.hoisted_params [i]; + HoistedParameter hp_cp = (HoistedParameter) host.hoisted_params_copy [i]; + + FieldExpr from = new FieldExpr (hp_cp.Field, loc); + from.InstanceExpression = CompilerGeneratedThis.Instance; + + init.Add (new ElementInitializer (hp.Field.Name, from, loc)); + } + } + + if (init != null) { + new_storey = new NewInitialize (storey_type_expr, null, + new CollectionOrObjectInitializers (init, loc), loc); + } else { + new_storey = new New (storey_type_expr, null, loc); + } + + new_storey = new_storey.Resolve (ec); + if (new_storey != null) + new_storey = Convert.ImplicitConversionRequired (ec, new_storey, host_method.MemberType, loc); + + if (TypeManager.int_interlocked_compare_exchange == null) { + TypeSpec t = TypeManager.CoreLookupType (ec.Compiler, "System.Threading", "Interlocked", MemberKind.Class, true); + if (t != null) { + var p = ParametersCompiled.CreateFullyResolved ( + new[] { + new ParameterData (null, Parameter.Modifier.REF), + new ParameterData (null, Parameter.Modifier.NONE), + new ParameterData (null, Parameter.Modifier.NONE) + }, + new[] { + TypeManager.int32_type, TypeManager.int32_type, TypeManager.int32_type + } + ); + var f = new MemberFilter ("CompareExchange", 0, MemberKind.Method, p, TypeManager.int32_type); + TypeManager.int_interlocked_compare_exchange = TypeManager.GetPredefinedMethod (t, f, loc); + } + } + + ec.CurrentBranching.CurrentUsageVector.Goto (); + return true; + } + + protected override void DoEmit (EmitContext ec) + { + Label label_init = ec.DefineLabel (); + + ec.Emit (OpCodes.Ldarg_0); + ec.Emit (OpCodes.Ldflda, host.PC.Spec); + ec.EmitInt ((int) Iterator.State.Start); + ec.EmitInt ((int) Iterator.State.Uninitialized); + ec.Emit (OpCodes.Call, TypeManager.int_interlocked_compare_exchange); + + ec.EmitInt ((int) Iterator.State.Uninitialized); + ec.Emit (OpCodes.Bne_Un_S, label_init); + + ec.Emit (OpCodes.Ldarg_0); + ec.Emit (OpCodes.Ret); + + ec.MarkLabel (label_init); + + new_storey.Emit (ec); + ec.Emit (OpCodes.Ret); + } + } + + public GetEnumeratorMethod (IteratorStorey host, FullNamedExpression returnType, MemberName name) + : base (host, returnType, 0, name) + { + Block.AddStatement (new GetEnumeratorStatement (host, this)); + } + } + + class DisposeMethod : IteratorMethod + { + sealed class DisposeMethodStatement : Statement + { + Iterator iterator; + + public DisposeMethodStatement (Iterator iterator) + { + this.iterator = iterator; + this.loc = iterator.Location; + } + + protected override void CloneTo (CloneContext clonectx, Statement target) + { + throw new NotSupportedException (); + } + + public override bool Resolve (BlockContext ec) + { + return true; + } + + protected override void DoEmit (EmitContext ec) + { + iterator.EmitDispose (ec); + } + } + + public DisposeMethod (IteratorStorey host) + : base (host, TypeManager.system_void_expr, Modifiers.PUBLIC, new MemberName ("Dispose", host.Location)) + { + host.AddMethod (this); + + Block = new ToplevelBlock (Compiler, host.Iterator.Container, ParametersCompiled.EmptyReadOnlyParameters, Location); + Block.AddStatement (new DisposeMethodStatement (host.Iterator)); + } + } + + // + // Uses Method as method info + // + class DynamicMethodGroupExpr : MethodGroupExpr + { + readonly Method method; + + public DynamicMethodGroupExpr (Method method, Location loc) + : base (null, loc) + { + this.method = method; + eclass = ExprClass.Unresolved; + } + + protected override Expression DoResolve (ResolveContext ec) + { + Methods = new List (1) { method.Spec }; + type = method.Parent.Definition; + InstanceExpression = new CompilerGeneratedThis (type, Location); + return base.DoResolve (ec); + } + } + + class DynamicFieldExpr : FieldExpr + { + readonly Field field; + + public DynamicFieldExpr (Field field, Location loc) + : base (loc) + { + this.field = field; + } + + protected override Expression DoResolve (ResolveContext ec) + { + spec = field.Spec; + type = spec.MemberType; + InstanceExpression = new CompilerGeneratedThis (type, Location); + return base.DoResolve (ec); + } + } + public readonly Iterator Iterator; TypeExpr iterator_type_expr; @@ -174,10 +380,9 @@ namespace Mono.CSharp { TypeExpr enumerable_type; TypeArguments generic_args; TypeExpr generic_enumerator_type; -#if GMCS_SOURCE TypeExpr generic_enumerable_type; -#endif + List hoisted_params_copy; int local_name_idx; public IteratorStorey (Iterator iterator) @@ -195,31 +400,31 @@ namespace Mono.CSharp { get { return current_field; } } - public ArrayList HoistedParameters { + public IList HoistedParameters { get { return hoisted_params; } } - public override TypeExpr [] GetClassBases (out TypeExpr base_class) + protected override TypeExpr [] ResolveBaseTypes (out TypeExpr base_class) { - iterator_type_expr = new TypeExpression (MutateType (Iterator.OriginalIteratorType), Location); + var mtype = Iterator.OriginalIteratorType; + if (Mutator != null) + mtype = Mutator.Mutate (mtype); -#if GMCS_SOURCE - generic_args = new TypeArguments (Location); - generic_args.Add (iterator_type_expr); -#endif + iterator_type_expr = new TypeExpression (mtype, Location); + generic_args = new TypeArguments (iterator_type_expr); - ArrayList list = new ArrayList (); + var list = new List (); if (Iterator.IsEnumerable) { enumerable_type = new TypeExpression ( TypeManager.ienumerable_type, Location); list.Add (enumerable_type); -#if GMCS_SOURCE - generic_enumerable_type = new ConstructedType ( - TypeManager.generic_ienumerable_type, - generic_args, Location); - list.Add (generic_enumerable_type); -#endif + if (TypeManager.generic_ienumerable_type != null) { + generic_enumerable_type = new GenericTypeExpr ( + TypeManager.generic_ienumerable_type, + generic_args, Location); + list.Add (generic_enumerable_type); + } } enumerator_type = new TypeExpression ( @@ -228,16 +433,16 @@ namespace Mono.CSharp { list.Add (new TypeExpression (TypeManager.idisposable_type, Location)); -#if GMCS_SOURCE - generic_enumerator_type = new ConstructedType ( - TypeManager.generic_ienumerator_type, - generic_args, Location); - list.Add (generic_enumerator_type); -#endif + if (TypeManager.generic_ienumerator_type != null) { + generic_enumerator_type = new GenericTypeExpr ( + TypeManager.generic_ienumerator_type, + generic_args, Location); + list.Add (generic_enumerator_type); + } type_bases = list; - return base.GetClassBases (out base_class); + return base.ResolveBaseTypes (out base_class); } protected override string GetVariableMangledName (LocalInfo local_info) @@ -245,52 +450,97 @@ namespace Mono.CSharp { return "<" + local_info.Name + ">__" + local_name_idx++.ToString (); } - public void DefineIteratorMembers () + protected override bool DoDefineMembers () + { + DefineIteratorMembers (); + return base.DoDefineMembers (); + } + + void DefineIteratorMembers () { pc_field = AddCompilerGeneratedField ("$PC", TypeManager.system_int32_expr); current_field = AddCompilerGeneratedField ("$current", iterator_type_expr); -#if GMCS_SOURCE - Define_Current (true); -#endif + if (hoisted_params != null) { + // + // Iterators are independent, each GetEnumerator call has to + // create same enumerator therefore we have to keep original values + // around for re-initialization + // + // TODO: Do it for assigned/modified parameters only + // + hoisted_params_copy = new List (hoisted_params.Count); + foreach (HoistedParameter hp in hoisted_params) { + hoisted_params_copy.Add (new HoistedParameter (hp, "<$>" + hp.Field.Name)); + } + } + + if (generic_enumerator_type != null) + Define_Current (true); + Define_Current (false); new DisposeMethod (this); Define_Reset (); if (Iterator.IsEnumerable) { - new GetEnumeratorMethod (this, false); -#if GMCS_SOURCE - new GetEnumeratorMethod (this, true); -#endif + MemberName name = new MemberName (QualifiedAliasMember.GlobalAlias, "System", null, Location); + name = new MemberName (name, "Collections", Location); + name = new MemberName (name, "IEnumerable", Location); + name = new MemberName (name, "GetEnumerator", Location); + + if (generic_enumerator_type != null) { + Method get_enumerator = new IteratorMethod (this, enumerator_type, 0, name); + + name = new MemberName (name.Left.Left, "Generic", Location); + name = new MemberName (name, "IEnumerable", generic_args, Location); + name = new MemberName (name, "GetEnumerator", Location); + Method gget_enumerator = new GetEnumeratorMethod (this, generic_enumerator_type, name); + + // + // Just call generic GetEnumerator implementation + // + get_enumerator.Block.AddStatement ( + new Return (new Invocation (new DynamicMethodGroupExpr (gget_enumerator, Location), null), Location)); + + AddMethod (get_enumerator); + AddMethod (gget_enumerator); + } else { + AddMethod (new GetEnumeratorMethod (this, enumerator_type, name)); + } } + } - DoResolveMembers (); + protected override void EmitHoistedParameters (EmitContext ec, IList hoisted) + { + base.EmitHoistedParameters (ec, hoisted); + base.EmitHoistedParameters (ec, hoisted_params_copy); } void Define_Current (bool is_generic) { - MemberName left; TypeExpr type; + MemberName name = new MemberName (QualifiedAliasMember.GlobalAlias, "System", null, Location); + name = new MemberName (name, "Collections", Location); + if (is_generic) { - left = new MemberName ( - "System.Collections.Generic.IEnumerator", - generic_args, Location); + name = new MemberName (name, "Generic", Location); + name = new MemberName (name, "IEnumerator", generic_args, Location); type = iterator_type_expr; } else { - left = new MemberName ("System.Collections.IEnumerator", Location); + name = new MemberName (name, "IEnumerator"); type = TypeManager.system_object_expr; } - MemberName name = new MemberName (left, "Current", null, Location); - - ToplevelBlock get_block = new ToplevelBlock (Location); - get_block.AddStatement (new CurrentBlock (this, is_generic)); + name = new MemberName (name, "Current", Location); - Accessor getter = new Accessor (get_block, 0, null, Location); + ToplevelBlock get_block = new ToplevelBlock (Compiler, Location); + get_block.AddStatement (new Return (new DynamicFieldExpr (CurrentField, Location), Location)); + + Accessor getter = new Accessor (get_block, 0, null, null, Location); Property current = new Property ( - this, type, Modifiers.DEBUGGER_HIDDEN, false, name, null, getter, null, false); + this, type, Modifiers.DEBUGGER_HIDDEN, name, null, getter, null, false); AddProperty (current); } @@ -299,243 +549,17 @@ namespace Mono.CSharp { Method reset = new Method ( this, null, TypeManager.system_void_expr, Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN, - false, new MemberName ("Reset", Location), - Parameters.EmptyReadOnlyParameters, null); + new MemberName ("Reset", Location), + ParametersCompiled.EmptyReadOnlyParameters, null); AddMethod (reset); - reset.Block = new ToplevelBlock (Location); - reset.Block.AddStatement (Create_ThrowNotSupported ()); - } - - Statement Create_ThrowNotSupported () - { - TypeExpr ex_type = new TypeLookupExpression ("System.NotSupportedException"); - - return new Throw (new New (ex_type, null, Location), Location); - } - - protected class GetEnumeratorMethod : Method - { - public IteratorStorey Host; - - static MemberName GetMemberName (IteratorStorey host, bool is_generic) - { - MemberName left; - if (is_generic) { - left = new MemberName ( - "System.Collections.Generic.IEnumerable", - host.generic_args, host.Location); - } else { - left = new MemberName ( - "System.Collections.IEnumerable", host.Location); - } - - return new MemberName (left, "GetEnumerator", host.Location); - } - - public GetEnumeratorMethod (IteratorStorey host, bool is_generic) - : base (host, null, is_generic ? - host.generic_enumerator_type : host.enumerator_type, - Modifiers.DEBUGGER_HIDDEN, false, GetMemberName (host, is_generic), - Parameters.EmptyReadOnlyParameters, null) - { - this.Host = host; - - host.AddMethod (this); + reset.Block = new ToplevelBlock (Compiler, Location); - Block = new ToplevelBlock (host.Iterator.Container.Toplevel, null, Location); - Block.AddStatement (new GetEnumeratorStatement (host, type_name)); - } - - public override EmitContext CreateEmitContext (DeclSpace tc, ILGenerator ig) - { - EmitContext ec = new EmitContext ( - this, tc, this.ds, Location, ig, MemberType, ModFlags, false); - - ec.CurrentAnonymousMethod = Host.Iterator; - return ec; - } - - protected class GetEnumeratorStatement : Statement - { - IteratorStorey host; - Expression type; - - Expression cast; - - public GetEnumeratorStatement (IteratorStorey host, Expression type) - { - this.host = host; - this.type = type; - loc = host.Location; - } - - public override bool Resolve (EmitContext ec) - { - type = type.ResolveAsTypeTerminal (ec, false); - if ((type == null) || (type.Type == null)) - return false; - - TypeExpression storey_type_expr = new TypeExpression (host.TypeBuilder, loc); - Expression new_storey; - if (host.hoisted_params != null) { - ArrayList init = new ArrayList (host.HoistedParameters.Count); - foreach (HoistedParameter hp in host.HoistedParameters) { - FieldExpr from = new FieldExpr (hp.Field.FieldBuilder, loc); - from.InstanceExpression = CompilerGeneratedThis.Instance; - init.Add (new ElementInitializer (hp.Field.Name, from, loc)); - } - - new_storey = new NewInitialize (storey_type_expr, new ArrayList (0), - new CollectionOrObjectInitializers (init, loc), loc); - } else { - new_storey = new New (storey_type_expr, new ArrayList (0), loc); - } - - new_storey = new_storey.Resolve (ec); - if (new_storey != null) - cast = Convert.ImplicitConversionRequired (ec, new_storey, type.Type, loc); - - if (TypeManager.int_interlocked_compare_exchange == null) { - Type t = TypeManager.CoreLookupType ("System.Threading", "Interlocked", Kind.Class, true); - if (t != null) { - TypeManager.int_interlocked_compare_exchange = TypeManager.GetPredefinedMethod ( - t, "CompareExchange", loc, TypeManager.GetReferenceType (TypeManager.int32_type), - TypeManager.int32_type, TypeManager.int32_type); - } - } - - ec.CurrentBranching.CurrentUsageVector.Goto (); - return true; - } - - protected override void DoEmit (EmitContext ec) - { - ILGenerator ig = ec.ig; - Label label_init = ig.DefineLabel (); - - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Ldflda, host.PC.FieldBuilder); - ig.Emit (OpCodes.Ldc_I4, (int) Iterator.State.Start); - ig.Emit (OpCodes.Ldc_I4, (int) Iterator.State.Uninitialized); - ig.Emit (OpCodes.Call, TypeManager.int_interlocked_compare_exchange); - - ig.Emit (OpCodes.Ldc_I4, (int) Iterator.State.Uninitialized); - ig.Emit (OpCodes.Bne_Un, label_init); - - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Ret); - - ig.MarkLabel (label_init); - - cast.Emit (ec); - ig.Emit (OpCodes.Ret); - } - - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) - { - throw new NotSupportedException (); - } - } - } - - protected class DisposeMethod : Method - { - readonly IteratorStorey Host; - - public DisposeMethod (IteratorStorey host) - : base (host, null, TypeManager.system_void_expr, - Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN | Modifiers.COMPILER_GENERATED, - false, new MemberName ("Dispose", host.Location), - Parameters.EmptyReadOnlyParameters, null) - { - this.Host = host; - - host.AddMethod (this); - - Block = new ToplevelBlock (host.Iterator.Container, null, Location); - Block.AddStatement (new DisposeMethodStatement (Host.Iterator)); - - Report.Debug (64, "DISPOSE METHOD", host, Block); - } - - public override EmitContext CreateEmitContext (DeclSpace tc, ILGenerator ig) - { - EmitContext ec = new EmitContext ( - this, tc, this.ds, Location, ig, MemberType, ModFlags, false); - - ec.CurrentAnonymousMethod = Host.Iterator; - return ec; - } - - //public override void Emit () - //{ - // if (Parent.MemberName.IsGeneric) - // block.MutateHoistedGenericType (Host.Iterator.Storey); - - // base.Emit (); - //} - - protected class DisposeMethodStatement : Statement - { - Iterator iterator; - - public DisposeMethodStatement (Iterator iterator) - { - this.iterator = iterator; - this.loc = iterator.Location; - } - - public override bool Resolve (EmitContext ec) - { - return true; - } - - protected override void DoEmit (EmitContext ec) - { - iterator.EmitDispose (ec); - } - - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) - { - throw new NotSupportedException (); - } - } - } - - protected class CurrentBlock : Statement { - IteratorStorey host; - bool is_generic; - - public CurrentBlock (IteratorStorey host, bool is_generic) - { - this.host = host; - this.is_generic = is_generic; - loc = host.Location; - } - - public override bool Resolve (EmitContext ec) - { - // We emit a 'ret', so prevent the enclosing TopLevelBlock from emitting one too - ec.CurrentBranching.CurrentUsageVector.Goto (); - return true; - } - - protected override void DoEmit (EmitContext ec) - { - ILGenerator ig = ec.ig; - - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Ldfld, host.CurrentField.FieldBuilder); - if (!is_generic) - ig.Emit (OpCodes.Box, host.CurrentField.MemberType); - ig.Emit (OpCodes.Ret); - } + TypeSpec ex_type = TypeManager.CoreLookupType (Compiler, "System", "NotSupportedException", MemberKind.Class, true); + if (ex_type == null) + return; - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) - { - throw new NotSupportedException (); - } + reset.Block.AddStatement (new Throw (new New (new TypeExpression (ex_type, Location), null, Location), Location)); } } @@ -544,8 +568,10 @@ namespace Mono.CSharp { // public class Iterator : AnonymousExpression { public readonly IMethodData OriginalMethod; - + AnonymousMethodMethod method; + public readonly TypeContainer Host; public readonly bool IsEnumerable; + List resume_points; // // The state as we generate the iterator @@ -569,7 +595,7 @@ namespace Mono.CSharp { get { return OriginalMethod.GenericMethod; } } - public readonly Type OriginalIteratorType; + public readonly TypeSpec OriginalIteratorType; readonly IteratorStorey IteratorHost; @@ -580,45 +606,36 @@ namespace Mono.CSharp { Start = 0 } - public override void AddStoreyReference (AnonymousMethodStorey storey) + public void EmitYieldBreak (EmitContext ec, bool unwind_protect) { - // do nothing - } - - public void EmitYieldBreak (ILGenerator ig, bool unwind_protect) - { - ig.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_error); + ec.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_error); } void EmitMoveNext_NoResumePoints (EmitContext ec, Block original_block) { - ILGenerator ig = ec.ig; - - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Ldfld, IteratorHost.PC.FieldBuilder); + ec.Emit (OpCodes.Ldarg_0); + ec.Emit (OpCodes.Ldfld, IteratorHost.PC.Spec); - ig.Emit (OpCodes.Ldarg_0); - IntConstant.EmitInt (ig, (int) State.After); - ig.Emit (OpCodes.Stfld, IteratorHost.PC.FieldBuilder); + ec.Emit (OpCodes.Ldarg_0); + ec.EmitInt ((int) State.After); + ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec); // We only care if the PC is zero (start executing) or non-zero (don't do anything) - ig.Emit (OpCodes.Brtrue, move_next_error); + ec.Emit (OpCodes.Brtrue, move_next_error); - SymbolWriter.StartIteratorBody (ec.ig); + SymbolWriter.StartIteratorBody (ec); original_block.Emit (ec); - SymbolWriter.EndIteratorBody (ec.ig); + SymbolWriter.EndIteratorBody (ec); - ig.MarkLabel (move_next_error); - ig.Emit (OpCodes.Ldc_I4_0); - ig.Emit (OpCodes.Ret); + ec.MarkLabel (move_next_error); + ec.Emit (OpCodes.Ldc_I4_0); + ec.Emit (OpCodes.Ret); } internal void EmitMoveNext (EmitContext ec, Block original_block) { - ILGenerator ig = ec.ig; - - move_next_ok = ig.DefineLabel (); - move_next_error = ig.DefineLabel (); + move_next_ok = ec.DefineLabel (); + move_next_error = ec.DefineLabel (); if (resume_points == null) { EmitMoveNext_NoResumePoints (ec, original_block); @@ -626,66 +643,64 @@ namespace Mono.CSharp { } current_pc = ec.GetTemporaryLocal (TypeManager.uint32_type); - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Ldfld, IteratorHost.PC.FieldBuilder); - ig.Emit (OpCodes.Stloc, current_pc); + ec.Emit (OpCodes.Ldarg_0); + ec.Emit (OpCodes.Ldfld, IteratorHost.PC.Spec); + ec.Emit (OpCodes.Stloc, current_pc); // We're actually in state 'running', but this is as good a PC value as any if there's an abnormal exit - ig.Emit (OpCodes.Ldarg_0); - IntConstant.EmitInt (ig, (int) State.After); - ig.Emit (OpCodes.Stfld, IteratorHost.PC.FieldBuilder); + ec.Emit (OpCodes.Ldarg_0); + ec.EmitInt ((int) State.After); + ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec); Label [] labels = new Label [1 + resume_points.Count]; - labels [0] = ig.DefineLabel (); + labels [0] = ec.DefineLabel (); bool need_skip_finally = false; for (int i = 0; i < resume_points.Count; ++i) { - ResumableStatement s = (ResumableStatement) resume_points [i]; + ResumableStatement s = resume_points [i]; need_skip_finally |= s is ExceptionStatement; labels [i+1] = s.PrepareForEmit (ec); } if (need_skip_finally) { skip_finally = ec.GetTemporaryLocal (TypeManager.bool_type); - ig.Emit (OpCodes.Ldc_I4_0); - ig.Emit (OpCodes.Stloc, skip_finally); + ec.Emit (OpCodes.Ldc_I4_0); + ec.Emit (OpCodes.Stloc, skip_finally); } - SymbolWriter.StartIteratorDispatcher (ec.ig); - ig.Emit (OpCodes.Ldloc, current_pc); - ig.Emit (OpCodes.Switch, labels); + SymbolWriter.StartIteratorDispatcher (ec); + ec.Emit (OpCodes.Ldloc, current_pc); + ec.Emit (OpCodes.Switch, labels); - ig.Emit (OpCodes.Br, move_next_error); - SymbolWriter.EndIteratorDispatcher (ec.ig); + ec.Emit (OpCodes.Br, move_next_error); + SymbolWriter.EndIteratorDispatcher (ec); - ig.MarkLabel (labels [0]); + ec.MarkLabel (labels [0]); - SymbolWriter.StartIteratorBody (ec.ig); + SymbolWriter.StartIteratorBody (ec); original_block.Emit (ec); - SymbolWriter.EndIteratorBody (ec.ig); + SymbolWriter.EndIteratorBody (ec); - SymbolWriter.StartIteratorDispatcher (ec.ig); + SymbolWriter.StartIteratorDispatcher (ec); - ig.Emit (OpCodes.Ldarg_0); - IntConstant.EmitInt (ig, (int) State.After); - ig.Emit (OpCodes.Stfld, IteratorHost.PC.FieldBuilder); + ec.Emit (OpCodes.Ldarg_0); + ec.EmitInt ((int) State.After); + ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec); - ig.MarkLabel (move_next_error); - ig.Emit (OpCodes.Ldc_I4_0); - ig.Emit (OpCodes.Ret); + ec.MarkLabel (move_next_error); + ec.EmitInt (0); + ec.Emit (OpCodes.Ret); - ig.MarkLabel (move_next_ok); - ig.Emit (OpCodes.Ldc_I4_1); - ig.Emit (OpCodes.Ret); + ec.MarkLabel (move_next_ok); + ec.Emit (OpCodes.Ldc_I4_1); + ec.Emit (OpCodes.Ret); - SymbolWriter.EndIteratorDispatcher (ec.ig); + SymbolWriter.EndIteratorDispatcher (ec); } public void EmitDispose (EmitContext ec) { - ILGenerator ig = ec.ig; - - Label end = ig.DefineLabel (); + Label end = ec.DefineLabel (); Label [] labels = null; int n_resume_points = resume_points == null ? 0 : resume_points.Count; @@ -704,34 +719,33 @@ namespace Mono.CSharp { if (labels != null) { current_pc = ec.GetTemporaryLocal (TypeManager.uint32_type); - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Ldfld, IteratorHost.PC.FieldBuilder); - ig.Emit (OpCodes.Stloc, current_pc); + ec.Emit (OpCodes.Ldarg_0); + ec.Emit (OpCodes.Ldfld, IteratorHost.PC.Spec); + ec.Emit (OpCodes.Stloc, current_pc); } - ig.Emit (OpCodes.Ldarg_0); - IntConstant.EmitInt (ig, (int) State.After); - ig.Emit (OpCodes.Stfld, IteratorHost.PC.FieldBuilder); + ec.Emit (OpCodes.Ldarg_0); + ec.EmitInt ((int) State.After); + ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec); if (labels != null) { //SymbolWriter.StartIteratorDispatcher (ec.ig); - ig.Emit (OpCodes.Ldloc, current_pc); - ig.Emit (OpCodes.Switch, labels); + ec.Emit (OpCodes.Ldloc, current_pc); + ec.Emit (OpCodes.Switch, labels); //SymbolWriter.EndIteratorDispatcher (ec.ig); foreach (ResumableStatement s in resume_points) s.EmitForDispose (ec, this, end, true); } - ig.MarkLabel (end); + ec.MarkLabel (end); } - - ArrayList resume_points; - public int AddResumePoint (ResumableStatement stmt, Location loc) + public int AddResumePoint (ResumableStatement stmt) { if (resume_points == null) - resume_points = new ArrayList (); + resume_points = new List (); + resume_points.Add (stmt); return resume_points.Count; } @@ -741,28 +755,26 @@ namespace Mono.CSharp { // public void MarkYield (EmitContext ec, Expression expr, int resume_pc, bool unwind_protect, Label resume_point) { - ILGenerator ig = ec.ig; - // Store the new current - ig.Emit (OpCodes.Ldarg_0); + ec.Emit (OpCodes.Ldarg_0); expr.Emit (ec); - ig.Emit (OpCodes.Stfld, IteratorHost.CurrentField.FieldBuilder); + ec.Emit (OpCodes.Stfld, IteratorHost.CurrentField.Spec); // store resume program-counter - ig.Emit (OpCodes.Ldarg_0); - IntConstant.EmitInt (ig, resume_pc); - ig.Emit (OpCodes.Stfld, IteratorHost.PC.FieldBuilder); + ec.Emit (OpCodes.Ldarg_0); + ec.EmitInt (resume_pc); + ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec); // mark finally blocks as disabled if (unwind_protect && skip_finally != null) { - ig.Emit (OpCodes.Ldc_I4_1); - ig.Emit (OpCodes.Stloc, skip_finally); + ec.EmitInt (1); + ec.Emit (OpCodes.Stloc, skip_finally); } // Return ok - ig.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_ok); + ec.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_ok); - ig.MarkLabel (resume_point); + ec.MarkLabel (resume_point); } public override string ContainerType { @@ -780,15 +792,17 @@ namespace Mono.CSharp { // // Our constructor // - private Iterator (IMethodData method, DeclSpace host, Type iterator_type, bool is_enumerable) - : base (host, - new ToplevelBlock (method.Block, Parameters.EmptyReadOnlyParameters, method.Block.StartLocation), + private Iterator (CompilerContext ctx, IMethodData method, TypeContainer host, TypeSpec iterator_type, bool is_enumerable) + : base ( + new ToplevelBlock (ctx, method.Block, ParametersCompiled.EmptyReadOnlyParameters, method.Block.StartLocation), TypeManager.bool_type, method.Location) { this.OriginalMethod = method; this.OriginalIteratorType = iterator_type; this.IsEnumerable = is_enumerable; + this.Host = host; + this.type = method.ReturnType; IteratorHost = Block.ChangeToIterator (this, method.Block); } @@ -798,21 +812,18 @@ namespace Mono.CSharp { return OriginalMethod.GetSignatureForError (); } - public override Expression DoResolve (EmitContext ec) + protected override Expression DoResolve (ResolveContext ec) { method = new AnonymousMethodMethod (Storey, this, Storey, null, TypeManager.system_boolean_expr, Modifiers.PUBLIC, OriginalMethod.GetSignatureForError (), new MemberName ("MoveNext", Location), - Parameters.EmptyReadOnlyParameters); + ParametersCompiled.EmptyReadOnlyParameters); - if (!Compatible (ec)) + if (Compatible (ec) == null) return null; - IteratorHost.DefineIteratorMembers (); - eclass = ExprClass.Value; - type = ec.ReturnType; return this; } @@ -827,35 +838,34 @@ namespace Mono.CSharp { // Initialize iterator PC when it's unitialized // if (IsEnumerable) { - ILGenerator ig = ec.ig; - ig.Emit (OpCodes.Dup); - IntConstant.EmitInt (ig, (int)State.Uninitialized); + ec.Emit (OpCodes.Dup); + ec.EmitInt ((int)State.Uninitialized); - FieldInfo field = IteratorHost.PC.FieldBuilder; -#if GMCS_SOURCE - if (Storey.IsGeneric) - field = TypeBuilder.GetField (Storey.Instance.Type, field); -#endif - ig.Emit (OpCodes.Stfld, field); + var field = IteratorHost.PC.Spec; + if (Storey.MemberName.IsGeneric) { + field = MemberCache.GetMember (Storey.Instance.Type, field); + } + + ec.Emit (OpCodes.Stfld, field); } } - public override Expression CreateExpressionTree (EmitContext ec) + public override Expression CreateExpressionTree (ResolveContext ec) { throw new NotSupportedException ("ET"); } - public static void CreateIterator (IMethodData method, DeclSpace parent, int modifiers) + public static void CreateIterator (IMethodData method, TypeContainer parent, Modifiers modifiers, CompilerContext ctx) { bool is_enumerable; - Type iterator_type; + TypeSpec iterator_type; - Type ret = method.ReturnType; + TypeSpec ret = method.ReturnType; if (ret == null) return; if (!CheckType (ret, out iterator_type, out is_enumerable)) { - Report.Error (1624, method.Location, + ctx.Report.Error (1624, method.Location, "The body of `{0}' cannot be an iterator block " + "because `{1}' is not an iterator interface type", method.GetSignatureForError (), @@ -863,24 +873,24 @@ namespace Mono.CSharp { return; } - Parameters parameters = method.ParameterInfo; + ParametersCompiled parameters = method.ParameterInfo; for (int i = 0; i < parameters.Count; i++) { Parameter p = parameters [i]; Parameter.Modifier mod = p.ModFlags; if ((mod & Parameter.Modifier.ISBYREF) != 0) { - Report.Error (1623, p.Location, + ctx.Report.Error (1623, p.Location, "Iterators cannot have ref or out parameters"); return; } - if ((mod & Parameter.Modifier.ARGLIST) != 0) { - Report.Error (1636, method.Location, + if (p is ArglistParameter) { + ctx.Report.Error (1636, method.Location, "__arglist is not allowed in parameter list of iterators"); return; } - if (p.ParameterType.IsPointer) { - Report.Error (1637, p.Location, + if (parameters.Types [i].IsPointer) { + ctx.Report.Error (1637, p.Location, "Iterators cannot have unsafe parameters or " + "yield types"); return; @@ -888,15 +898,15 @@ namespace Mono.CSharp { } if ((modifiers & Modifiers.UNSAFE) != 0) { - Report.Error (1629, method.Location, "Unsafe code may not appear in iterators"); + ctx.Report.Error (1629, method.Location, "Unsafe code may not appear in iterators"); return; } - Iterator iter = new Iterator (method, parent, iterator_type, is_enumerable); - iter.Storey.DefineType (); + // TODO: Ugly leftover + new Iterator (ctx, method, parent, iterator_type, is_enumerable); } - static bool CheckType (Type ret, out Type original_iterator_type, out bool is_enumerable) + static bool CheckType (TypeSpec ret, out TypeSpec original_iterator_type, out bool is_enumerable) { original_iterator_type = null; is_enumerable = false; @@ -912,22 +922,19 @@ namespace Mono.CSharp { return true; } - if (!TypeManager.IsGenericType (ret)) - return false; - - Type[] args = TypeManager.GetTypeArguments (ret); - if (args.Length != 1) + InflatedTypeSpec inflated = ret as InflatedTypeSpec; + if (inflated == null) return false; - Type gt = TypeManager.DropGenericTypeArguments (ret); - if (gt == TypeManager.generic_ienumerable_type) { - original_iterator_type = args [0]; + ret = inflated.GetDefinition (); + if (ret == TypeManager.generic_ienumerable_type) { + original_iterator_type = inflated.TypeArguments[0]; is_enumerable = true; return true; } - if (gt == TypeManager.generic_ienumerator_type) { - original_iterator_type = args [0]; + if (ret == TypeManager.generic_ienumerator_type) { + original_iterator_type = inflated.TypeArguments[0]; is_enumerable = false; return true; }