X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fiterators.cs;h=cbf983c856f35415037a809edd3143a6dcc8a7ee;hb=732841a4f171062563a831fb8cd3165be1ddfd6e;hp=ac119857e66d85d028fd23013df9234cef3cc573;hpb=27b26a2ef0151e0e9a0783a3fe827d4014d1b153;p=mono.git diff --git a/mcs/mcs/iterators.cs b/mcs/mcs/iterators.cs index ac119857e66..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) + 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) @@ -74,7 +61,7 @@ namespace Mono.CSharp { 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,13 +88,16 @@ 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"); } @@ -116,19 +107,15 @@ namespace Mono.CSharp { throw new NotSupportedException (); } - protected override bool DoResolve (EmitContext ec) + protected override bool DoResolve (BlockContext ec) { + iterator = ec.CurrentIterator; return Yield.CheckContext (ec, loc); } protected override void DoEmit (EmitContext ec) { - ec.CurrentIterator.EmitYieldBreak (ec.ig, unwind_protect); - } - - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) - { - // nothing to do + iterator.EmitYieldBreak (ec, unwind_protect); } } @@ -138,9 +125,9 @@ 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; @@ -154,7 +141,7 @@ namespace Mono.CSharp { t.iterator = (Iterator) iterator.Clone (clonectx); } - public override bool Resolve (EmitContext ec) + public override bool Resolve (BlockContext ec) { ec.StartFlowBranching (iterator); bool ok = original_block.Resolve (ec); @@ -166,221 +153,46 @@ 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 { - public readonly Iterator Iterator; - - TypeExpr iterator_type_expr; - Field pc_field; - Field current_field; - - TypeExpr enumerator_type; - TypeExpr enumerable_type; - TypeArguments generic_args; - TypeExpr generic_enumerator_type; -#if GMCS_SOURCE - TypeExpr generic_enumerable_type; -#endif - - int local_name_idx; - - public IteratorStorey (Iterator iterator) - : base (iterator.Container.Toplevel, iterator.Host, - iterator.OriginalMethod as MemberBase, iterator.GenericMethod, "Iterator") - { - this.Iterator = iterator; - HasHoistedVariables = true; - } - - public Field PC { - get { return pc_field; } - } - - public Field CurrentField { - get { return current_field; } - } - - public ArrayList HoistedParameters { - get { return hoisted_params; } - } - - protected override TypeExpr [] ResolveBaseTypes (out TypeExpr base_class) - { - iterator_type_expr = new TypeExpression (MutateType (Iterator.OriginalIteratorType), Location); - -#if GMCS_SOURCE - generic_args = new TypeArguments (Location); - generic_args.Add (iterator_type_expr); -#endif - - ArrayList list = new ArrayList (); - 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 - } - - enumerator_type = new TypeExpression ( - TypeManager.ienumerator_type, Location); - list.Add (enumerator_type); - - 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 - - type_bases = list; - - return base.ResolveBaseTypes (out base_class); - } - - protected override string GetVariableMangledName (LocalInfo local_info) - { - return "<" + local_info.Name + ">__" + local_name_idx++.ToString (); - } - - public void DefineIteratorMembers () - { - pc_field = AddCompilerGeneratedField ("$PC", TypeManager.system_int32_expr); - current_field = AddCompilerGeneratedField ("$current", iterator_type_expr); - -#if GMCS_SOURCE - Define_Current (true); -#endif - Define_Current (false); - new DisposeMethod (this); - Define_Reset (); - - if (Iterator.IsEnumerable) { - new GetEnumeratorMethod (this, false); -#if GMCS_SOURCE - new GetEnumeratorMethod (this, true); -#endif - } - - DoResolveMembers (); - } - - void Define_Current (bool is_generic) - { - MemberName left; - TypeExpr type; - - if (is_generic) { - left = new MemberName ( - "System.Collections.Generic.IEnumerator", - generic_args, Location); - type = iterator_type_expr; - } else { - left = new MemberName ("System.Collections.IEnumerator", Location); - 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)); - - Accessor getter = new Accessor (get_block, 0, null, null, Location); - - Property current = new Property ( - this, type, Modifiers.DEBUGGER_HIDDEN, name, null, getter, null, false); - AddProperty (current); - } - - void Define_Reset () - { - Method reset = new Method ( - this, null, TypeManager.system_void_expr, - Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN, - new MemberName ("Reset", Location), - Parameters.EmptyReadOnlyParameters, null); - AddMethod (reset); - - reset.Block = new ToplevelBlock (Location); - reset.Block.AddStatement (Create_ThrowNotSupported ()); - } - - Statement Create_ThrowNotSupported () + class IteratorMethod : Method { - 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); - } + readonly IteratorStorey host; - public GetEnumeratorMethod (IteratorStorey host, bool is_generic) - : base (host, null, is_generic ? - host.generic_enumerator_type : host.enumerator_type, - Modifiers.DEBUGGER_HIDDEN, GetMemberName (host, is_generic), - Parameters.EmptyReadOnlyParameters, null) + 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; - - host.AddMethod (this); + this.host = host; - Block = new ToplevelBlock (host.Iterator.Container.Toplevel, null, Location); - Block.AddStatement (new GetEnumeratorStatement (host, type_name)); + Block = new ToplevelBlock (Compiler, host.Iterator.Container.Toplevel, ParametersCompiled.EmptyReadOnlyParameters, Location); } - public override EmitContext CreateEmitContext (DeclSpace tc, ILGenerator ig) + public override EmitContext CreateEmitContext (ILGenerator ig) { - EmitContext ec = new EmitContext ( - this, tc, this.ds, Location, ig, MemberType, ModFlags, false); + EmitContext ec = new EmitContext (this, ig, MemberType); - ec.CurrentAnonymousMethod = Host.Iterator; + ec.CurrentAnonymousMethod = host.Iterator; return ec; } + } - protected class GetEnumeratorStatement : Statement + class GetEnumeratorMethod : IteratorMethod + { + sealed class GetEnumeratorStatement : Statement { IteratorStorey host; - Expression type; + IteratorMethod host_method; - Expression cast; + Expression new_storey; - public GetEnumeratorStatement (IteratorStorey host, Expression type) + public GetEnumeratorStatement (IteratorStorey host, IteratorMethod host_method) { this.host = host; - this.type = type; - loc = host.Location; + this.host_method = host_method; + loc = host_method.Location; } protected override void CloneTo (CloneContext clonectx, Statement target) @@ -388,38 +200,59 @@ namespace Mono.CSharp { throw new NotSupportedException (); } - public override bool Resolve (EmitContext ec) + public override bool Resolve (BlockContext ec) { - type = type.ResolveAsTypeTerminal (ec, false); - if ((type == null) || (type.Type == null)) - return false; + 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)); + } - 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); + 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)); } + } - new_storey = new NewInitialize (storey_type_expr, new ArrayList (0), + if (init != null) { + new_storey = new NewInitialize (storey_type_expr, null, new CollectionOrObjectInitializers (init, loc), loc); } else { - new_storey = new New (storey_type_expr, new ArrayList (0), loc); + new_storey = new New (storey_type_expr, null, loc); } new_storey = new_storey.Resolve (ec); if (new_storey != null) - cast = Convert.ImplicitConversionRequired (ec, new_storey, type.Type, loc); + new_storey = Convert.ImplicitConversionRequired (ec, new_storey, host_method.MemberType, loc); if (TypeManager.int_interlocked_compare_exchange == null) { - Type t = TypeManager.CoreLookupType ("System.Threading", "Interlocked", Kind.Class, true); + TypeSpec t = TypeManager.CoreLookupType (ec.Compiler, "System.Threading", "Interlocked", MemberKind.Class, true); if (t != null) { - TypeManager.int_interlocked_compare_exchange = TypeManager.GetPredefinedMethod ( - t, "CompareExchange", loc, TypeManager.int32_type, - TypeManager.int32_type, TypeManager.int32_type); + 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); } } @@ -429,72 +262,37 @@ namespace Mono.CSharp { protected override void DoEmit (EmitContext ec) { - ILGenerator ig = ec.ig; - Label label_init = ig.DefineLabel (); + Label label_init = ec.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); + 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); - ig.Emit (OpCodes.Ldc_I4, (int) Iterator.State.Uninitialized); - ig.Emit (OpCodes.Bne_Un, label_init); + ec.EmitInt ((int) Iterator.State.Uninitialized); + ec.Emit (OpCodes.Bne_Un_S, label_init); - ig.Emit (OpCodes.Ldarg_0); - ig.Emit (OpCodes.Ret); + ec.Emit (OpCodes.Ldarg_0); + ec.Emit (OpCodes.Ret); - ig.MarkLabel (label_init); + ec.MarkLabel (label_init); - cast.Emit (ec); - ig.Emit (OpCodes.Ret); - } - - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) - { - throw new NotSupportedException (); + new_storey.Emit (ec); + ec.Emit (OpCodes.Ret); } } - } - 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, - new MemberName ("Dispose", host.Location), - Parameters.EmptyReadOnlyParameters, null) + public GetEnumeratorMethod (IteratorStorey host, FullNamedExpression returnType, MemberName name) + : base (host, returnType, 0, name) { - 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); + Block.AddStatement (new GetEnumeratorStatement (host, this)); } + } - 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 + class DisposeMethod : IteratorMethod + { + sealed class DisposeMethodStatement : Statement { Iterator iterator; @@ -509,7 +307,7 @@ namespace Mono.CSharp { throw new NotSupportedException (); } - public override bool Resolve (EmitContext ec) + public override bool Resolve (BlockContext ec) { return true; } @@ -518,52 +316,250 @@ namespace Mono.CSharp { { iterator.EmitDispose (ec); } + } - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) - { - throw new NotSupportedException (); - } + 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)); } } - protected class CurrentBlock : Statement { - IteratorStorey host; - bool is_generic; + // + // Uses Method as method info + // + class DynamicMethodGroupExpr : MethodGroupExpr + { + readonly Method method; - public CurrentBlock (IteratorStorey host, bool is_generic) + public DynamicMethodGroupExpr (Method method, Location loc) + : base (null, loc) { - this.host = host; - this.is_generic = is_generic; - loc = host.Location; + this.method = method; + eclass = ExprClass.Unresolved; } - protected override void CloneTo (CloneContext clonectx, Statement target) + protected override Expression DoResolve (ResolveContext ec) { - throw new NotSupportedException (); + Methods = new List (1) { method.Spec }; + type = method.Parent.Definition; + InstanceExpression = new CompilerGeneratedThis (type, Location); + return base.DoResolve (ec); } + } - public override bool Resolve (EmitContext ec) + class DynamicFieldExpr : FieldExpr + { + readonly Field field; + + public DynamicFieldExpr (Field field, Location loc) + : base (loc) { - // We emit a 'ret', so prevent the enclosing TopLevelBlock from emitting one too - ec.CurrentBranching.CurrentUsageVector.Goto (); - return true; + this.field = field; } - protected override void DoEmit (EmitContext ec) + protected override Expression DoResolve (ResolveContext ec) { - ILGenerator ig = ec.ig; + spec = field.Spec; + type = spec.MemberType; + InstanceExpression = new CompilerGeneratedThis (type, Location); + return base.DoResolve (ec); + } + } + + public readonly Iterator Iterator; + + TypeExpr iterator_type_expr; + Field pc_field; + Field current_field; + + TypeExpr enumerator_type; + TypeExpr enumerable_type; + TypeArguments generic_args; + TypeExpr generic_enumerator_type; + TypeExpr generic_enumerable_type; + + List hoisted_params_copy; + int local_name_idx; - 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); + public IteratorStorey (Iterator iterator) + : base (iterator.Container.Toplevel, iterator.Host, + iterator.OriginalMethod as MemberBase, iterator.GenericMethod, "Iterator") + { + this.Iterator = iterator; + } + + public Field PC { + get { return pc_field; } + } + + public Field CurrentField { + get { return current_field; } + } + + public IList HoistedParameters { + get { return hoisted_params; } + } + + protected override TypeExpr [] ResolveBaseTypes (out TypeExpr base_class) + { + var mtype = Iterator.OriginalIteratorType; + if (Mutator != null) + mtype = Mutator.Mutate (mtype); + + iterator_type_expr = new TypeExpression (mtype, Location); + generic_args = new TypeArguments (iterator_type_expr); + + var list = new List (); + if (Iterator.IsEnumerable) { + enumerable_type = new TypeExpression ( + TypeManager.ienumerable_type, Location); + list.Add (enumerable_type); + + if (TypeManager.generic_ienumerable_type != null) { + generic_enumerable_type = new GenericTypeExpr ( + TypeManager.generic_ienumerable_type, + generic_args, Location); + list.Add (generic_enumerable_type); + } } - public override void MutateHoistedGenericType (AnonymousMethodStorey storey) - { - throw new NotSupportedException (); + enumerator_type = new TypeExpression ( + TypeManager.ienumerator_type, Location); + list.Add (enumerator_type); + + list.Add (new TypeExpression (TypeManager.idisposable_type, Location)); + + 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.ResolveBaseTypes (out base_class); + } + + protected override string GetVariableMangledName (LocalInfo local_info) + { + return "<" + local_info.Name + ">__" + local_name_idx++.ToString (); + } + + 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 (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) { + 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)); + } + } + } + + protected override void EmitHoistedParameters (EmitContext ec, IList hoisted) + { + base.EmitHoistedParameters (ec, hoisted); + base.EmitHoistedParameters (ec, hoisted_params_copy); + } + + void Define_Current (bool is_generic) + { + TypeExpr type; + + MemberName name = new MemberName (QualifiedAliasMember.GlobalAlias, "System", null, Location); + name = new MemberName (name, "Collections", Location); + + if (is_generic) { + name = new MemberName (name, "Generic", Location); + name = new MemberName (name, "IEnumerator", generic_args, Location); + type = iterator_type_expr; + } else { + name = new MemberName (name, "IEnumerator"); + type = TypeManager.system_object_expr; + } + + name = new MemberName (name, "Current", 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, name, null, getter, null, false); + AddProperty (current); + } + + void Define_Reset () + { + Method reset = new Method ( + this, null, TypeManager.system_void_expr, + Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN, + new MemberName ("Reset", Location), + ParametersCompiled.EmptyReadOnlyParameters, null); + AddMethod (reset); + + reset.Block = new ToplevelBlock (Compiler, Location); + + TypeSpec ex_type = TypeManager.CoreLookupType (Compiler, "System", "NotSupportedException", MemberKind.Class, true); + if (ex_type == null) + return; + + reset.Block.AddStatement (new Throw (new New (new TypeExpression (ex_type, Location), null, Location), Location)); } } @@ -575,6 +571,7 @@ namespace Mono.CSharp { AnonymousMethodMethod method; public readonly TypeContainer Host; public readonly bool IsEnumerable; + List resume_points; // // The state as we generate the iterator @@ -598,7 +595,7 @@ namespace Mono.CSharp { get { return OriginalMethod.GenericMethod; } } - public readonly Type OriginalIteratorType; + public readonly TypeSpec OriginalIteratorType; readonly IteratorStorey IteratorHost; @@ -609,45 +606,36 @@ namespace Mono.CSharp { Start = 0 } - public override void AddStoreyReference (AnonymousMethodStorey storey) - { - // do nothing - } - - public void EmitYieldBreak (ILGenerator ig, bool unwind_protect) + public void EmitYieldBreak (EmitContext ec, 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); @@ -655,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; @@ -733,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) { if (resume_points == null) - resume_points = new ArrayList (); + resume_points = new List (); + resume_points.Add (stmt); return resume_points.Count; } @@ -770,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 { @@ -809,9 +792,9 @@ namespace Mono.CSharp { // // Our constructor // - private Iterator (IMethodData method, TypeContainer host, Type iterator_type, bool is_enumerable) + private Iterator (CompilerContext ctx, IMethodData method, TypeContainer host, TypeSpec iterator_type, bool is_enumerable) : base ( - new ToplevelBlock (method.Block, Parameters.EmptyReadOnlyParameters, method.Block.StartLocation), + new ToplevelBlock (ctx, method.Block, ParametersCompiled.EmptyReadOnlyParameters, method.Block.StartLocation), TypeManager.bool_type, method.Location) { @@ -819,6 +802,7 @@ namespace Mono.CSharp { this.OriginalIteratorType = iterator_type; this.IsEnumerable = is_enumerable; this.Host = host; + this.type = method.ReturnType; IteratorHost = Block.ChangeToIterator (this, method.Block); } @@ -828,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; } @@ -857,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.MemberName.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, TypeContainer 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 (), @@ -893,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 (parameters.Types [i].IsPointer) { - Report.Error (1637, p.Location, + ctx.Report.Error (1637, p.Location, "Iterators cannot have unsafe parameters or " + "yield types"); return; @@ -918,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; @@ -942,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; }