?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
**** Merged from MCS ****
[mono-project.git] / mcs / mcs / iterators.cs
blob06c92a90c71dfc6f2542ae1a94dad3c7d2dc20ed
1 //
2 // iterators.cs: Support for implementing iterators
3 //
4 // Author:
5 // Miguel de Icaza (miguel@ximian.com)
6 //
7 // (C) 2003 Ximian, Inc.
8 //
9 // TODO:
10 // Flow analysis for Yield.
11 // Emit calls to parent object constructor.
12 //
13 // Generics note:
14 // Current should be defined to return T, and IEnumerator.Current returns object
15 //
16
17 using System;
18 using System.Collections;
19 using System.Reflection;
20 using System.Reflection.Emit;
21
22 namespace Mono.CSharp {
23
24 public interface IIteratorContainer {
25
26 //
27 // Invoked if a yield statement is found in the body
28 //
29 void SetYields ();
30 }
31
32 public class Yield : Statement {
33 public Expression expr;
34 ArrayList finally_blocks;
35
36 public Yield (Expression expr, Location l)
37 {
38 this.expr = expr;
39 loc = l;
40 }
41
42 public static bool CheckContext (EmitContext ec, Location loc)
43 {
44 if (ec.CurrentBranching.InFinally (true)){
45 Report.Error (1625, loc, "Cannot yield in the body of a " +
46 "finally clause");
47 return false;
48 }
49 if (ec.CurrentBranching.InCatch ()){
50 Report.Error (1631, loc, "Cannot yield in the body of a " +
51 "catch clause");
52 return false;
53 }
54 if (ec.CurrentAnonymousMethod != null){
55 Report.Error (1621, loc, "yield statement can not appear inside an anonymoud method");
56 return false;
57 }
58
59 //
60 // FIXME: Missing check for Yield inside try block that contains catch clauses
61 //
62 return true;
63 }
64
65 public override bool Resolve (EmitContext ec)
66 {
67 expr = expr.Resolve (ec);
68 if (expr == null)
69 return false;
70 if (!CheckContext (ec, loc))
71 return false;
72
73 Iterator iterator = ec.CurrentIterator;
74 if (expr.Type != iterator.IteratorType){
75 expr = Convert.ImplicitConversionRequired (
76 ec, expr, iterator.IteratorType, loc);
77 if (expr == null)
78 return false;
79 }
80
81 ec.CurrentBranching.StealFinallyClauses (ref finally_blocks);
82 return true;
83 }
84
85 protected override void DoEmit (EmitContext ec)
86 {
87 ec.CurrentIterator.MarkYield (ec, expr, finally_blocks);
88 }
89 }
90
91 public class YieldBreak : Statement {
92
93 public YieldBreak (Location l)
94 {
95 loc = l;
96 }
97
98 public override bool Resolve (EmitContext ec)
99 {
100 if (!Yield.CheckContext (ec, loc))
101 return false;
102
103 ec.CurrentBranching.CurrentUsageVector.Goto ();
104 return true;
105 }
106
107 protected override void DoEmit (EmitContext ec)
108 {
109 ec.CurrentIterator.EmitYieldBreak (ec.ig);
110 }
111 }
112
113 public class Iterator : Class {
114 ToplevelBlock original_block;
115 ToplevelBlock block;
116 string original_name;
117
118 Type iterator_type;
119 TypeExpr iterator_type_expr;
120 bool is_enumerable;
121 bool is_static;
122
123 Hashtable fields;
124
125 //
126 // The state as we generate the iterator
127 //
128 Label move_next_ok, move_next_error;
129 ArrayList resume_points = new ArrayList ();
130 int pc;
131
132 //
133 // Context from the original method
134 //
135 TypeContainer container;
136 Type return_type;
137 Type [] param_types;
138 InternalParameters parameters;
139
140 protected enum State {
141 Uninitialized = -2,
142 After,
143 Running
144 }
145
146 static int proxy_count;
147
148 public void EmitYieldBreak (ILGenerator ig)
149 {
150 ig.Emit (OpCodes.Ldarg_0);
151 IntConstant.EmitInt (ig, (int) State.After);
152 ig.Emit (OpCodes.Stfld, pc_field.FieldBuilder);
153 ig.Emit (OpCodes.Br, move_next_error);
154 }
155
156 public void EmitMoveNext (EmitContext ec)
157 {
158 ILGenerator ig = ec.ig;
159
160 move_next_ok = ig.DefineLabel ();
161 move_next_error = ig.DefineLabel ();
162
163 LocalBuilder retval = ec.GetTemporaryLocal (TypeManager.int32_type);
164
165 ig.BeginExceptionBlock ();
166
167 Label dispatcher = ig.DefineLabel ();
168 ig.Emit (OpCodes.Br, dispatcher);
169
170 ResumePoint entry_point = new ResumePoint (null);
171 resume_points.Add (entry_point);
172 entry_point.Define (ig);
173
174 ec.EmitTopBlock (original_block, parameters, Location);
175 EmitYieldBreak (ig);
176
177 ig.MarkLabel (dispatcher);
178
179 Label [] labels = new Label [resume_points.Count];
180 for (int i = 0; i < labels.Length; i++)
181 labels [i] = ((ResumePoint) resume_points [i]).Label;
182
183 ig.Emit (OpCodes.Ldarg_0);
184 ig.Emit (OpCodes.Ldfld, pc_field.FieldBuilder);
185 ig.Emit (OpCodes.Switch, labels);
186
187 Label end = ig.DefineLabel ();
188
189 ig.MarkLabel (move_next_error);
190 ig.Emit (OpCodes.Ldc_I4_0);
191 ig.Emit (OpCodes.Stloc, retval);
192 ig.Emit (OpCodes.Leave, end);
193
194 ig.MarkLabel (move_next_ok);
195 ig.Emit (OpCodes.Ldc_I4_1);
196 ig.Emit (OpCodes.Stloc, retval);
197 ig.Emit (OpCodes.Leave, end);
198
199 ig.BeginFaultBlock ();
200
201 ig.Emit (OpCodes.Ldarg_0);
202 ig.Emit (OpCodes.Callvirt, dispose.MethodBuilder);
203
204 ig.EndExceptionBlock ();
205
206 ig.MarkLabel (end);
207 ig.Emit (OpCodes.Ldloc, retval);
208 ig.Emit (OpCodes.Ret);
209 }
210
211 public void EmitDispose (EmitContext ec)
212 {
213 ILGenerator ig = ec.ig;
214
215 Label end = ig.DefineLabel ();
216 Label dispatcher = ig.DefineLabel ();
217 ig.Emit (OpCodes.Br, dispatcher);
218
219 ec.RemapToProxy = true;
220 Label [] labels = new Label [resume_points.Count];
221 for (int i = 0; i < labels.Length; i++) {
222 ResumePoint point = (ResumePoint) resume_points [i];
223
224 if (point.FinallyBlocks == null) {
225 labels [i] = end;
226 continue;
227 }
228
229 labels [i] = ig.DefineLabel ();
230 ig.MarkLabel (labels [i]);
231
232 ig.BeginExceptionBlock ();
233 ig.BeginFinallyBlock ();
234
235 foreach (ExceptionStatement stmt in point.FinallyBlocks) {
236 if (stmt != null)
237 stmt.EmitFinally (ec);
238 }
239
240 ig.EndExceptionBlock ();
241 ig.Emit (OpCodes.Br, end);
242 }
243 ec.RemapToProxy = false;
244
245 ig.MarkLabel (dispatcher);
246 ig.Emit (OpCodes.Ldarg_0);
247 ig.Emit (OpCodes.Ldfld, pc_field.FieldBuilder);
248 ig.Emit (OpCodes.Switch, labels);
249
250 ig.Emit (OpCodes.Ldarg_0);
251 IntConstant.EmitInt (ig, (int) State.After);
252 ig.Emit (OpCodes.Stfld, pc_field.FieldBuilder);
253
254 ig.MarkLabel (end);
255 }
256
257 protected class ResumePoint
258 {
259 public Label Label;
260 public readonly ExceptionStatement[] FinallyBlocks;
261
262 public ResumePoint (ArrayList list)
263 {
264 if (list != null) {
265 FinallyBlocks = new ExceptionStatement [list.Count];
266 list.CopyTo (FinallyBlocks, 0);
267 }
268 }
269
270 public void Define (ILGenerator ig)
271 {
272 Label = ig.DefineLabel ();
273 ig.MarkLabel (Label);
274 }
275 }
276
277 //
278 // Invoked when a local variable declaration needs to be mapped to
279 // a field in our proxy class
280 //
281 // Prefixes registered:
282 // v_ for EmitContext.MapVariable
283 // s_ for Storage
284 //
285 public FieldBuilder MapVariable (string pfx, string name, Type t)
286 {
287 string full_name = pfx + name;
288 FieldBuilder fb = (FieldBuilder) fields [full_name];
289 if (fb != null)
290 return fb;
291
292 fb = TypeBuilder.DefineField (full_name, t, FieldAttributes.Private);
293 fields.Add (full_name, fb);
294 return fb;
295 }
296
297 //
298 // Called back from Yield
299 //
300 public void MarkYield (EmitContext ec, Expression expr,
301 ArrayList finally_blocks)
302 {
303 ILGenerator ig = ec.ig;
304
305 // Store the new current
306 ig.Emit (OpCodes.Ldarg_0);
307 expr.Emit (ec);
308 ig.Emit (OpCodes.Stfld, current_field.FieldBuilder);
309
310 // increment pc
311 pc++;
312 ig.Emit (OpCodes.Ldarg_0);
313 IntConstant.EmitInt (ig, pc);
314 ig.Emit (OpCodes.Stfld, pc_field.FieldBuilder);
315
316 // Return ok
317 ig.Emit (OpCodes.Br, move_next_ok);
318
319 ResumePoint point = new ResumePoint (finally_blocks);
320 resume_points.Add (point);
321 point.Define (ig);
322 }
323
324 public void MarkFinally (EmitContext ec, ArrayList finally_blocks)
325 {
326 ILGenerator ig = ec.ig;
327
328 // increment pc
329 pc++;
330 ig.Emit (OpCodes.Ldarg_0);
331 IntConstant.EmitInt (ig, pc);
332 ig.Emit (OpCodes.Stfld, pc_field.FieldBuilder);
333
334 ResumePoint point = new ResumePoint (finally_blocks);
335 resume_points.Add (point);
336 point.Define (ig);
337 }
338
339 private static MemberName MakeProxyName (string name)
340 {
341 int pos = name.LastIndexOf ('.');
342 if (pos > 0)
343 name = name.Substring (pos + 1);
344
345 return new MemberName ("<" + name + ">__" + (proxy_count++));
346 }
347
348 //
349 // Our constructor
350 //
351 public Iterator (TypeContainer container, string name, Type return_type,
352 Type [] param_types, InternalParameters parameters,
353 int modifiers, ToplevelBlock block, Location loc)
354 : base (container.NamespaceEntry, container, MakeProxyName (name),
355 Modifiers.PRIVATE, null, loc)
356 {
357 this.container = container;
358 this.return_type = return_type;
359 this.param_types = param_types;
360 this.parameters = parameters;
361 this.original_name = name;
362 this.original_block = block;
363 this.block = new ToplevelBlock (loc);
364
365 fields = new Hashtable ();
366
367 is_static = (modifiers & Modifiers.STATIC) != 0;
368 }
369
370 public bool DefineIterator ()
371 {
372 if (!CheckType (return_type)) {
373 Report.Error (
374 1624, Location,
375 "The body of `{0}' cannot be an iterator block " +
376 "because '{1}' is not an iterator interface type",
377 original_name, TypeManager.CSharpName (return_type));
378 return false;
379 }
380
381 for (int i = 0; i < parameters.Count; i++){
382 Parameter.Modifier mod = parameters.ParameterModifier (i);
383 if ((mod & (Parameter.Modifier.REF | Parameter.Modifier.OUT)) != 0){
384 Report.Error (
385 1623, Location,
386 "Iterators cannot have ref or out parameters");
387 return false;
388 }
389 }
390
391 ArrayList list = new ArrayList ();
392 if (is_enumerable)
393 list.Add (new TypeExpression (
394 TypeManager.ienumerable_type, Location));
395 list.Add (new TypeExpression (TypeManager.ienumerator_type, Location));
396 list.Add (new TypeExpression (TypeManager.idisposable_type, Location));
397
398 iterator_type_expr = new TypeExpression (iterator_type, Location);
399
400 container.AddIterator (this);
401
402 Bases = list;
403 return true;
404 }
405
406 //
407 // Returns the new block for the method, or null on failure
408 //
409 protected override bool DefineNestedTypes ()
410 {
411 Define_Fields ();
412 Define_Constructor ();
413 Define_Current ();
414 Define_MoveNext ();
415 Define_Reset ();
416 Define_Dispose ();
417
418 if (is_enumerable)
419 Define_GetEnumerator ();
420
421 Create_Block ();
422
423 return base.DefineNestedTypes ();
424 }
425
426
427 Field pc_field;
428 Field current_field;
429 Method dispose;
430
431 public Field this_field;
432 public Field[] parameter_fields;
433
434 void Create_Block ()
435 {
436 int first = is_static ? 0 : 1;
437
438 ArrayList args = new ArrayList ();
439 if (!is_static) {
440 Type t = container.TypeBuilder;
441 args.Add (new Argument (
442 new ThisParameterReference (t, 0, Location)));
443 }
444
445 args.Add (new Argument (new BoolLiteral (false)));
446
447 for (int i = 0; i < parameters.Count; i++) {
448 Type t = parameters.ParameterType (i);
449 args.Add (new Argument (
450 new SimpleParameterReference (t, first + i, Location)));
451 }
452
453 Expression new_expr = new New (
454 new TypeExpression (TypeBuilder, Location), args, Location);
455
456 block.AddStatement (new NoCheckReturn (new_expr, Location));
457 }
458
459 void Define_Fields ()
460 {
461 Location loc = Location.Null;
462
463 pc_field = new Field (
464 this, TypeManager.system_int32_expr, Modifiers.PRIVATE, "PC",
465 null, null, loc);
466 AddField (pc_field);
467
468 current_field = new Field (
469 this, iterator_type_expr, Modifiers.PRIVATE, "current",
470 null, null, loc);
471 AddField (current_field);
472
473 if (!is_static) {
474 this_field = new Field (
475 this,
476 new TypeExpression (container.TypeBuilder, Location),
477 Modifiers.PRIVATE, "this", null, null, loc);
478 AddField (this_field);
479 }
480
481 parameter_fields = new Field [parameters.Count];
482 for (int i = 0; i < parameters.Count; i++) {
483 string fname = String.Format (
484 "field{0}_{1}", i, parameters.ParameterName (i));
485
486 parameter_fields [i] = new Field (
487 this,
488 new TypeExpression (parameters.ParameterType (i), loc),
489 Modifiers.PRIVATE, fname, null, null, loc);
490 AddField (parameter_fields [i]);
491 }
492 }
493
494 void Define_Constructor ()
495 {
496 Parameters ctor_params;
497
498 ArrayList list = new ArrayList ();
499
500 if (!is_static)
501 list.Add (new Parameter (
502 new TypeExpression (container.TypeBuilder, Location),
503 "this", Parameter.Modifier.NONE, null));
504 list.Add (new Parameter (
505 TypeManager.system_boolean_expr, "initialized",
506 Parameter.Modifier.NONE, null));
507
508 Parameter[] old_fixed = parameters.Parameters.FixedParameters;
509 if (old_fixed != null)
510 list.AddRange (old_fixed);
511
512 Parameter[] fixed_params = new Parameter [list.Count];
513 list.CopyTo (fixed_params);
514
515 ctor_params = new Parameters (
516 fixed_params, parameters.Parameters.ArrayParameter,
517 Location);
518
519 Constructor ctor = new Constructor (
520 this, Name, Modifiers.PUBLIC, ctor_params,
521 new ConstructorBaseInitializer (
522 null, Parameters.EmptyReadOnlyParameters, Location),
523 Location);
524 AddConstructor (ctor);
525
526 ToplevelBlock block = ctor.Block = new ToplevelBlock (Location);
527
528 if (!is_static) {
529 Type t = container.TypeBuilder;
530
531 Assign assign = new Assign (
532 new FieldExpression (this_field),
533 new SimpleParameterReference (t, 1, Location),
534 Location);
535
536 block.AddStatement (new StatementExpression (assign, Location));
537 }
538
539 int first = is_static ? 2 : 3;
540
541 for (int i = 0; i < parameters.Count; i++) {
542 Type t = parameters.ParameterType (i);
543
544 Assign assign = new Assign (
545 new FieldExpression (parameter_fields [i]),
546 new SimpleParameterReference (t, first + i, Location),
547 Location);
548
549 block.AddStatement (new StatementExpression (assign, Location));
550 }
551
552 State initial = is_enumerable ? State.Uninitialized : State.Running;
553 block.AddStatement (new SetState (this, initial, Location));
554
555 block.AddStatement (new If (
556 new SimpleParameterReference (
557 TypeManager.bool_type, first - 1, Location),
558 new SetState (this, State.Running, Location),
559 Location));
560 }
561
562 Statement Create_ThrowInvalidOperation ()
563 {
564 TypeExpr ex_type = new TypeExpression (
565 TypeManager.invalid_operation_exception_type, Location);
566
567 return new Throw (new New (ex_type, null, Location), Location);
568 }
569
570 Statement Create_ThrowNotSupported ()
571 {
572 TypeExpr ex_type = new TypeExpression (
573 TypeManager.not_supported_exception_type, Location);
574
575 return new Throw (new New (ex_type, null, Location), Location);
576 }
577
578 void Define_Current ()
579 {
580 ToplevelBlock get_block = new ToplevelBlock (Location);
581 MemberName left = new MemberName ("System.Collections.IEnumerator");
582 MemberName name = new MemberName (left, "Current");
583
584 get_block.AddStatement (new If (
585 new Binary (
586 Binary.Operator.LessThanOrEqual,
587 new FieldExpression (pc_field),
588 new IntLiteral ((int) State.Running), Location),
589 Create_ThrowInvalidOperation (),
590 new Return (
591 new FieldExpression (current_field), Location),
592 Location));
593
594 Accessor getter = new Accessor (get_block, 0, null, Location);
595
596 Property current = new Property (
597 this, iterator_type_expr, 0,
598 false, name, null, getter, null, Location);
599 AddProperty (current);
600 }
601
602 void Define_MoveNext ()
603 {
604 Method move_next = new Method (
605 this, TypeManager.system_boolean_expr,
606 Modifiers.PUBLIC, false, new MemberName ("MoveNext"),
607 Parameters.EmptyReadOnlyParameters, null,
608 Location.Null);
609 AddMethod (move_next);
610
611 ToplevelBlock block = move_next.Block = new ToplevelBlock (Location);
612
613 MoveNextMethod inline = new MoveNextMethod (this, Location);
614 block.AddStatement (inline);
615 }
616
617 void Define_GetEnumerator ()
618 {
619 MemberName left = new MemberName ("System.Collections.IEnumerable");
620 MemberName name = new MemberName (left, "GetEnumerator");
621
622 Method get_enumerator = new Method (
623 this,
624 new TypeExpression (TypeManager.ienumerator_type, Location),
625 0, false, name,
626 Parameters.EmptyReadOnlyParameters, null,
627 Location.Null);
628 AddMethod (get_enumerator);
629
630 get_enumerator.Block = new ToplevelBlock (Location);
631
632 Expression ce = new MemberAccess (
633 new SimpleName ("System.Threading.Interlocked", Location),
634 "CompareExchange", Location);
635
636 Expression pc = new FieldExpression (pc_field);
637 Expression before = new IntLiteral ((int) State.Running);
638 Expression uninitialized = new IntLiteral ((int) State.Uninitialized);
639
640 ArrayList args = new ArrayList ();
641 args.Add (new Argument (pc, Argument.AType.Ref));
642 args.Add (new Argument (before, Argument.AType.Expression));
643 args.Add (new Argument (uninitialized, Argument.AType.Expression));
644
645 get_enumerator.Block.AddStatement (new If (
646 new Binary (
647 Binary.Operator.Equality,
648 new Invocation (ce, args, Location),
649 uninitialized, Location),
650 new Return (new This (block, Location), Location),
651 Location));
652
653 args = new ArrayList ();
654 if (!is_static)
655 args.Add (new Argument (new FieldExpression (this_field)));
656
657 args.Add (new Argument (new BoolLiteral (true)));
658
659 for (int i = 0; i < parameters.Count; i++)
660 args.Add (new Argument (
661 new FieldExpression (parameter_fields [i])));
662
663 Expression new_expr = new New (
664 new TypeExpression (TypeBuilder, Location), args, Location);
665 get_enumerator.Block.AddStatement (new Return (new_expr, Location));
666 }
667
668 protected class SimpleParameterReference : Expression
669 {
670 int idx;
671
672 public SimpleParameterReference (Type type, int idx, Location loc)
673 {
674 this.idx = idx;
675 this.loc = loc;
676 this.type = type;
677 eclass = ExprClass.Variable;
678 }
679
680 public override Expression DoResolve (EmitContext ec)
681 {
682 return this;
683 }
684
685 public override void Emit (EmitContext ec)
686 {
687 DoEmit (ec);
688 }
689
690 protected virtual void DoEmit (EmitContext ec)
691 {
692 ParameterReference.EmitLdArg (ec.ig, idx);
693 }
694 }
695
696 protected class ThisParameterReference : SimpleParameterReference
697 {
698 public ThisParameterReference (Type type, int idx, Location loc)
699 : base (type, idx, loc)
700 { }
701
702 protected override void DoEmit (EmitContext ec)
703 {
704 base.DoEmit (ec);
705 if (ec.TypeContainer is Struct)
706 ec.ig.Emit (OpCodes.Ldobj, type);
707 }
708 }
709
710 protected class FieldExpression : Expression
711 {
712 Field field;
713
714 public FieldExpression (Field field)
715 {
716 this.field = field;
717 }
718
719 public override Expression DoResolve (EmitContext ec)
720 {
721 FieldExpr fexpr = new FieldExpr (field.FieldBuilder, loc);
722 fexpr.InstanceExpression = ec.GetThis (loc);
723 return fexpr.Resolve (ec);
724 }
725
726 public override void Emit (EmitContext ec)
727 {
728 throw new InvalidOperationException ();
729 }
730 }
731
732 protected class MoveNextMethod : Statement {
733 Iterator iterator;
734
735 public MoveNextMethod (Iterator iterator, Location loc)
736 {
737 this.loc = loc;
738 this.iterator = iterator;
739 }
740
741 public override bool Resolve (EmitContext ec)
742 {
743 ec.CurrentBranching.CurrentUsageVector.Return ();
744 return true;
745 }
746
747 protected override void DoEmit (EmitContext ec)
748 {
749 int code_flags = Modifiers.METHOD_YIELDS;
750 if (iterator.is_static)
751 code_flags |= Modifiers.STATIC;
752
753 EmitContext new_ec = new EmitContext (
754 iterator.container, loc, ec.ig,
755 TypeManager.int32_type, code_flags);
756
757 new_ec.CurrentIterator = iterator;
758
759 iterator.EmitMoveNext (new_ec);
760 }
761 }
762
763 protected class DisposeMethod : Statement {
764 Iterator iterator;
765
766 public DisposeMethod (Iterator iterator, Location loc)
767 {
768 this.loc = loc;
769 this.iterator = iterator;
770 }
771
772 public override bool Resolve (EmitContext ec)
773 {
774 return true;
775 }
776
777 protected override void DoEmit (EmitContext ec)
778 {
779 iterator.EmitDispose (ec);
780 }
781 }
782
783 protected class StatementList : Statement {
784 ArrayList statements;
785
786 public StatementList (Location loc)
787 {
788 this.loc = loc;
789 statements = new ArrayList ();
790 }
791
792 public void Add (Statement statement)
793 {
794 statements.Add (statement);
795 }
796
797 public override bool Resolve (EmitContext ec)
798 {
799 foreach (Statement stmt in statements) {
800 if (!stmt.Resolve (ec))
801 return false;
802 }
803
804 return true;
805 }
806
807 protected override void DoEmit (EmitContext ec)
808 {
809 foreach (Statement stmt in statements)
810 stmt.Emit (ec);
811 }
812 }
813
814 protected class SetState : Statement
815 {
816 Iterator iterator;
817 State state;
818
819 public SetState (Iterator iterator, State state, Location loc)
820 {
821 this.iterator = iterator;
822 this.state = state;
823 this.loc = loc;
824 }
825
826 public override bool Resolve (EmitContext ec)
827 {
828 return true;
829 }
830
831 protected override void DoEmit (EmitContext ec)
832 {
833 ec.ig.Emit (OpCodes.Ldarg_0);
834 IntConstant.EmitInt (ec.ig, (int) state);
835 ec.ig.Emit (OpCodes.Stfld, iterator.pc_field.FieldBuilder);
836 }
837 }
838
839 void Define_Reset ()
840 {
841 Method reset = new Method (
842 this, TypeManager.system_void_expr, Modifiers.PUBLIC,
843 false, new MemberName ("Reset"),
844 Parameters.EmptyReadOnlyParameters, null, Location);
845 AddMethod (reset);
846
847 reset.Block = new ToplevelBlock (Location);
848 reset.Block.AddStatement (Create_ThrowNotSupported ());
849 }
850
851 void Define_Dispose ()
852 {
853 dispose = new Method (
854 this, TypeManager.system_void_expr, Modifiers.PUBLIC,
855 false, new MemberName ("Dispose"),
856 Parameters.EmptyReadOnlyParameters, null, Location);
857 AddMethod (dispose);
858
859 dispose.Block = new ToplevelBlock (Location);
860 dispose.Block.AddStatement (new DisposeMethod (this, Location));
861 }
862
863 public ToplevelBlock Block {
864 get { return block; }
865 }
866
867 public Type IteratorType {
868 get { return iterator_type; }
869 }
870
871 //
872 // This return statement tricks return into not flagging an error for being
873 // used in a Yields method
874 //
875 class NoCheckReturn : Return {
876 public NoCheckReturn (Expression expr, Location loc) : base (expr, loc)
877 {
878 }
879
880 public override bool Resolve (EmitContext ec)
881 {
882 ec.InIterator = false;
883 bool ret_val = base.Resolve (ec);
884 ec.InIterator = true;
885
886 return ret_val;
887 }
888 }
889
890 bool CheckType (Type t)
891 {
892 if (t == TypeManager.ienumerable_type) {
893 iterator_type = TypeManager.object_type;
894 is_enumerable = true;
895 return true;
896 } else if (t == TypeManager.ienumerator_type) {
897 iterator_type = TypeManager.object_type;
898 is_enumerable = false;
899 return true;
900 }
901
902 return false;
903 }
904 }
905 }
906
Mirror of the official Mono project git repository