?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
revert 144379
[mcs.git] / mcs / statement.cs
blobbb4a8007f7a1b358bf618457d993b7dae3669d38
1 //
2 // statement.cs: Statement representation for the IL tree.
3 //
4 // Author:
5 // Miguel de Icaza (miguel@ximian.com)
6 // Martin Baulig (martin@ximian.com)
7 // Marek Safar (marek.safar@seznam.cz)
8 //
9 // Copyright 2001, 2002, 2003 Ximian, Inc.
10 // Copyright 2003, 2004 Novell, Inc.
11 //
12
13 using System;
14 using System.Text;
15 using System.Reflection;
16 using System.Reflection.Emit;
17 using System.Diagnostics;
18 using System.Collections;
19 using System.Collections.Specialized;
20
21 namespace Mono.CSharp {
22
23 public abstract class Statement {
24 public Location loc;
25
26 /// <summary>
27 /// Resolves the statement, true means that all sub-statements
28 /// did resolve ok.
29 // </summary>
30 public virtual bool Resolve (BlockContext ec)
31 {
32 return true;
33 }
34
35 /// <summary>
36 /// We already know that the statement is unreachable, but we still
37 /// need to resolve it to catch errors.
38 /// </summary>
39 public virtual bool ResolveUnreachable (BlockContext ec, bool warn)
40 {
41 //
42 // This conflicts with csc's way of doing this, but IMHO it's
43 // the right thing to do.
44 //
45 // If something is unreachable, we still check whether it's
46 // correct. This means that you cannot use unassigned variables
47 // in unreachable code, for instance.
48 //
49
50 if (warn)
51 ec.Report.Warning (162, 2, loc, "Unreachable code detected");
52
53 ec.StartFlowBranching (FlowBranching.BranchingType.Block, loc);
54 bool ok = Resolve (ec);
55 ec.KillFlowBranching ();
56
57 return ok;
58 }
59
60 /// <summary>
61 /// Return value indicates whether all code paths emitted return.
62 /// </summary>
63 protected abstract void DoEmit (EmitContext ec);
64
65 public virtual void Emit (EmitContext ec)
66 {
67 ec.Mark (loc);
68 DoEmit (ec);
69 }
70
71 //
72 // This routine must be overrided in derived classes and make copies
73 // of all the data that might be modified if resolved
74 //
75 protected abstract void CloneTo (CloneContext clonectx, Statement target);
76
77 public Statement Clone (CloneContext clonectx)
78 {
79 Statement s = (Statement) this.MemberwiseClone ();
80 CloneTo (clonectx, s);
81 return s;
82 }
83
84 public virtual Expression CreateExpressionTree (ResolveContext ec)
85 {
86 ec.Report.Error (834, loc, "A lambda expression with statement body cannot be converted to an expresion tree");
87 return null;
88 }
89
90 public Statement PerformClone ()
91 {
92 CloneContext clonectx = new CloneContext ();
93
94 return Clone (clonectx);
95 }
96
97 public abstract void MutateHoistedGenericType (AnonymousMethodStorey storey);
98 }
99
100 public sealed class EmptyStatement : Statement {
101
102 private EmptyStatement () {}
103
104 public static readonly EmptyStatement Value = new EmptyStatement ();
105
106 public override bool Resolve (BlockContext ec)
107 {
108 return true;
109 }
110
111 public override bool ResolveUnreachable (BlockContext ec, bool warn)
112 {
113 return true;
114 }
115
116 protected override void DoEmit (EmitContext ec)
117 {
118 }
119
120 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
121 {
122 }
123
124 protected override void CloneTo (CloneContext clonectx, Statement target)
125 {
126 // nothing needed.
127 }
128 }
129
130 public class If : Statement {
131 Expression expr;
132 public Statement TrueStatement;
133 public Statement FalseStatement;
134
135 bool is_true_ret;
136
137 public If (Expression bool_expr, Statement true_statement, Location l)
138 : this (bool_expr, true_statement, null, l)
139 {
140 }
141
142 public If (Expression bool_expr,
143 Statement true_statement,
144 Statement false_statement,
145 Location l)
146 {
147 this.expr = bool_expr;
148 TrueStatement = true_statement;
149 FalseStatement = false_statement;
150 loc = l;
151 }
152
153 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
154 {
155 expr.MutateHoistedGenericType (storey);
156 TrueStatement.MutateHoistedGenericType (storey);
157 if (FalseStatement != null)
158 FalseStatement.MutateHoistedGenericType (storey);
159 }
160
161 public override bool Resolve (BlockContext ec)
162 {
163 bool ok = true;
164
165 Report.Debug (1, "START IF BLOCK", loc);
166
167 expr = expr.Resolve (ec);
168 if (expr == null) {
169 ok = false;
170 } else {
171 //
172 // Dead code elimination
173 //
174 if (expr is Constant) {
175 bool take = !((Constant) expr).IsDefaultValue;
176
177 if (take) {
178 if (!TrueStatement.Resolve (ec))
179 return false;
180
181 if ((FalseStatement != null) &&
182 !FalseStatement.ResolveUnreachable (ec, true))
183 return false;
184 FalseStatement = null;
185 } else {
186 if (!TrueStatement.ResolveUnreachable (ec, true))
187 return false;
188 TrueStatement = null;
189
190 if ((FalseStatement != null) &&
191 !FalseStatement.Resolve (ec))
192 return false;
193 }
194
195 return true;
196 }
197 }
198
199 ec.StartFlowBranching (FlowBranching.BranchingType.Conditional, loc);
200
201 ok &= TrueStatement.Resolve (ec);
202
203 is_true_ret = ec.CurrentBranching.CurrentUsageVector.IsUnreachable;
204
205 ec.CurrentBranching.CreateSibling ();
206
207 if (FalseStatement != null)
208 ok &= FalseStatement.Resolve (ec);
209
210 ec.EndFlowBranching ();
211
212 Report.Debug (1, "END IF BLOCK", loc);
213
214 return ok;
215 }
216
217 protected override void DoEmit (EmitContext ec)
218 {
219 ILGenerator ig = ec.ig;
220 Label false_target = ig.DefineLabel ();
221 Label end;
222
223 //
224 // If we're a boolean constant, Resolve() already
225 // eliminated dead code for us.
226 //
227 Constant c = expr as Constant;
228 if (c != null){
229 c.EmitSideEffect (ec);
230
231 if (!c.IsDefaultValue)
232 TrueStatement.Emit (ec);
233 else if (FalseStatement != null)
234 FalseStatement.Emit (ec);
235
236 return;
237 }
238
239 expr.EmitBranchable (ec, false_target, false);
240
241 TrueStatement.Emit (ec);
242
243 if (FalseStatement != null){
244 bool branch_emitted = false;
245
246 end = ig.DefineLabel ();
247 if (!is_true_ret){
248 ig.Emit (OpCodes.Br, end);
249 branch_emitted = true;
250 }
251
252 ig.MarkLabel (false_target);
253 FalseStatement.Emit (ec);
254
255 if (branch_emitted)
256 ig.MarkLabel (end);
257 } else {
258 ig.MarkLabel (false_target);
259 }
260 }
261
262 protected override void CloneTo (CloneContext clonectx, Statement t)
263 {
264 If target = (If) t;
265
266 target.expr = expr.Clone (clonectx);
267 target.TrueStatement = TrueStatement.Clone (clonectx);
268 if (FalseStatement != null)
269 target.FalseStatement = FalseStatement.Clone (clonectx);
270 }
271 }
272
273 public class Do : Statement {
274 public Expression expr;
275 public Statement EmbeddedStatement;
276
277 public Do (Statement statement, BooleanExpression bool_expr, Location l)
278 {
279 expr = bool_expr;
280 EmbeddedStatement = statement;
281 loc = l;
282 }
283
284 public override bool Resolve (BlockContext ec)
285 {
286 bool ok = true;
287
288 ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc);
289
290 bool was_unreachable = ec.CurrentBranching.CurrentUsageVector.IsUnreachable;
291
292 ec.StartFlowBranching (FlowBranching.BranchingType.Embedded, loc);
293 if (!EmbeddedStatement.Resolve (ec))
294 ok = false;
295 ec.EndFlowBranching ();
296
297 if (ec.CurrentBranching.CurrentUsageVector.IsUnreachable && !was_unreachable)
298 ec.Report.Warning (162, 2, expr.Location, "Unreachable code detected");
299
300 expr = expr.Resolve (ec);
301 if (expr == null)
302 ok = false;
303 else if (expr is Constant){
304 bool infinite = !((Constant) expr).IsDefaultValue;
305 if (infinite)
306 ec.CurrentBranching.CurrentUsageVector.Goto ();
307 }
308
309 ec.EndFlowBranching ();
310
311 return ok;
312 }
313
314 protected override void DoEmit (EmitContext ec)
315 {
316 ILGenerator ig = ec.ig;
317 Label loop = ig.DefineLabel ();
318 Label old_begin = ec.LoopBegin;
319 Label old_end = ec.LoopEnd;
320
321 ec.LoopBegin = ig.DefineLabel ();
322 ec.LoopEnd = ig.DefineLabel ();
323
324 ig.MarkLabel (loop);
325 EmbeddedStatement.Emit (ec);
326 ig.MarkLabel (ec.LoopBegin);
327
328 //
329 // Dead code elimination
330 //
331 if (expr is Constant){
332 bool res = !((Constant) expr).IsDefaultValue;
333
334 expr.EmitSideEffect (ec);
335 if (res)
336 ec.ig.Emit (OpCodes.Br, loop);
337 } else
338 expr.EmitBranchable (ec, loop, true);
339
340 ig.MarkLabel (ec.LoopEnd);
341
342 ec.LoopBegin = old_begin;
343 ec.LoopEnd = old_end;
344 }
345
346 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
347 {
348 expr.MutateHoistedGenericType (storey);
349 EmbeddedStatement.MutateHoistedGenericType (storey);
350 }
351
352 protected override void CloneTo (CloneContext clonectx, Statement t)
353 {
354 Do target = (Do) t;
355
356 target.EmbeddedStatement = EmbeddedStatement.Clone (clonectx);
357 target.expr = expr.Clone (clonectx);
358 }
359 }
360
361 public class While : Statement {
362 public Expression expr;
363 public Statement Statement;
364 bool infinite, empty;
365
366 public While (BooleanExpression bool_expr, Statement statement, Location l)
367 {
368 this.expr = bool_expr;
369 Statement = statement;
370 loc = l;
371 }
372
373 public override bool Resolve (BlockContext ec)
374 {
375 bool ok = true;
376
377 expr = expr.Resolve (ec);
378 if (expr == null)
379 ok = false;
380
381 //
382 // Inform whether we are infinite or not
383 //
384 if (expr is Constant){
385 bool value = !((Constant) expr).IsDefaultValue;
386
387 if (value == false){
388 if (!Statement.ResolveUnreachable (ec, true))
389 return false;
390 empty = true;
391 return true;
392 } else
393 infinite = true;
394 }
395
396 ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc);
397 if (!infinite)
398 ec.CurrentBranching.CreateSibling ();
399
400 ec.StartFlowBranching (FlowBranching.BranchingType.Embedded, loc);
401 if (!Statement.Resolve (ec))
402 ok = false;
403 ec.EndFlowBranching ();
404
405 // There's no direct control flow from the end of the embedded statement to the end of the loop
406 ec.CurrentBranching.CurrentUsageVector.Goto ();
407
408 ec.EndFlowBranching ();
409
410 return ok;
411 }
412
413 protected override void DoEmit (EmitContext ec)
414 {
415 if (empty) {
416 expr.EmitSideEffect (ec);
417 return;
418 }
419
420 ILGenerator ig = ec.ig;
421 Label old_begin = ec.LoopBegin;
422 Label old_end = ec.LoopEnd;
423
424 ec.LoopBegin = ig.DefineLabel ();
425 ec.LoopEnd = ig.DefineLabel ();
426
427 //
428 // Inform whether we are infinite or not
429 //
430 if (expr is Constant){
431 // expr is 'true', since the 'empty' case above handles the 'false' case
432 ig.MarkLabel (ec.LoopBegin);
433 expr.EmitSideEffect (ec);
434 Statement.Emit (ec);
435 ig.Emit (OpCodes.Br, ec.LoopBegin);
436
437 //
438 // Inform that we are infinite (ie, `we return'), only
439 // if we do not `break' inside the code.
440 //
441 ig.MarkLabel (ec.LoopEnd);
442 } else {
443 Label while_loop = ig.DefineLabel ();
444
445 ig.Emit (OpCodes.Br, ec.LoopBegin);
446 ig.MarkLabel (while_loop);
447
448 Statement.Emit (ec);
449
450 ig.MarkLabel (ec.LoopBegin);
451 ec.Mark (loc);
452
453 expr.EmitBranchable (ec, while_loop, true);
454
455 ig.MarkLabel (ec.LoopEnd);
456 }
457
458 ec.LoopBegin = old_begin;
459 ec.LoopEnd = old_end;
460 }
461
462 public override void Emit (EmitContext ec)
463 {
464 DoEmit (ec);
465 }
466
467 protected override void CloneTo (CloneContext clonectx, Statement t)
468 {
469 While target = (While) t;
470
471 target.expr = expr.Clone (clonectx);
472 target.Statement = Statement.Clone (clonectx);
473 }
474
475 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
476 {
477 expr.MutateHoistedGenericType (storey);
478 Statement.MutateHoistedGenericType (storey);
479 }
480 }
481
482 public class For : Statement {
483 Expression Test;
484 Statement InitStatement;
485 Statement Increment;
486 public Statement Statement;
487 bool infinite, empty;
488
489 public For (Statement init_statement,
490 BooleanExpression test,
491 Statement increment,
492 Statement statement,
493 Location l)
494 {
495 InitStatement = init_statement;
496 Test = test;
497 Increment = increment;
498 Statement = statement;
499 loc = l;
500 }
501
502 public override bool Resolve (BlockContext ec)
503 {
504 bool ok = true;
505
506 if (InitStatement != null){
507 if (!InitStatement.Resolve (ec))
508 ok = false;
509 }
510
511 if (Test != null){
512 Test = Test.Resolve (ec);
513 if (Test == null)
514 ok = false;
515 else if (Test is Constant){
516 bool value = !((Constant) Test).IsDefaultValue;
517
518 if (value == false){
519 if (!Statement.ResolveUnreachable (ec, true))
520 return false;
521 if ((Increment != null) &&
522 !Increment.ResolveUnreachable (ec, false))
523 return false;
524 empty = true;
525 return true;
526 } else
527 infinite = true;
528 }
529 } else
530 infinite = true;
531
532 ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc);
533 if (!infinite)
534 ec.CurrentBranching.CreateSibling ();
535
536 bool was_unreachable = ec.CurrentBranching.CurrentUsageVector.IsUnreachable;
537
538 ec.StartFlowBranching (FlowBranching.BranchingType.Embedded, loc);
539 if (!Statement.Resolve (ec))
540 ok = false;
541 ec.EndFlowBranching ();
542
543 if (Increment != null){
544 if (ec.CurrentBranching.CurrentUsageVector.IsUnreachable) {
545 if (!Increment.ResolveUnreachable (ec, !was_unreachable))
546 ok = false;
547 } else {
548 if (!Increment.Resolve (ec))
549 ok = false;
550 }
551 }
552
553 // There's no direct control flow from the end of the embedded statement to the end of the loop
554 ec.CurrentBranching.CurrentUsageVector.Goto ();
555
556 ec.EndFlowBranching ();
557
558 return ok;
559 }
560
561 protected override void DoEmit (EmitContext ec)
562 {
563 if (InitStatement != null && InitStatement != EmptyStatement.Value)
564 InitStatement.Emit (ec);
565
566 if (empty) {
567 Test.EmitSideEffect (ec);
568 return;
569 }
570
571 ILGenerator ig = ec.ig;
572 Label old_begin = ec.LoopBegin;
573 Label old_end = ec.LoopEnd;
574 Label loop = ig.DefineLabel ();
575 Label test = ig.DefineLabel ();
576
577 ec.LoopBegin = ig.DefineLabel ();
578 ec.LoopEnd = ig.DefineLabel ();
579
580 ig.Emit (OpCodes.Br, test);
581 ig.MarkLabel (loop);
582 Statement.Emit (ec);
583
584 ig.MarkLabel (ec.LoopBegin);
585 if (Increment != EmptyStatement.Value)
586 Increment.Emit (ec);
587
588 ig.MarkLabel (test);
589 //
590 // If test is null, there is no test, and we are just
591 // an infinite loop
592 //
593 if (Test != null){
594 //
595 // The Resolve code already catches the case for
596 // Test == Constant (false) so we know that
597 // this is true
598 //
599 if (Test is Constant) {
600 Test.EmitSideEffect (ec);
601 ig.Emit (OpCodes.Br, loop);
602 } else {
603 Test.EmitBranchable (ec, loop, true);
604 }
605
606 } else
607 ig.Emit (OpCodes.Br, loop);
608 ig.MarkLabel (ec.LoopEnd);
609
610 ec.LoopBegin = old_begin;
611 ec.LoopEnd = old_end;
612 }
613
614 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
615 {
616 if (InitStatement != null)
617 InitStatement.MutateHoistedGenericType (storey);
618 if (Test != null)
619 Test.MutateHoistedGenericType (storey);
620 if (Increment != null)
621 Increment.MutateHoistedGenericType (storey);
622
623 Statement.MutateHoistedGenericType (storey);
624 }
625
626 protected override void CloneTo (CloneContext clonectx, Statement t)
627 {
628 For target = (For) t;
629
630 if (InitStatement != null)
631 target.InitStatement = InitStatement.Clone (clonectx);
632 if (Test != null)
633 target.Test = Test.Clone (clonectx);
634 if (Increment != null)
635 target.Increment = Increment.Clone (clonectx);
636 target.Statement = Statement.Clone (clonectx);
637 }
638 }
639
640 public class StatementExpression : Statement {
641 ExpressionStatement expr;
642
643 public StatementExpression (ExpressionStatement expr)
644 {
645 this.expr = expr;
646 loc = expr.Location;
647 }
648
649 public override bool Resolve (BlockContext ec)
650 {
651 if (expr != null && expr.eclass == ExprClass.Invalid)
652 expr = expr.ResolveStatement (ec);
653 return expr != null;
654 }
655
656 protected override void DoEmit (EmitContext ec)
657 {
658 expr.EmitStatement (ec);
659 }
660
661 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
662 {
663 expr.MutateHoistedGenericType (storey);
664 }
665
666 public override string ToString ()
667 {
668 return "StatementExpression (" + expr + ")";
669 }
670
671 protected override void CloneTo (CloneContext clonectx, Statement t)
672 {
673 StatementExpression target = (StatementExpression) t;
674
675 target.expr = (ExpressionStatement) expr.Clone (clonectx);
676 }
677 }
678
679 // A 'return' or a 'yield break'
680 public abstract class ExitStatement : Statement
681 {
682 protected bool unwind_protect;
683 protected abstract bool DoResolve (BlockContext ec);
684
685 public virtual void Error_FinallyClause (Report Report)
686 {
687 Report.Error (157, loc, "Control cannot leave the body of a finally clause");
688 }
689
690 public sealed override bool Resolve (BlockContext ec)
691 {
692 if (!DoResolve (ec))
693 return false;
694
695 unwind_protect = ec.CurrentBranching.AddReturnOrigin (ec.CurrentBranching.CurrentUsageVector, this);
696 if (unwind_protect)
697 ec.NeedReturnLabel ();
698 ec.CurrentBranching.CurrentUsageVector.Goto ();
699 return true;
700 }
701 }
702
703 /// <summary>
704 /// Implements the return statement
705 /// </summary>
706 public class Return : ExitStatement {
707 protected Expression Expr;
708 public Return (Expression expr, Location l)
709 {
710 Expr = expr;
711 loc = l;
712 }
713
714 protected override bool DoResolve (BlockContext ec)
715 {
716 if (Expr == null) {
717 if (ec.ReturnType == TypeManager.void_type)
718 return true;
719
720 ec.Report.Error (126, loc,
721 "An object of a type convertible to `{0}' is required for the return statement",
722 TypeManager.CSharpName (ec.ReturnType));
723 return false;
724 }
725
726 if (ec.CurrentBlock.Toplevel.IsIterator) {
727 ec.Report.Error (1622, loc, "Cannot return a value from iterators. Use the yield return " +
728 "statement to return a value, or yield break to end the iteration");
729 }
730
731 AnonymousExpression am = ec.CurrentAnonymousMethod;
732 if (am == null && ec.ReturnType == TypeManager.void_type) {
733 ec.Report.Error (127, loc, "`{0}': A return keyword must not be followed by any expression when method returns void",
734 ec.GetSignatureForError ());
735 }
736
737 Expr = Expr.Resolve (ec);
738 if (Expr == null)
739 return false;
740
741 if (ec.HasSet (ResolveContext.Options.InferReturnType)) {
742 ec.ReturnTypeInference.AddCommonTypeBound (Expr.Type);
743 return true;
744 }
745
746 if (Expr.Type != ec.ReturnType) {
747 Expr = Convert.ImplicitConversionRequired (ec, Expr, ec.ReturnType, loc);
748
749 if (Expr == null) {
750 if (am != null) {
751 ec.Report.Error (1662, loc,
752 "Cannot convert `{0}' to delegate type `{1}' because some of the return types in the block are not implicitly convertible to the delegate return type",
753 am.ContainerType, am.GetSignatureForError ());
754 }
755 return false;
756 }
757 }
758
759 return true;
760 }
761
762 protected override void DoEmit (EmitContext ec)
763 {
764 if (Expr != null) {
765 Expr.Emit (ec);
766
767 if (unwind_protect)
768 ec.ig.Emit (OpCodes.Stloc, ec.TemporaryReturn ());
769 }
770
771 if (unwind_protect)
772 ec.ig.Emit (OpCodes.Leave, ec.ReturnLabel);
773 else
774 ec.ig.Emit (OpCodes.Ret);
775 }
776
777 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
778 {
779 if (Expr != null)
780 Expr.MutateHoistedGenericType (storey);
781 }
782
783 protected override void CloneTo (CloneContext clonectx, Statement t)
784 {
785 Return target = (Return) t;
786 // It's null for simple return;
787 if (Expr != null)
788 target.Expr = Expr.Clone (clonectx);
789 }
790 }
791
792 public class Goto : Statement {
793 string target;
794 LabeledStatement label;
795 bool unwind_protect;
796
797 public override bool Resolve (BlockContext ec)
798 {
799 unwind_protect = ec.CurrentBranching.AddGotoOrigin (ec.CurrentBranching.CurrentUsageVector, this);
800 ec.CurrentBranching.CurrentUsageVector.Goto ();
801 return true;
802 }
803
804 public Goto (string label, Location l)
805 {
806 loc = l;
807 target = label;
808 }
809
810 public string Target {
811 get { return target; }
812 }
813
814 public void SetResolvedTarget (LabeledStatement label)
815 {
816 this.label = label;
817 label.AddReference ();
818 }
819
820 protected override void CloneTo (CloneContext clonectx, Statement target)
821 {
822 // Nothing to clone
823 }
824
825 protected override void DoEmit (EmitContext ec)
826 {
827 if (label == null)
828 throw new InternalErrorException ("goto emitted before target resolved");
829 Label l = label.LabelTarget (ec);
830 ec.ig.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, l);
831 }
832
833 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
834 {
835 }
836 }
837
838 public class LabeledStatement : Statement {
839 string name;
840 bool defined;
841 bool referenced;
842 Label label;
843 ILGenerator ig;
844
845 FlowBranching.UsageVector vectors;
846
847 public LabeledStatement (string name, Location l)
848 {
849 this.name = name;
850 this.loc = l;
851 }
852
853 public Label LabelTarget (EmitContext ec)
854 {
855 if (defined)
856 return label;
857 ig = ec.ig;
858 label = ec.ig.DefineLabel ();
859 defined = true;
860
861 return label;
862 }
863
864 public string Name {
865 get { return name; }
866 }
867
868 public bool IsDefined {
869 get { return defined; }
870 }
871
872 public bool HasBeenReferenced {
873 get { return referenced; }
874 }
875
876 public FlowBranching.UsageVector JumpOrigins {
877 get { return vectors; }
878 }
879
880 public void AddUsageVector (FlowBranching.UsageVector vector)
881 {
882 vector = vector.Clone ();
883 vector.Next = vectors;
884 vectors = vector;
885 }
886
887 protected override void CloneTo (CloneContext clonectx, Statement target)
888 {
889 // nothing to clone
890 }
891
892 public override bool Resolve (BlockContext ec)
893 {
894 // this flow-branching will be terminated when the surrounding block ends
895 ec.StartFlowBranching (this);
896 return true;
897 }
898
899 protected override void DoEmit (EmitContext ec)
900 {
901 if (ig != null && ig != ec.ig)
902 throw new InternalErrorException ("cannot happen");
903 LabelTarget (ec);
904 ec.ig.MarkLabel (label);
905 }
906
907 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
908 {
909 }
910
911 public void AddReference ()
912 {
913 referenced = true;
914 }
915 }
916
917
918 /// <summary>
919 /// `goto default' statement
920 /// </summary>
921 public class GotoDefault : Statement {
922
923 public GotoDefault (Location l)
924 {
925 loc = l;
926 }
927
928 protected override void CloneTo (CloneContext clonectx, Statement target)
929 {
930 // nothing to clone
931 }
932
933 public override bool Resolve (BlockContext ec)
934 {
935 ec.CurrentBranching.CurrentUsageVector.Goto ();
936
937 if (ec.Switch == null) {
938 ec.Report.Error (153, loc, "A goto case is only valid inside a switch statement");
939 return false;
940 }
941
942 if (!ec.Switch.GotDefault) {
943 FlowBranchingBlock.Error_UnknownLabel (loc, "default", ec.Report);
944 return false;
945 }
946
947 return true;
948 }
949
950 protected override void DoEmit (EmitContext ec)
951 {
952 ec.ig.Emit (OpCodes.Br, ec.Switch.DefaultTarget);
953 }
954
955 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
956 {
957 }
958 }
959
960 /// <summary>
961 /// `goto case' statement
962 /// </summary>
963 public class GotoCase : Statement {
964 Expression expr;
965 SwitchLabel sl;
966
967 public GotoCase (Expression e, Location l)
968 {
969 expr = e;
970 loc = l;
971 }
972
973 public override bool Resolve (BlockContext ec)
974 {
975 if (ec.Switch == null){
976 ec.Report.Error (153, loc, "A goto case is only valid inside a switch statement");
977 return false;
978 }
979
980 ec.CurrentBranching.CurrentUsageVector.Goto ();
981
982 expr = expr.Resolve (ec);
983 if (expr == null)
984 return false;
985
986 Constant c = expr as Constant;
987 if (c == null) {
988 ec.Report.Error (150, expr.Location, "A constant value is expected");
989 return false;
990 }
991
992 Type type = ec.Switch.SwitchType;
993 Constant res = c.TryReduce (ec, type, c.Location);
994 if (res == null) {
995 c.Error_ValueCannotBeConverted (ec, loc, type, true);
996 return false;
997 }
998
999 if (!Convert.ImplicitStandardConversionExists (c, type))
1000 ec.Report.Warning (469, 2, loc,
1001 "The `goto case' value is not implicitly convertible to type `{0}'",
1002 TypeManager.CSharpName (type));
1003
1004 object val = res.GetValue ();
1005 if (val == null)
1006 val = SwitchLabel.NullStringCase;
1007
1008 sl = (SwitchLabel) ec.Switch.Elements [val];
1009
1010 if (sl == null){
1011 FlowBranchingBlock.Error_UnknownLabel (loc, "case " +
1012 (c.GetValue () == null ? "null" : val.ToString ()), ec.Report);
1013 return false;
1014 }
1015
1016 return true;
1017 }
1018
1019 protected override void DoEmit (EmitContext ec)
1020 {
1021 ec.ig.Emit (OpCodes.Br, sl.GetILLabelCode (ec));
1022 }
1023
1024 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
1025 {
1026 expr.MutateHoistedGenericType (storey);
1027 }
1028
1029 protected override void CloneTo (CloneContext clonectx, Statement t)
1030 {
1031 GotoCase target = (GotoCase) t;
1032
1033 target.expr = expr.Clone (clonectx);
1034 }
1035 }
1036
1037 public class Throw : Statement {
1038 Expression expr;
1039
1040 public Throw (Expression expr, Location l)
1041 {
1042 this.expr = expr;
1043 loc = l;
1044 }
1045
1046 public override bool Resolve (BlockContext ec)
1047 {
1048 if (expr == null) {
1049 ec.CurrentBranching.CurrentUsageVector.Goto ();
1050 return ec.CurrentBranching.CheckRethrow (loc);
1051 }
1052
1053 expr = expr.Resolve (ec, ResolveFlags.Type | ResolveFlags.VariableOrValue);
1054 ec.CurrentBranching.CurrentUsageVector.Goto ();
1055
1056 if (expr == null)
1057 return false;
1058
1059 if (Convert.ImplicitConversionExists (ec, expr, TypeManager.exception_type))
1060 expr = Convert.ImplicitConversion (ec, expr, TypeManager.exception_type, loc);
1061 else
1062 ec.Report.Error (155, expr.Location, "The type caught or thrown must be derived from System.Exception");
1063
1064 return true;
1065 }
1066
1067 protected override void DoEmit (EmitContext ec)
1068 {
1069 if (expr == null)
1070 ec.ig.Emit (OpCodes.Rethrow);
1071 else {
1072 expr.Emit (ec);
1073
1074 ec.ig.Emit (OpCodes.Throw);
1075 }
1076 }
1077
1078 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
1079 {
1080 if (expr != null)
1081 expr.MutateHoistedGenericType (storey);
1082 }
1083
1084 protected override void CloneTo (CloneContext clonectx, Statement t)
1085 {
1086 Throw target = (Throw) t;
1087
1088 if (expr != null)
1089 target.expr = expr.Clone (clonectx);
1090 }
1091 }
1092
1093 public class Break : Statement {
1094
1095 public Break (Location l)
1096 {
1097 loc = l;
1098 }
1099
1100 bool unwind_protect;
1101
1102 public override bool Resolve (BlockContext ec)
1103 {
1104 unwind_protect = ec.CurrentBranching.AddBreakOrigin (ec.CurrentBranching.CurrentUsageVector, loc);
1105 ec.CurrentBranching.CurrentUsageVector.Goto ();
1106 return true;
1107 }
1108
1109 protected override void DoEmit (EmitContext ec)
1110 {
1111 ec.ig.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, ec.LoopEnd);
1112 }
1113
1114 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
1115 {
1116 }
1117
1118 protected override void CloneTo (CloneContext clonectx, Statement t)
1119 {
1120 // nothing needed
1121 }
1122 }
1123
1124 public class Continue : Statement {
1125
1126 public Continue (Location l)
1127 {
1128 loc = l;
1129 }
1130
1131 bool unwind_protect;
1132
1133 public override bool Resolve (BlockContext ec)
1134 {
1135 unwind_protect = ec.CurrentBranching.AddContinueOrigin (ec.CurrentBranching.CurrentUsageVector, loc);
1136 ec.CurrentBranching.CurrentUsageVector.Goto ();
1137 return true;
1138 }
1139
1140 protected override void DoEmit (EmitContext ec)
1141 {
1142 ec.ig.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, ec.LoopBegin);
1143 }
1144
1145 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
1146 {
1147 }
1148
1149 protected override void CloneTo (CloneContext clonectx, Statement t)
1150 {
1151 // nothing needed.
1152 }
1153 }
1154
1155 public interface ILocalVariable
1156 {
1157 void Emit (EmitContext ec);
1158 void EmitAssign (EmitContext ec);
1159 void EmitAddressOf (EmitContext ec);
1160 }
1161
1162 public interface IKnownVariable {
1163 Block Block { get; }
1164 Location Location { get; }
1165 }
1166
1167 //
1168 // The information about a user-perceived local variable
1169 //
1170 public class LocalInfo : IKnownVariable, ILocalVariable {
1171 public readonly FullNamedExpression Type;
1172
1173 public Type VariableType;
1174 public readonly string Name;
1175 public readonly Location Location;
1176 public readonly Block Block;
1177
1178 public VariableInfo VariableInfo;
1179 public HoistedVariable HoistedVariableReference;
1180
1181 [Flags]
1182 enum Flags : byte {
1183 Used = 1,
1184 ReadOnly = 2,
1185 Pinned = 4,
1186 IsThis = 8,
1187 AddressTaken = 32,
1188 CompilerGenerated = 64,
1189 IsConstant = 128
1190 }
1191
1192 public enum ReadOnlyContext: byte {
1193 Using,
1194 Foreach,
1195 Fixed
1196 }
1197
1198 Flags flags;
1199 ReadOnlyContext ro_context;
1200 LocalBuilder builder;
1201
1202 public LocalInfo (FullNamedExpression type, string name, Block block, Location l)
1203 {
1204 Type = type;
1205 Name = name;
1206 Block = block;
1207 Location = l;
1208 }
1209
1210 public LocalInfo (DeclSpace ds, Block block, Location l)
1211 {
1212 VariableType = ds.IsGeneric ? ds.CurrentType : ds.TypeBuilder;
1213 Block = block;
1214 Location = l;
1215 }
1216
1217 public void ResolveVariable (EmitContext ec)
1218 {
1219 if (HoistedVariableReference != null)
1220 return;
1221
1222 if (builder == null) {
1223 if (Pinned)
1224 //
1225 // This is needed to compile on both .NET 1.x and .NET 2.x
1226 // the later introduced `DeclareLocal (Type t, bool pinned)'
1227 //
1228 builder = TypeManager.DeclareLocalPinned (ec.ig, VariableType);
1229 else
1230 builder = ec.ig.DeclareLocal (TypeManager.TypeToReflectionType (VariableType));
1231 }
1232 }
1233
1234 public void Emit (EmitContext ec)
1235 {
1236 ec.ig.Emit (OpCodes.Ldloc, builder);
1237 }
1238
1239 public void EmitAssign (EmitContext ec)
1240 {
1241 ec.ig.Emit (OpCodes.Stloc, builder);
1242 }
1243
1244 public void EmitAddressOf (EmitContext ec)
1245 {
1246 ec.ig.Emit (OpCodes.Ldloca, builder);
1247 }
1248
1249 public void EmitSymbolInfo (EmitContext ec)
1250 {
1251 if (builder != null)
1252 ec.DefineLocalVariable (Name, builder);
1253 }
1254
1255 public bool IsThisAssigned (BlockContext ec, Block block)
1256 {
1257 if (VariableInfo == null)
1258 throw new Exception ();
1259
1260 if (!ec.DoFlowAnalysis || ec.CurrentBranching.IsAssigned (VariableInfo))
1261 return true;
1262
1263 return VariableInfo.TypeInfo.IsFullyInitialized (ec, VariableInfo, block.StartLocation);
1264 }
1265
1266 public bool IsAssigned (BlockContext ec)
1267 {
1268 if (VariableInfo == null)
1269 throw new Exception ();
1270
1271 return !ec.DoFlowAnalysis || ec.CurrentBranching.IsAssigned (VariableInfo);
1272 }
1273
1274 public bool Resolve (ResolveContext ec)
1275 {
1276 if (VariableType != null)
1277 return true;
1278
1279 TypeExpr texpr = Type.ResolveAsContextualType (ec, false);
1280 if (texpr == null)
1281 return false;
1282
1283 VariableType = texpr.Type;
1284
1285 if (TypeManager.IsGenericParameter (VariableType))
1286 return true;
1287
1288 if (VariableType.IsAbstract && VariableType.IsSealed) {
1289 FieldBase.Error_VariableOfStaticClass (Location, Name, VariableType, ec.Report);
1290 return false;
1291 }
1292
1293 if (VariableType.IsPointer && !ec.IsUnsafe)
1294 Expression.UnsafeError (ec, Location);
1295
1296 return true;
1297 }
1298
1299 public bool IsConstant {
1300 get { return (flags & Flags.IsConstant) != 0; }
1301 set { flags |= Flags.IsConstant; }
1302 }
1303
1304 public bool AddressTaken {
1305 get { return (flags & Flags.AddressTaken) != 0; }
1306 set { flags |= Flags.AddressTaken; }
1307 }
1308
1309 public bool CompilerGenerated {
1310 get { return (flags & Flags.CompilerGenerated) != 0; }
1311 set { flags |= Flags.CompilerGenerated; }
1312 }
1313
1314 public override string ToString ()
1315 {
1316 return String.Format ("LocalInfo ({0},{1},{2},{3})",
1317 Name, Type, VariableInfo, Location);
1318 }
1319
1320 public bool Used {
1321 get { return (flags & Flags.Used) != 0; }
1322 set { flags = value ? (flags | Flags.Used) : (unchecked (flags & ~Flags.Used)); }
1323 }
1324
1325 public bool ReadOnly {
1326 get { return (flags & Flags.ReadOnly) != 0; }
1327 }
1328
1329 public void SetReadOnlyContext (ReadOnlyContext context)
1330 {
1331 flags |= Flags.ReadOnly;
1332 ro_context = context;
1333 }
1334
1335 public string GetReadOnlyContext ()
1336 {
1337 if (!ReadOnly)
1338 throw new InternalErrorException ("Variable is not readonly");
1339
1340 switch (ro_context) {
1341 case ReadOnlyContext.Fixed:
1342 return "fixed variable";
1343 case ReadOnlyContext.Foreach:
1344 return "foreach iteration variable";
1345 case ReadOnlyContext.Using:
1346 return "using variable";
1347 }
1348 throw new NotImplementedException ();
1349 }
1350
1351 //
1352 // Whether the variable is pinned, if Pinned the variable has been
1353 // allocated in a pinned slot with DeclareLocal.
1354 //
1355 public bool Pinned {
1356 get { return (flags & Flags.Pinned) != 0; }
1357 set { flags = value ? (flags | Flags.Pinned) : (flags & ~Flags.Pinned); }
1358 }
1359
1360 public bool IsThis {
1361 get { return (flags & Flags.IsThis) != 0; }
1362 set { flags = value ? (flags | Flags.IsThis) : (flags & ~Flags.IsThis); }
1363 }
1364
1365 Block IKnownVariable.Block {
1366 get { return Block; }
1367 }
1368
1369 Location IKnownVariable.Location {
1370 get { return Location; }
1371 }
1372
1373 public LocalInfo Clone (CloneContext clonectx)
1374 {
1375 //
1376 // Variables in anonymous block are not resolved yet
1377 //
1378 if (VariableType == null)
1379 return new LocalInfo ((FullNamedExpression) Type.Clone (clonectx), Name, clonectx.LookupBlock (Block), Location);
1380
1381 //
1382 // Variables in method block are resolved
1383 //
1384 LocalInfo li = new LocalInfo (null, Name, clonectx.LookupBlock (Block), Location);
1385 li.VariableType = VariableType;
1386 return li;
1387 }
1388 }
1389
1390 /// <summary>
1391 /// Block represents a C# block.
1392 /// </summary>
1393 ///
1394 /// <remarks>
1395 /// This class is used in a number of places: either to represent
1396 /// explicit blocks that the programmer places or implicit blocks.
1397 ///
1398 /// Implicit blocks are used as labels or to introduce variable
1399 /// declarations.
1400 ///
1401 /// Top-level blocks derive from Block, and they are called ToplevelBlock
1402 /// they contain extra information that is not necessary on normal blocks.
1403 /// </remarks>
1404 public class Block : Statement {
1405 public Block Parent;
1406 public Location StartLocation;
1407 public Location EndLocation = Location.Null;
1408
1409 public ExplicitBlock Explicit;
1410 public ToplevelBlock Toplevel; // TODO: Use Explicit
1411
1412 [Flags]
1413 public enum Flags : byte {
1414 Unchecked = 1,
1415 BlockUsed = 2,
1416 VariablesInitialized = 4,
1417 HasRet = 8,
1418 Unsafe = 16,
1419 IsIterator = 32,
1420 HasCapturedVariable = 64,
1421 HasCapturedThis = 128
1422 }
1423 protected Flags flags;
1424
1425 public bool Unchecked {
1426 get { return (flags & Flags.Unchecked) != 0; }
1427 set { flags = value ? flags | Flags.Unchecked : flags & ~Flags.Unchecked; }
1428 }
1429
1430 public bool Unsafe {
1431 get { return (flags & Flags.Unsafe) != 0; }
1432 set { flags |= Flags.Unsafe; }
1433 }
1434
1435 //
1436 // The statements in this block
1437 //
1438 protected ArrayList statements;
1439
1440 //
1441 // An array of Blocks. We keep track of children just
1442 // to generate the local variable declarations.
1443 //
1444 // Statements and child statements are handled through the
1445 // statements.
1446 //
1447 ArrayList children;
1448
1449 //
1450 // Labels. (label, block) pairs.
1451 //
1452 protected HybridDictionary labels;
1453
1454 //
1455 // Keeps track of (name, type) pairs
1456 //
1457 IDictionary variables;
1458
1459 //
1460 // Keeps track of constants
1461 HybridDictionary constants;
1462
1463 //
1464 // Temporary variables.
1465 //
1466 ArrayList temporary_variables;
1467
1468 //
1469 // If this is a switch section, the enclosing switch block.
1470 //
1471 Block switch_block;
1472
1473 protected ArrayList scope_initializers;
1474
1475 ArrayList anonymous_children;
1476
1477 protected static int id;
1478
1479 int this_id;
1480
1481 int assignable_slots;
1482 bool unreachable_shown;
1483 bool unreachable;
1484
1485 public Block (Block parent)
1486 : this (parent, (Flags) 0, Location.Null, Location.Null)
1487 { }
1488
1489 public Block (Block parent, Flags flags)
1490 : this (parent, flags, Location.Null, Location.Null)
1491 { }
1492
1493 public Block (Block parent, Location start, Location end)
1494 : this (parent, (Flags) 0, start, end)
1495 { }
1496
1497 //
1498 // Useful when TopLevel block is downgraded to normal block
1499 //
1500 public Block (ToplevelBlock parent, ToplevelBlock source)
1501 : this (parent, source.flags, source.StartLocation, source.EndLocation)
1502 {
1503 statements = source.statements;
1504 children = source.children;
1505 labels = source.labels;
1506 variables = source.variables;
1507 constants = source.constants;
1508 switch_block = source.switch_block;
1509 }
1510
1511 public Block (Block parent, Flags flags, Location start, Location end)
1512 {
1513 if (parent != null) {
1514 parent.AddChild (this);
1515
1516 // the appropriate constructors will fixup these fields
1517 Toplevel = parent.Toplevel;
1518 Explicit = parent.Explicit;
1519 }
1520
1521 this.Parent = parent;
1522 this.flags = flags;
1523 this.StartLocation = start;
1524 this.EndLocation = end;
1525 this.loc = start;
1526 this_id = id++;
1527 statements = new ArrayList (4);
1528 }
1529
1530 public Block CreateSwitchBlock (Location start)
1531 {
1532 // FIXME: should this be implicit?
1533 Block new_block = new ExplicitBlock (this, start, start);
1534 new_block.switch_block = this;
1535 return new_block;
1536 }
1537
1538 public int ID {
1539 get { return this_id; }
1540 }
1541
1542 public IDictionary Variables {
1543 get {
1544 if (variables == null)
1545 variables = new ListDictionary ();
1546 return variables;
1547 }
1548 }
1549
1550 void AddChild (Block b)
1551 {
1552 if (children == null)
1553 children = new ArrayList (1);
1554
1555 children.Add (b);
1556 }
1557
1558 public void SetEndLocation (Location loc)
1559 {
1560 EndLocation = loc;
1561 }
1562
1563 protected void Error_158 (string name, Location loc)
1564 {
1565 Toplevel.Report.Error (158, loc, "The label `{0}' shadows another label " +
1566 "by the same name in a contained scope", name);
1567 }
1568
1569 /// <summary>
1570 /// Adds a label to the current block.
1571 /// </summary>
1572 ///
1573 /// <returns>
1574 /// false if the name already exists in this block. true
1575 /// otherwise.
1576 /// </returns>
1577 ///
1578 public bool AddLabel (LabeledStatement target)
1579 {
1580 if (switch_block != null)
1581 return switch_block.AddLabel (target);
1582
1583 string name = target.Name;
1584
1585 Block cur = this;
1586 while (cur != null) {
1587 LabeledStatement s = cur.DoLookupLabel (name);
1588 if (s != null) {
1589 Toplevel.Report.SymbolRelatedToPreviousError (s.loc, s.Name);
1590 Toplevel.Report.Error (140, target.loc, "The label `{0}' is a duplicate", name);
1591 return false;
1592 }
1593
1594 if (this == Explicit)
1595 break;
1596
1597 cur = cur.Parent;
1598 }
1599
1600 while (cur != null) {
1601 if (cur.DoLookupLabel (name) != null) {
1602 Error_158 (name, target.loc);
1603 return false;
1604 }
1605
1606 if (children != null) {
1607 foreach (Block b in children) {
1608 LabeledStatement s = b.DoLookupLabel (name);
1609 if (s == null)
1610 continue;
1611
1612 Toplevel.Report.SymbolRelatedToPreviousError (s.loc, s.Name);
1613 Error_158 (name, target.loc);
1614 return false;
1615 }
1616 }
1617
1618 cur = cur.Parent;
1619 }
1620
1621 Toplevel.CheckError158 (name, target.loc);
1622
1623 if (labels == null)
1624 labels = new HybridDictionary();
1625
1626 labels.Add (name, target);
1627 return true;
1628 }
1629
1630 public LabeledStatement LookupLabel (string name)
1631 {
1632 LabeledStatement s = DoLookupLabel (name);
1633 if (s != null)
1634 return s;
1635
1636 if (children == null)
1637 return null;
1638
1639 foreach (Block child in children) {
1640 if (Explicit != child.Explicit)
1641 continue;
1642
1643 s = child.LookupLabel (name);
1644 if (s != null)
1645 return s;
1646 }
1647
1648 return null;
1649 }
1650
1651 LabeledStatement DoLookupLabel (string name)
1652 {
1653 if (switch_block != null)
1654 return switch_block.LookupLabel (name);
1655
1656 if (labels != null)
1657 if (labels.Contains (name))
1658 return ((LabeledStatement) labels [name]);
1659
1660 return null;
1661 }
1662
1663 public bool CheckInvariantMeaningInBlock (string name, Expression e, Location loc)
1664 {
1665 Block b = this;
1666 IKnownVariable kvi = b.Explicit.GetKnownVariable (name);
1667 while (kvi == null) {
1668 b = b.Explicit.Parent;
1669 if (b == null)
1670 return true;
1671 kvi = b.Explicit.GetKnownVariable (name);
1672 }
1673
1674 if (kvi.Block == b)
1675 return true;
1676
1677 // Is kvi.Block nested inside 'b'
1678 if (b.Explicit != kvi.Block.Explicit) {
1679 //
1680 // If a variable by the same name it defined in a nested block of this
1681 // block, we violate the invariant meaning in a block.
1682 //
1683 if (b == this) {
1684 Toplevel.Report.SymbolRelatedToPreviousError (kvi.Location, name);
1685 Toplevel.Report.Error (135, loc, "`{0}' conflicts with a declaration in a child block", name);
1686 return false;
1687 }
1688
1689 //
1690 // It's ok if the definition is in a nested subblock of b, but not
1691 // nested inside this block -- a definition in a sibling block
1692 // should not affect us.
1693 //
1694 return true;
1695 }
1696
1697 //
1698 // Block 'b' and kvi.Block are the same textual block.
1699 // However, different variables are extant.
1700 //
1701 // Check if the variable is in scope in both blocks. We use
1702 // an indirect check that depends on AddVariable doing its
1703 // part in maintaining the invariant-meaning-in-block property.
1704 //
1705 if (e is VariableReference || (e is Constant && b.GetLocalInfo (name) != null))
1706 return true;
1707
1708 if (this is ToplevelBlock) {
1709 Toplevel.Report.SymbolRelatedToPreviousError (kvi.Location, name);
1710 e.Error_VariableIsUsedBeforeItIsDeclared (Toplevel.Report, name);
1711 return false;
1712 }
1713
1714 //
1715 // Even though we detected the error when the name is used, we
1716 // treat it as if the variable declaration was in error.
1717 //
1718 Toplevel.Report.SymbolRelatedToPreviousError (loc, name);
1719 Error_AlreadyDeclared (kvi.Location, name, "parent or current");
1720 return false;
1721 }
1722
1723 protected virtual bool CheckParentConflictName (ToplevelBlock block, string name, Location l)
1724 {
1725 LocalInfo vi = GetLocalInfo (name);
1726 if (vi != null) {
1727 block.Report.SymbolRelatedToPreviousError (vi.Location, name);
1728 if (Explicit == vi.Block.Explicit) {
1729 Error_AlreadyDeclared (l, name, null);
1730 } else {
1731 Error_AlreadyDeclared (l, name, this is ToplevelBlock ?
1732 "parent or current" : "parent");
1733 }
1734 return false;
1735 }
1736
1737 if (block != null) {
1738 Expression e = block.GetParameterReference (name, Location.Null);
1739 if (e != null) {
1740 ParameterReference pr = e as ParameterReference;
1741 if (this is Linq.QueryBlock && (pr != null && pr.Parameter is Linq.QueryBlock.ImplicitQueryParameter || e is MemberAccess))
1742 Error_AlreadyDeclared (loc, name);
1743 else
1744 Error_AlreadyDeclared (loc, name, "parent or current");
1745 return false;
1746 }
1747 }
1748
1749 return true;
1750 }
1751
1752 public LocalInfo AddVariable (Expression type, string name, Location l)
1753 {
1754 if (!CheckParentConflictName (Toplevel, name, l))
1755 return null;
1756
1757 if (Toplevel.GenericMethod != null) {
1758 foreach (TypeParameter tp in Toplevel.GenericMethod.CurrentTypeParameters) {
1759 if (tp.Name == name) {
1760 Toplevel.Report.SymbolRelatedToPreviousError (tp);
1761 Error_AlreadyDeclaredTypeParameter (Toplevel.Report, loc, name, "local variable");
1762 return null;
1763 }
1764 }
1765 }
1766
1767 IKnownVariable kvi = Explicit.GetKnownVariable (name);
1768 if (kvi != null) {
1769 Toplevel.Report.SymbolRelatedToPreviousError (kvi.Location, name);
1770 Error_AlreadyDeclared (l, name, "child");
1771 return null;
1772 }
1773
1774 LocalInfo vi = new LocalInfo ((FullNamedExpression) type, name, this, l);
1775 AddVariable (vi);
1776
1777 if ((flags & Flags.VariablesInitialized) != 0)
1778 throw new InternalErrorException ("block has already been resolved");
1779
1780 return vi;
1781 }
1782
1783 protected virtual void AddVariable (LocalInfo li)
1784 {
1785 Variables.Add (li.Name, li);
1786 Explicit.AddKnownVariable (li.Name, li);
1787 }
1788
1789 protected virtual void Error_AlreadyDeclared (Location loc, string var, string reason)
1790 {
1791 if (reason == null) {
1792 Error_AlreadyDeclared (loc, var);
1793 return;
1794 }
1795
1796 Toplevel.Report.Error (136, loc, "A local variable named `{0}' cannot be declared " +
1797 "in this scope because it would give a different meaning " +
1798 "to `{0}', which is already used in a `{1}' scope " +
1799 "to denote something else", var, reason);
1800 }
1801
1802 protected virtual void Error_AlreadyDeclared (Location loc, string name)
1803 {
1804 Toplevel.Report.Error (128, loc,
1805 "A local variable named `{0}' is already defined in this scope", name);
1806 }
1807
1808 public virtual void Error_AlreadyDeclaredTypeParameter (Report r, Location loc, string name, string conflict)
1809 {
1810 r.Error (412, loc, "The type parameter name `{0}' is the same as `{1}'",
1811 name, conflict);
1812 }
1813
1814 public bool AddConstant (Expression type, string name, Expression value, Location l)
1815 {
1816 if (AddVariable (type, name, l) == null)
1817 return false;
1818
1819 if (constants == null)
1820 constants = new HybridDictionary();
1821
1822 constants.Add (name, value);
1823
1824 // A block is considered used if we perform an initialization in a local declaration, even if it is constant.
1825 Use ();
1826 return true;
1827 }
1828
1829 static int next_temp_id = 0;
1830
1831 public LocalInfo AddTemporaryVariable (TypeExpr te, Location loc)
1832 {
1833 Report.Debug (64, "ADD TEMPORARY", this, Toplevel, loc);
1834
1835 if (temporary_variables == null)
1836 temporary_variables = new ArrayList ();
1837
1838 int id = ++next_temp_id;
1839 string name = "$s_" + id.ToString ();
1840
1841 LocalInfo li = new LocalInfo (te, name, this, loc);
1842 li.CompilerGenerated = true;
1843 temporary_variables.Add (li);
1844 return li;
1845 }
1846
1847 public LocalInfo GetLocalInfo (string name)
1848 {
1849 LocalInfo ret;
1850 for (Block b = this; b != null; b = b.Parent) {
1851 if (b.variables != null) {
1852 ret = (LocalInfo) b.variables [name];
1853 if (ret != null)
1854 return ret;
1855 }
1856 }
1857
1858 return null;
1859 }
1860
1861 public Expression GetVariableType (string name)
1862 {
1863 LocalInfo vi = GetLocalInfo (name);
1864 return vi == null ? null : vi.Type;
1865 }
1866
1867 public Expression GetConstantExpression (string name)
1868 {
1869 for (Block b = this; b != null; b = b.Parent) {
1870 if (b.constants != null) {
1871 Expression ret = b.constants [name] as Expression;
1872 if (ret != null)
1873 return ret;
1874 }
1875 }
1876 return null;
1877 }
1878
1879 //
1880 // It should be used by expressions which require to
1881 // register a statement during resolve process.
1882 //
1883 public void AddScopeStatement (Statement s)
1884 {
1885 if (scope_initializers == null)
1886 scope_initializers = new ArrayList ();
1887
1888 scope_initializers.Add (s);
1889 }
1890
1891 public void AddStatement (Statement s)
1892 {
1893 statements.Add (s);
1894 flags |= Flags.BlockUsed;
1895 }
1896
1897 public bool Used {
1898 get { return (flags & Flags.BlockUsed) != 0; }
1899 }
1900
1901 public void Use ()
1902 {
1903 flags |= Flags.BlockUsed;
1904 }
1905
1906 public bool HasRet {
1907 get { return (flags & Flags.HasRet) != 0; }
1908 }
1909
1910 public int AssignableSlots {
1911 get {
1912 // TODO: Re-enable
1913 // if ((flags & Flags.VariablesInitialized) == 0)
1914 // throw new Exception ("Variables have not been initialized yet");
1915 return assignable_slots;
1916 }
1917 }
1918
1919 public ArrayList AnonymousChildren {
1920 get { return anonymous_children; }
1921 }
1922
1923 public void AddAnonymousChild (ToplevelBlock b)
1924 {
1925 if (anonymous_children == null)
1926 anonymous_children = new ArrayList ();
1927
1928 anonymous_children.Add (b);
1929 }
1930
1931 void DoResolveConstants (BlockContext ec)
1932 {
1933 if (constants == null)
1934 return;
1935
1936 if (variables == null)
1937 throw new InternalErrorException ("cannot happen");
1938
1939 foreach (DictionaryEntry de in variables) {
1940 string name = (string) de.Key;
1941 LocalInfo vi = (LocalInfo) de.Value;
1942 Type variable_type = vi.VariableType;
1943
1944 if (variable_type == null) {
1945 if (vi.Type is VarExpr)
1946 ec.Report.Error (822, vi.Type.Location, "An implicitly typed local variable cannot be a constant");
1947
1948 continue;
1949 }
1950
1951 Expression cv = (Expression) constants [name];
1952 if (cv == null)
1953 continue;
1954
1955 // Don't let 'const int Foo = Foo;' succeed.
1956 // Removing the name from 'constants' ensures that we get a LocalVariableReference below,
1957 // which in turn causes the 'must be constant' error to be triggered.
1958 constants.Remove (name);
1959
1960 if (!Const.IsConstantTypeValid (variable_type)) {
1961 Const.Error_InvalidConstantType (variable_type, loc, ec.Report);
1962 continue;
1963 }
1964
1965 ec.CurrentBlock = this;
1966 Expression e;
1967 using (ec.With (ResolveContext.Options.ConstantCheckState, (flags & Flags.Unchecked) == 0)) {
1968 e = cv.Resolve (ec);
1969 }
1970 if (e == null)
1971 continue;
1972
1973 Constant ce = e as Constant;
1974 if (ce == null) {
1975 Const.Error_ExpressionMustBeConstant (vi.Location, name, ec.Report);
1976 continue;
1977 }
1978
1979 e = ce.ConvertImplicitly (variable_type);
1980 if (e == null) {
1981 if (TypeManager.IsReferenceType (variable_type))
1982 Const.Error_ConstantCanBeInitializedWithNullOnly (variable_type, vi.Location, vi.Name, ec.Report);
1983 else
1984 ce.Error_ValueCannotBeConverted (ec, vi.Location, variable_type, false);
1985 continue;
1986 }
1987
1988 constants.Add (name, e);
1989 vi.IsConstant = true;
1990 }
1991 }
1992
1993 protected void ResolveMeta (BlockContext ec, int offset)
1994 {
1995 Report.Debug (64, "BLOCK RESOLVE META", this, Parent);
1996
1997 // If some parent block was unsafe, we remain unsafe even if this block
1998 // isn't explicitly marked as such.
1999 using (ec.With (ResolveContext.Options.UnsafeScope, ec.IsUnsafe | Unsafe)) {
2000 flags |= Flags.VariablesInitialized;
2001
2002 if (variables != null) {
2003 foreach (LocalInfo li in variables.Values) {
2004 if (!li.Resolve (ec))
2005 continue;
2006 li.VariableInfo = new VariableInfo (li, offset);
2007 offset += li.VariableInfo.Length;
2008 }
2009 }
2010 assignable_slots = offset;
2011
2012 DoResolveConstants (ec);
2013
2014 if (children == null)
2015 return;
2016 foreach (Block b in children)
2017 b.ResolveMeta (ec, offset);
2018 }
2019 }
2020
2021 //
2022 // Emits the local variable declarations for a block
2023 //
2024 public virtual void EmitMeta (EmitContext ec)
2025 {
2026 if (variables != null){
2027 foreach (LocalInfo vi in variables.Values)
2028 vi.ResolveVariable (ec);
2029 }
2030
2031 if (temporary_variables != null) {
2032 for (int i = 0; i < temporary_variables.Count; i++)
2033 ((LocalInfo)temporary_variables[i]).ResolveVariable(ec);
2034 }
2035
2036 if (children != null) {
2037 for (int i = 0; i < children.Count; i++)
2038 ((Block)children[i]).EmitMeta(ec);
2039 }
2040 }
2041
2042 void UsageWarning (BlockContext ec)
2043 {
2044 if (variables == null || ec.Report.WarningLevel < 3)
2045 return;
2046
2047 foreach (DictionaryEntry de in variables) {
2048 LocalInfo vi = (LocalInfo) de.Value;
2049
2050 if (!vi.Used) {
2051 string name = (string) de.Key;
2052
2053 // vi.VariableInfo can be null for 'catch' variables
2054 if (vi.VariableInfo != null && vi.VariableInfo.IsEverAssigned)
2055 ec.Report.Warning (219, 3, vi.Location, "The variable `{0}' is assigned but its value is never used", name);
2056 else
2057 ec.Report.Warning (168, 3, vi.Location, "The variable `{0}' is declared but never used", name);
2058 }
2059 }
2060 }
2061
2062 static void CheckPossibleMistakenEmptyStatement (BlockContext ec, Statement s)
2063 {
2064 Statement body;
2065
2066 // Some statements are wrapped by a Block. Since
2067 // others' internal could be changed, here I treat
2068 // them as possibly wrapped by Block equally.
2069 Block b = s as Block;
2070 if (b != null && b.statements.Count == 1)
2071 s = (Statement) b.statements [0];
2072
2073 if (s is Lock)
2074 body = ((Lock) s).Statement;
2075 else if (s is For)
2076 body = ((For) s).Statement;
2077 else if (s is Foreach)
2078 body = ((Foreach) s).Statement;
2079 else if (s is While)
2080 body = ((While) s).Statement;
2081 else if (s is Fixed)
2082 body = ((Fixed) s).Statement;
2083 else if (s is Using)
2084 body = ((Using) s).EmbeddedStatement;
2085 else if (s is UsingTemporary)
2086 body = ((UsingTemporary) s).Statement;
2087 else
2088 return;
2089
2090 if (body == null || body is EmptyStatement)
2091 ec.Report.Warning (642, 3, s.loc, "Possible mistaken empty statement");
2092 }
2093
2094 public override bool Resolve (BlockContext ec)
2095 {
2096 Block prev_block = ec.CurrentBlock;
2097 bool ok = true;
2098
2099 int errors = ec.Report.Errors;
2100
2101 ec.CurrentBlock = this;
2102 ec.StartFlowBranching (this);
2103
2104 Report.Debug (4, "RESOLVE BLOCK", StartLocation, ec.CurrentBranching);
2105
2106 //
2107 // Compiler generated scope statements
2108 //
2109 if (scope_initializers != null) {
2110 foreach (Statement s in scope_initializers)
2111 s.Resolve (ec);
2112 }
2113
2114 //
2115 // This flag is used to notate nested statements as unreachable from the beginning of this block.
2116 // For the purposes of this resolution, it doesn't matter that the whole block is unreachable
2117 // from the beginning of the function. The outer Resolve() that detected the unreachability is
2118 // responsible for handling the situation.
2119 //
2120 int statement_count = statements.Count;
2121 for (int ix = 0; ix < statement_count; ix++){
2122 Statement s = (Statement) statements [ix];
2123 // Check possible empty statement (CS0642)
2124 if (ix + 1 < statement_count && ec.Report.WarningLevel >= 3 &&
2125 statements [ix + 1] is ExplicitBlock)
2126 CheckPossibleMistakenEmptyStatement (ec, s);
2127
2128 //
2129 // Warn if we detect unreachable code.
2130 //
2131 if (unreachable) {
2132 if (s is EmptyStatement)
2133 continue;
2134
2135 if (!unreachable_shown && !(s is LabeledStatement)) {
2136 ec.Report.Warning (162, 2, s.loc, "Unreachable code detected");
2137 unreachable_shown = true;
2138 }
2139
2140 Block c_block = s as Block;
2141 if (c_block != null)
2142 c_block.unreachable = c_block.unreachable_shown = true;
2143 }
2144
2145 //
2146 // Note that we're not using ResolveUnreachable() for unreachable
2147 // statements here. ResolveUnreachable() creates a temporary
2148 // flow branching and kills it afterwards. This leads to problems
2149 // if you have two unreachable statements where the first one
2150 // assigns a variable and the second one tries to access it.
2151 //
2152
2153 if (!s.Resolve (ec)) {
2154 ok = false;
2155 if (ec.IsInProbingMode)
2156 break;
2157
2158 statements [ix] = EmptyStatement.Value;
2159 continue;
2160 }
2161
2162 if (unreachable && !(s is LabeledStatement) && !(s is Block))
2163 statements [ix] = EmptyStatement.Value;
2164
2165 unreachable = ec.CurrentBranching.CurrentUsageVector.IsUnreachable;
2166 if (unreachable && s is LabeledStatement)
2167 throw new InternalErrorException ("should not happen");
2168 }
2169
2170 Report.Debug (4, "RESOLVE BLOCK DONE", StartLocation,
2171 ec.CurrentBranching, statement_count);
2172
2173 while (ec.CurrentBranching is FlowBranchingLabeled)
2174 ec.EndFlowBranching ();
2175
2176 bool flow_unreachable = ec.EndFlowBranching ();
2177
2178 ec.CurrentBlock = prev_block;
2179
2180 if (flow_unreachable)
2181 flags |= Flags.HasRet;
2182
2183 // If we're a non-static `struct' constructor which doesn't have an
2184 // initializer, then we must initialize all of the struct's fields.
2185 if (this == Toplevel && !Toplevel.IsThisAssigned (ec) && !flow_unreachable)
2186 ok = false;
2187
2188 if ((labels != null) && (ec.Report.WarningLevel >= 2)) {
2189 foreach (LabeledStatement label in labels.Values)
2190 if (!label.HasBeenReferenced)
2191 ec.Report.Warning (164, 2, label.loc, "This label has not been referenced");
2192 }
2193
2194 if (ok && errors == ec.Report.Errors)
2195 UsageWarning (ec);
2196
2197 return ok;
2198 }
2199
2200 public override bool ResolveUnreachable (BlockContext ec, bool warn)
2201 {
2202 unreachable_shown = true;
2203 unreachable = true;
2204
2205 if (warn)
2206 ec.Report.Warning (162, 2, loc, "Unreachable code detected");
2207
2208 ec.StartFlowBranching (FlowBranching.BranchingType.Block, loc);
2209 bool ok = Resolve (ec);
2210 ec.KillFlowBranching ();
2211
2212 return ok;
2213 }
2214
2215 protected override void DoEmit (EmitContext ec)
2216 {
2217 for (int ix = 0; ix < statements.Count; ix++){
2218 Statement s = (Statement) statements [ix];
2219 s.Emit (ec);
2220 }
2221 }
2222
2223 public override void Emit (EmitContext ec)
2224 {
2225 if (scope_initializers != null)
2226 EmitScopeInitializers (ec);
2227
2228 ec.Mark (StartLocation);
2229 DoEmit (ec);
2230
2231 if (SymbolWriter.HasSymbolWriter)
2232 EmitSymbolInfo (ec);
2233 }
2234
2235 protected void EmitScopeInitializers (EmitContext ec)
2236 {
2237 SymbolWriter.OpenCompilerGeneratedBlock (ec.ig);
2238
2239 using (ec.With (EmitContext.Options.OmitDebugInfo, true)) {
2240 foreach (Statement s in scope_initializers)
2241 s.Emit (ec);
2242 }
2243
2244 SymbolWriter.CloseCompilerGeneratedBlock (ec.ig);
2245 }
2246
2247 protected virtual void EmitSymbolInfo (EmitContext ec)
2248 {
2249 if (variables != null) {
2250 foreach (LocalInfo vi in variables.Values) {
2251 vi.EmitSymbolInfo (ec);
2252 }
2253 }
2254 }
2255
2256 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
2257 {
2258 MutateVariables (storey);
2259
2260 if (scope_initializers != null) {
2261 foreach (Statement s in scope_initializers)
2262 s.MutateHoistedGenericType (storey);
2263 }
2264
2265 foreach (Statement s in statements)
2266 s.MutateHoistedGenericType (storey);
2267 }
2268
2269 void MutateVariables (AnonymousMethodStorey storey)
2270 {
2271 if (variables != null) {
2272 foreach (LocalInfo vi in variables.Values) {
2273 vi.VariableType = storey.MutateType (vi.VariableType);
2274 }
2275 }
2276
2277 if (temporary_variables != null) {
2278 foreach (LocalInfo vi in temporary_variables)
2279 vi.VariableType = storey.MutateType (vi.VariableType);
2280 }
2281 }
2282
2283 public override string ToString ()
2284 {
2285 return String.Format ("{0} ({1}:{2})", GetType (),ID, StartLocation);
2286 }
2287
2288 protected override void CloneTo (CloneContext clonectx, Statement t)
2289 {
2290 Block target = (Block) t;
2291
2292 clonectx.AddBlockMap (this, target);
2293
2294 //target.Toplevel = (ToplevelBlock) clonectx.LookupBlock (Toplevel);
2295 target.Explicit = (ExplicitBlock) clonectx.LookupBlock (Explicit);
2296 if (Parent != null)
2297 target.Parent = clonectx.RemapBlockCopy (Parent);
2298
2299 if (variables != null){
2300 target.variables = new Hashtable ();
2301
2302 foreach (DictionaryEntry de in variables){
2303 LocalInfo newlocal = ((LocalInfo) de.Value).Clone (clonectx);
2304 target.variables [de.Key] = newlocal;
2305 clonectx.AddVariableMap ((LocalInfo) de.Value, newlocal);
2306 }
2307 }
2308
2309 target.statements = new ArrayList (statements.Count);
2310 foreach (Statement s in statements)
2311 target.statements.Add (s.Clone (clonectx));
2312
2313 if (target.children != null){
2314 target.children = new ArrayList (children.Count);
2315 foreach (Block b in children){
2316 target.children.Add (clonectx.LookupBlock (b));
2317 }
2318 }
2319
2320 //
2321 // TODO: labels, switch_block, constants (?), anonymous_children
2322 //
2323 }
2324 }
2325
2326 public class ExplicitBlock : Block {
2327 HybridDictionary known_variables;
2328 protected AnonymousMethodStorey am_storey;
2329
2330 public ExplicitBlock (Block parent, Location start, Location end)
2331 : this (parent, (Flags) 0, start, end)
2332 {
2333 }
2334
2335 public ExplicitBlock (Block parent, Flags flags, Location start, Location end)
2336 : base (parent, flags, start, end)
2337 {
2338 this.Explicit = this;
2339 }
2340
2341 // <summary>
2342 // Marks a variable with name @name as being used in this or a child block.
2343 // If a variable name has been used in a child block, it's illegal to
2344 // declare a variable with the same name in the current block.
2345 // </summary>
2346 internal void AddKnownVariable (string name, IKnownVariable info)
2347 {
2348 if (known_variables == null)
2349 known_variables = new HybridDictionary();
2350
2351 known_variables [name] = info;
2352
2353 if (Parent != null)
2354 Parent.Explicit.AddKnownVariable (name, info);
2355 }
2356
2357 public AnonymousMethodStorey AnonymousMethodStorey {
2358 get { return am_storey; }
2359 }
2360
2361 //
2362 // Creates anonymous method storey in current block
2363 //
2364 public AnonymousMethodStorey CreateAnonymousMethodStorey (ResolveContext ec)
2365 {
2366 //
2367 // When referencing a variable in iterator storey from children anonymous method
2368 //
2369 if (Toplevel.am_storey is IteratorStorey) {
2370 return Toplevel.am_storey;
2371 }
2372
2373 //
2374 // An iterator has only 1 storey block
2375 //
2376 if (ec.CurrentIterator != null)
2377 return ec.CurrentIterator.Storey;
2378
2379 if (am_storey == null) {
2380 MemberBase mc = ec.MemberContext as MemberBase;
2381 GenericMethod gm = mc == null ? null : mc.GenericMethod;
2382
2383 //
2384 // Creates anonymous method storey for this block
2385 //
2386 am_storey = new AnonymousMethodStorey (this, ec.CurrentTypeDefinition, mc, gm, "AnonStorey");
2387 }
2388
2389 return am_storey;
2390 }
2391
2392 public override void Emit (EmitContext ec)
2393 {
2394 if (am_storey != null)
2395 am_storey.EmitStoreyInstantiation (ec);
2396
2397 bool emit_debug_info = SymbolWriter.HasSymbolWriter && Parent != null && !(am_storey is IteratorStorey);
2398 if (emit_debug_info)
2399 ec.BeginScope ();
2400
2401 base.Emit (ec);
2402
2403 if (emit_debug_info)
2404 ec.EndScope ();
2405 }
2406
2407 public override void EmitMeta (EmitContext ec)
2408 {
2409 //
2410 // Creates anonymous method storey
2411 //
2412 if (am_storey != null) {
2413 if (ec.CurrentAnonymousMethod != null && ec.CurrentAnonymousMethod.Storey != null) {
2414 //
2415 // Creates parent storey reference when hoisted this is accessible
2416 //
2417 if (am_storey.OriginalSourceBlock.Explicit.HasCapturedThis) {
2418 ExplicitBlock parent = Toplevel.Parent.Explicit;
2419
2420 //
2421 // Hoisted this exists in top-level parent storey only
2422 //
2423 while (parent.am_storey == null || parent.am_storey.Parent is AnonymousMethodStorey)
2424 parent = parent.Parent.Explicit;
2425
2426 am_storey.AddParentStoreyReference (parent.am_storey);
2427 }
2428
2429 am_storey.ChangeParentStorey (ec.CurrentAnonymousMethod.Storey);
2430 }
2431
2432 am_storey.DefineType ();
2433 am_storey.ResolveType ();
2434 am_storey.Define ();
2435 am_storey.Parent.PartialContainer.AddCompilerGeneratedClass (am_storey);
2436
2437 ArrayList ref_blocks = am_storey.ReferencesFromChildrenBlock;
2438 if (ref_blocks != null) {
2439 foreach (ExplicitBlock ref_block in ref_blocks) {
2440 for (ExplicitBlock b = ref_block.Explicit; b != this; b = b.Parent.Explicit) {
2441 if (b.am_storey != null) {
2442 b.am_storey.AddParentStoreyReference (am_storey);
2443
2444 // Stop propagation inside same top block
2445 if (b.Toplevel == Toplevel)
2446 break;
2447
2448 b = b.Toplevel;
2449 }
2450 b.HasCapturedVariable = true;
2451 }
2452 }
2453 }
2454 }
2455
2456 base.EmitMeta (ec);
2457 }
2458
2459 internal IKnownVariable GetKnownVariable (string name)
2460 {
2461 return known_variables == null ? null : (IKnownVariable) known_variables [name];
2462 }
2463
2464 public bool HasCapturedThis
2465 {
2466 set { flags = value ? flags | Flags.HasCapturedThis : flags & ~Flags.HasCapturedThis; }
2467 get { return (flags & Flags.HasCapturedThis) != 0; }
2468 }
2469
2470 public bool HasCapturedVariable
2471 {
2472 set { flags = value ? flags | Flags.HasCapturedVariable : flags & ~Flags.HasCapturedVariable; }
2473 get { return (flags & Flags.HasCapturedVariable) != 0; }
2474 }
2475
2476 protected override void CloneTo (CloneContext clonectx, Statement t)
2477 {
2478 ExplicitBlock target = (ExplicitBlock) t;
2479 target.known_variables = null;
2480 base.CloneTo (clonectx, t);
2481 }
2482 }
2483
2484 public class ToplevelParameterInfo : IKnownVariable {
2485 public readonly ToplevelBlock Block;
2486 public readonly int Index;
2487 public VariableInfo VariableInfo;
2488
2489 Block IKnownVariable.Block {
2490 get { return Block; }
2491 }
2492 public Parameter Parameter {
2493 get { return Block.Parameters [Index]; }
2494 }
2495
2496 public Type ParameterType {
2497 get { return Block.Parameters.Types [Index]; }
2498 }
2499
2500 public Location Location {
2501 get { return Parameter.Location; }
2502 }
2503
2504 public ToplevelParameterInfo (ToplevelBlock block, int idx)
2505 {
2506 this.Block = block;
2507 this.Index = idx;
2508 }
2509 }
2510
2511 //
2512 // A toplevel block contains extra information, the split is done
2513 // only to separate information that would otherwise bloat the more
2514 // lightweight Block.
2515 //
2516 // In particular, this was introduced when the support for Anonymous
2517 // Methods was implemented.
2518 //
2519 public class ToplevelBlock : ExplicitBlock
2520 {
2521 //
2522 // Block is converted to an expression
2523 //
2524 sealed class BlockScopeExpression : Expression
2525 {
2526 Expression child;
2527 readonly ToplevelBlock block;
2528
2529 public BlockScopeExpression (Expression child, ToplevelBlock block)
2530 {
2531 this.child = child;
2532 this.block = block;
2533 }
2534
2535 public override Expression CreateExpressionTree (ResolveContext ec)
2536 {
2537 throw new NotSupportedException ();
2538 }
2539
2540 public override Expression DoResolve (ResolveContext ec)
2541 {
2542 if (child == null)
2543 return null;
2544
2545 child = child.Resolve (ec);
2546 if (child == null)
2547 return null;
2548
2549 eclass = child.eclass;
2550 type = child.Type;
2551 return this;
2552 }
2553
2554 public override void Emit (EmitContext ec)
2555 {
2556 block.EmitMeta (ec);
2557 block.EmitScopeInitializers (ec);
2558 child.Emit (ec);
2559 }
2560
2561 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
2562 {
2563 type = storey.MutateType (type);
2564 child.MutateHoistedGenericType (storey);
2565 block.MutateHoistedGenericType (storey);
2566 }
2567 }
2568
2569 GenericMethod generic;
2570 protected ParametersCompiled parameters;
2571 ToplevelParameterInfo[] parameter_info;
2572 LocalInfo this_variable;
2573 bool resolved;
2574 bool unreachable;
2575 CompilerContext compiler;
2576
2577 public HoistedVariable HoistedThisVariable;
2578
2579 public bool Resolved {
2580 get {
2581 return resolved;
2582 }
2583 }
2584
2585 //
2586 // The parameters for the block.
2587 //
2588 public ParametersCompiled Parameters {
2589 get { return parameters; }
2590 }
2591
2592 public Report Report {
2593 get { return compiler.Report; }
2594 }
2595
2596 public GenericMethod GenericMethod {
2597 get { return generic; }
2598 }
2599
2600 public ToplevelBlock Container {
2601 get { return Parent == null ? null : Parent.Toplevel; }
2602 }
2603
2604 public ToplevelBlock (CompilerContext ctx, Block parent, ParametersCompiled parameters, Location start) :
2605 this (ctx, parent, (Flags) 0, parameters, start)
2606 {
2607 }
2608
2609 public ToplevelBlock (CompilerContext ctx, Block parent, ParametersCompiled parameters, GenericMethod generic, Location start) :
2610 this (ctx, parent, parameters, start)
2611 {
2612 this.generic = generic;
2613 }
2614
2615 public ToplevelBlock (CompilerContext ctx, ParametersCompiled parameters, Location start) :
2616 this (ctx, null, (Flags) 0, parameters, start)
2617 {
2618 }
2619
2620 ToplevelBlock (CompilerContext ctx, Flags flags, ParametersCompiled parameters, Location start) :
2621 this (ctx, null, flags, parameters, start)
2622 {
2623 }
2624
2625 // We use 'Parent' to hook up to the containing block, but don't want to register the current block as a child.
2626 // So, we use a two-stage setup -- first pass a null parent to the base constructor, and then override 'Parent'.
2627 public ToplevelBlock (CompilerContext ctx, Block parent, Flags flags, ParametersCompiled parameters, Location start) :
2628 base (null, flags, start, Location.Null)
2629 {
2630 this.compiler = ctx;
2631 this.Toplevel = this;
2632
2633 this.parameters = parameters;
2634 this.Parent = parent;
2635 if (parent != null)
2636 parent.AddAnonymousChild (this);
2637
2638 if (!this.parameters.IsEmpty)
2639 ProcessParameters ();
2640 }
2641
2642 public ToplevelBlock (CompilerContext ctx, Location loc)
2643 : this (ctx, null, (Flags) 0, ParametersCompiled.EmptyReadOnlyParameters, loc)
2644 {
2645 }
2646
2647 protected override void CloneTo (CloneContext clonectx, Statement t)
2648 {
2649 ToplevelBlock target = (ToplevelBlock) t;
2650 base.CloneTo (clonectx, t);
2651
2652 if (parameters.Count != 0)
2653 target.parameter_info = new ToplevelParameterInfo [parameters.Count];
2654 for (int i = 0; i < parameters.Count; ++i)
2655 target.parameter_info [i] = new ToplevelParameterInfo (target, i);
2656 }
2657
2658 public bool CheckError158 (string name, Location loc)
2659 {
2660 if (AnonymousChildren != null) {
2661 foreach (ToplevelBlock child in AnonymousChildren) {
2662 if (!child.CheckError158 (name, loc))
2663 return false;
2664 }
2665 }
2666
2667 for (ToplevelBlock c = Container; c != null; c = c.Container) {
2668 if (!c.DoCheckError158 (name, loc))
2669 return false;
2670 }
2671
2672 return true;
2673 }
2674
2675 void ProcessParameters ()
2676 {
2677 int n = parameters.Count;
2678 parameter_info = new ToplevelParameterInfo [n];
2679 ToplevelBlock top_parent = Parent == null ? null : Parent.Toplevel;
2680 for (int i = 0; i < n; ++i) {
2681 parameter_info [i] = new ToplevelParameterInfo (this, i);
2682
2683 Parameter p = parameters [i];
2684 if (p == null)
2685 continue;
2686
2687 string name = p.Name;
2688 if (CheckParentConflictName (top_parent, name, loc))
2689 AddKnownVariable (name, parameter_info [i]);
2690 }
2691
2692 // mark this block as "used" so that we create local declarations in a sub-block
2693 // FIXME: This appears to uncover a lot of bugs
2694 //this.Use ();
2695 }
2696
2697 bool DoCheckError158 (string name, Location loc)
2698 {
2699 LabeledStatement s = LookupLabel (name);
2700 if (s != null) {
2701 Report.SymbolRelatedToPreviousError (s.loc, s.Name);
2702 Error_158 (name, loc);
2703 return false;
2704 }
2705
2706 return true;
2707 }
2708
2709 public override Expression CreateExpressionTree (ResolveContext ec)
2710 {
2711 if (statements.Count == 1) {
2712 Expression expr = ((Statement) statements[0]).CreateExpressionTree (ec);
2713 if (scope_initializers != null)
2714 expr = new BlockScopeExpression (expr, this);
2715
2716 return expr;
2717 }
2718
2719 return base.CreateExpressionTree (ec);
2720 }
2721
2722 //
2723 // Reformats this block to be top-level iterator block
2724 //
2725 public IteratorStorey ChangeToIterator (Iterator iterator, ToplevelBlock source)
2726 {
2727 IsIterator = true;
2728
2729 // Creates block with original statements
2730 AddStatement (new IteratorStatement (iterator, new Block (this, source)));
2731
2732 source.statements = new ArrayList (1);
2733 source.AddStatement (new Return (iterator, iterator.Location));
2734 source.IsIterator = false;
2735
2736 IteratorStorey iterator_storey = new IteratorStorey (iterator);
2737 source.am_storey = iterator_storey;
2738 return iterator_storey;
2739 }
2740
2741 //
2742 // Returns a parameter reference expression for the given name,
2743 // or null if there is no such parameter
2744 //
2745 public Expression GetParameterReference (string name, Location loc)
2746 {
2747 for (ToplevelBlock t = this; t != null; t = t.Container) {
2748 Expression expr = t.GetParameterReferenceExpression (name, loc);
2749 if (expr != null)
2750 return expr;
2751 }
2752
2753 return null;
2754 }
2755
2756 protected virtual Expression GetParameterReferenceExpression (string name, Location loc)
2757 {
2758 int idx = parameters.GetParameterIndexByName (name);
2759 return idx < 0 ?
2760 null : new ParameterReference (parameter_info [idx], loc);
2761 }
2762
2763 // <summary>
2764 // Returns the "this" instance variable of this block.
2765 // See AddThisVariable() for more information.
2766 // </summary>
2767 public LocalInfo ThisVariable {
2768 get { return this_variable; }
2769 }
2770
2771 // <summary>
2772 // This is used by non-static `struct' constructors which do not have an
2773 // initializer - in this case, the constructor must initialize all of the
2774 // struct's fields. To do this, we add a "this" variable and use the flow
2775 // analysis code to ensure that it's been fully initialized before control
2776 // leaves the constructor.
2777 // </summary>
2778 public LocalInfo AddThisVariable (DeclSpace ds, Location l)
2779 {
2780 if (this_variable == null) {
2781 this_variable = new LocalInfo (ds, this, l);
2782 this_variable.Used = true;
2783 this_variable.IsThis = true;
2784
2785 Variables.Add ("this", this_variable);
2786 }
2787
2788 return this_variable;
2789 }
2790
2791 public bool IsIterator {
2792 get { return (flags & Flags.IsIterator) != 0; }
2793 set { flags = value ? flags | Flags.IsIterator : flags & ~Flags.IsIterator; }
2794 }
2795
2796 public bool IsThisAssigned (BlockContext ec)
2797 {
2798 return this_variable == null || this_variable.IsThisAssigned (ec, this);
2799 }
2800
2801 public bool Resolve (FlowBranching parent, BlockContext rc, ParametersCompiled ip, IMethodData md)
2802 {
2803 if (resolved)
2804 return true;
2805
2806 resolved = true;
2807
2808 try {
2809 if (!ResolveMeta (rc, ip))
2810 return false;
2811
2812 using (rc.With (ResolveContext.Options.DoFlowAnalysis, true)) {
2813 FlowBranchingToplevel top_level = rc.StartFlowBranching (this, parent);
2814
2815 if (!Resolve (rc))
2816 return false;
2817
2818 unreachable = top_level.End ();
2819 }
2820 } catch (Exception) {
2821 #if PRODUCTION
2822 if (rc.CurrentBlock != null) {
2823 ec.Report.Error (584, rc.CurrentBlock.StartLocation, "Internal compiler error: Phase Resolve");
2824 } else {
2825 ec.Report.Error (587, "Internal compiler error: Phase Resolve");
2826 }
2827 #endif
2828 throw;
2829 }
2830
2831 if (rc.ReturnType != TypeManager.void_type && !unreachable) {
2832 if (rc.CurrentAnonymousMethod == null) {
2833 rc.Report.Error (161, md.Location, "`{0}': not all code paths return a value", md.GetSignatureForError ());
2834 return false;
2835 } else if (!rc.CurrentAnonymousMethod.IsIterator) {
2836 rc.Report.Error (1643, rc.CurrentAnonymousMethod.Location, "Not all code paths return a value in anonymous method of type `{0}'",
2837 rc.CurrentAnonymousMethod.GetSignatureForError ());
2838 return false;
2839 }
2840 }
2841
2842 return true;
2843 }
2844
2845 bool ResolveMeta (BlockContext ec, ParametersCompiled ip)
2846 {
2847 int errors = ec.Report.Errors;
2848 int orig_count = parameters.Count;
2849
2850 if (ip != null)
2851 parameters = ip;
2852
2853 // Assert: orig_count != parameter.Count => orig_count == 0
2854 if (orig_count != 0 && orig_count != parameters.Count)
2855 throw new InternalErrorException ("parameter information mismatch");
2856
2857 int offset = Parent == null ? 0 : Parent.AssignableSlots;
2858
2859 for (int i = 0; i < orig_count; ++i) {
2860 Parameter.Modifier mod = parameters.FixedParameters [i].ModFlags;
2861
2862 if ((mod & Parameter.Modifier.OUT) != Parameter.Modifier.OUT)
2863 continue;
2864
2865 VariableInfo vi = new VariableInfo (ip, i, offset);
2866 parameter_info [i].VariableInfo = vi;
2867 offset += vi.Length;
2868 }
2869
2870 ResolveMeta (ec, offset);
2871
2872 return ec.Report.Errors == errors;
2873 }
2874
2875 // <summary>
2876 // Check whether all `out' parameters have been assigned.
2877 // </summary>
2878 public void CheckOutParameters (FlowBranching.UsageVector vector, Location loc)
2879 {
2880 if (vector.IsUnreachable)
2881 return;
2882
2883 int n = parameter_info == null ? 0 : parameter_info.Length;
2884
2885 for (int i = 0; i < n; i++) {
2886 VariableInfo var = parameter_info [i].VariableInfo;
2887
2888 if (var == null)
2889 continue;
2890
2891 if (vector.IsAssigned (var, false))
2892 continue;
2893
2894 Report.Error (177, loc, "The out parameter `{0}' must be assigned to before control leaves the current method",
2895 var.Name);
2896 }
2897 }
2898
2899 public override void Emit (EmitContext ec)
2900 {
2901 if (Report.Errors > 0)
2902 return;
2903
2904 #if PRODUCTION
2905 try {
2906 #endif
2907 EmitMeta (ec);
2908
2909 if (ec.HasReturnLabel)
2910 ec.ReturnLabel = ec.ig.DefineLabel ();
2911
2912 base.Emit (ec);
2913
2914 ec.Mark (EndLocation);
2915
2916 if (ec.HasReturnLabel)
2917 ec.ig.MarkLabel (ec.ReturnLabel);
2918
2919 if (ec.return_value != null) {
2920 ec.ig.Emit (OpCodes.Ldloc, ec.return_value);
2921 ec.ig.Emit (OpCodes.Ret);
2922 } else {
2923 //
2924 // If `HasReturnLabel' is set, then we already emitted a
2925 // jump to the end of the method, so we must emit a `ret'
2926 // there.
2927 //
2928 // Unfortunately, System.Reflection.Emit automatically emits
2929 // a leave to the end of a finally block. This is a problem
2930 // if no code is following the try/finally block since we may
2931 // jump to a point after the end of the method.
2932 // As a workaround, we're always creating a return label in
2933 // this case.
2934 //
2935
2936 if (ec.HasReturnLabel || !unreachable) {
2937 if (ec.ReturnType != TypeManager.void_type)
2938 ec.ig.Emit (OpCodes.Ldloc, ec.TemporaryReturn ());
2939 ec.ig.Emit (OpCodes.Ret);
2940 }
2941 }
2942
2943 #if PRODUCTION
2944 } catch (Exception e){
2945 Console.WriteLine ("Exception caught by the compiler while emitting:");
2946 Console.WriteLine (" Block that caused the problem begin at: " + block.loc);
2947
2948 Console.WriteLine (e.GetType ().FullName + ": " + e.Message);
2949 throw;
2950 }
2951 #endif
2952 }
2953
2954 public override void EmitMeta (EmitContext ec)
2955 {
2956 parameters.ResolveVariable ();
2957
2958 // Avoid declaring an IL variable for this_variable since it is not accessed
2959 // from the generated IL
2960 if (this_variable != null)
2961 Variables.Remove ("this");
2962 base.EmitMeta (ec);
2963 }
2964
2965 protected override void EmitSymbolInfo (EmitContext ec)
2966 {
2967 AnonymousExpression ae = ec.CurrentAnonymousMethod;
2968 if ((ae != null) && (ae.Storey != null))
2969 SymbolWriter.DefineScopeVariable (ae.Storey.ID);
2970
2971 base.EmitSymbolInfo (ec);
2972 }
2973 }
2974
2975 public class SwitchLabel {
2976 Expression label;
2977 object converted;
2978 Location loc;
2979
2980 Label il_label;
2981 bool il_label_set;
2982 Label il_label_code;
2983 bool il_label_code_set;
2984
2985 public static readonly object NullStringCase = new object ();
2986
2987 //
2988 // if expr == null, then it is the default case.
2989 //
2990 public SwitchLabel (Expression expr, Location l)
2991 {
2992 label = expr;
2993 loc = l;
2994 }
2995
2996 public Expression Label {
2997 get {
2998 return label;
2999 }
3000 }
3001
3002 public Location Location {
3003 get { return loc; }
3004 }
3005
3006 public object Converted {
3007 get {
3008 return converted;
3009 }
3010 }
3011
3012 public Label GetILLabel (EmitContext ec)
3013 {
3014 if (!il_label_set){
3015 il_label = ec.ig.DefineLabel ();
3016 il_label_set = true;
3017 }
3018 return il_label;
3019 }
3020
3021 public Label GetILLabelCode (EmitContext ec)
3022 {
3023 if (!il_label_code_set){
3024 il_label_code = ec.ig.DefineLabel ();
3025 il_label_code_set = true;
3026 }
3027 return il_label_code;
3028 }
3029
3030 //
3031 // Resolves the expression, reduces it to a literal if possible
3032 // and then converts it to the requested type.
3033 //
3034 public bool ResolveAndReduce (ResolveContext ec, Type required_type, bool allow_nullable)
3035 {
3036 Expression e = label.Resolve (ec);
3037
3038 if (e == null)
3039 return false;
3040
3041 Constant c = e as Constant;
3042 if (c == null){
3043 ec.Report.Error (150, loc, "A constant value is expected");
3044 return false;
3045 }
3046
3047 if (required_type == TypeManager.string_type && c.GetValue () == null) {
3048 converted = NullStringCase;
3049 return true;
3050 }
3051
3052 if (allow_nullable && c.GetValue () == null) {
3053 converted = NullStringCase;
3054 return true;
3055 }
3056
3057 c = c.ImplicitConversionRequired (ec, required_type, loc);
3058 if (c == null)
3059 return false;
3060
3061 converted = c.GetValue ();
3062 return true;
3063 }
3064
3065 public void Error_AlreadyOccurs (ResolveContext ec, Type switch_type, SwitchLabel collision_with)
3066 {
3067 string label;
3068 if (converted == null)
3069 label = "default";
3070 else if (converted == NullStringCase)
3071 label = "null";
3072 else
3073 label = converted.ToString ();
3074
3075 ec.Report.SymbolRelatedToPreviousError (collision_with.loc, null);
3076 ec.Report.Error (152, loc, "The label `case {0}:' already occurs in this switch statement", label);
3077 }
3078
3079 public SwitchLabel Clone (CloneContext clonectx)
3080 {
3081 return new SwitchLabel (label.Clone (clonectx), loc);
3082 }
3083 }
3084
3085 public class SwitchSection {
3086 // An array of SwitchLabels.
3087 public readonly ArrayList Labels;
3088 public readonly Block Block;
3089
3090 public SwitchSection (ArrayList labels, Block block)
3091 {
3092 Labels = labels;
3093 Block = block;
3094 }
3095
3096 public SwitchSection Clone (CloneContext clonectx)
3097 {
3098 ArrayList cloned_labels = new ArrayList ();
3099
3100 foreach (SwitchLabel sl in cloned_labels)
3101 cloned_labels.Add (sl.Clone (clonectx));
3102
3103 return new SwitchSection (cloned_labels, clonectx.LookupBlock (Block));
3104 }
3105 }
3106
3107 public class Switch : Statement {
3108 public ArrayList Sections;
3109 public Expression Expr;
3110
3111 /// <summary>
3112 /// Maps constants whose type type SwitchType to their SwitchLabels.
3113 /// </summary>
3114 public IDictionary Elements;
3115
3116 /// <summary>
3117 /// The governing switch type
3118 /// </summary>
3119 public Type SwitchType;
3120
3121 //
3122 // Computed
3123 //
3124 Label default_target;
3125 Label null_target;
3126 Expression new_expr;
3127 bool is_constant;
3128 bool has_null_case;
3129 SwitchSection constant_section;
3130 SwitchSection default_section;
3131
3132 ExpressionStatement string_dictionary;
3133 FieldExpr switch_cache_field;
3134 static int unique_counter;
3135
3136 //
3137 // Nullable Types support
3138 //
3139 Nullable.Unwrap unwrap;
3140
3141 protected bool HaveUnwrap {
3142 get { return unwrap != null; }
3143 }
3144
3145 //
3146 // The types allowed to be implicitly cast from
3147 // on the governing type
3148 //
3149 static Type [] allowed_types;
3150
3151 public Switch (Expression e, ArrayList sects, Location l)
3152 {
3153 Expr = e;
3154 Sections = sects;
3155 loc = l;
3156 }
3157
3158 public bool GotDefault {
3159 get {
3160 return default_section != null;
3161 }
3162 }
3163
3164 public Label DefaultTarget {
3165 get {
3166 return default_target;
3167 }
3168 }
3169
3170 //
3171 // Determines the governing type for a switch. The returned
3172 // expression might be the expression from the switch, or an
3173 // expression that includes any potential conversions to the
3174 // integral types or to string.
3175 //
3176 Expression SwitchGoverningType (ResolveContext ec, Expression expr)
3177 {
3178 Type t = expr.Type;
3179
3180 if (t == TypeManager.byte_type ||
3181 t == TypeManager.sbyte_type ||
3182 t == TypeManager.ushort_type ||
3183 t == TypeManager.short_type ||
3184 t == TypeManager.uint32_type ||
3185 t == TypeManager.int32_type ||
3186 t == TypeManager.uint64_type ||
3187 t == TypeManager.int64_type ||
3188 t == TypeManager.char_type ||
3189 t == TypeManager.string_type ||
3190 t == TypeManager.bool_type ||
3191 TypeManager.IsEnumType (t))
3192 return expr;
3193
3194 if (allowed_types == null){
3195 allowed_types = new Type [] {
3196 TypeManager.sbyte_type,
3197 TypeManager.byte_type,
3198 TypeManager.short_type,
3199 TypeManager.ushort_type,
3200 TypeManager.int32_type,
3201 TypeManager.uint32_type,
3202 TypeManager.int64_type,
3203 TypeManager.uint64_type,
3204 TypeManager.char_type,
3205 TypeManager.string_type
3206 };
3207 }
3208
3209 //
3210 // Try to find a *user* defined implicit conversion.
3211 //
3212 // If there is no implicit conversion, or if there are multiple
3213 // conversions, we have to report an error
3214 //
3215 Expression converted = null;
3216 foreach (Type tt in allowed_types){
3217 Expression e;
3218
3219 e = Convert.ImplicitUserConversion (ec, expr, tt, loc);
3220 if (e == null)
3221 continue;
3222
3223 //
3224 // Ignore over-worked ImplicitUserConversions that do
3225 // an implicit conversion in addition to the user conversion.
3226 //
3227 if (!(e is UserCast))
3228 continue;
3229
3230 if (converted != null){
3231 ec.Report.ExtraInformation (loc, "(Ambiguous implicit user defined conversion in previous ");
3232 return null;
3233 }
3234
3235 converted = e;
3236 }
3237 return converted;
3238 }
3239
3240 //
3241 // Performs the basic sanity checks on the switch statement
3242 // (looks for duplicate keys and non-constant expressions).
3243 //
3244 // It also returns a hashtable with the keys that we will later
3245 // use to compute the switch tables
3246 //
3247 bool CheckSwitch (ResolveContext ec)
3248 {
3249 bool error = false;
3250 Elements = Sections.Count > 10 ?
3251 (IDictionary)new Hashtable () :
3252 (IDictionary)new ListDictionary ();
3253
3254 foreach (SwitchSection ss in Sections){
3255 foreach (SwitchLabel sl in ss.Labels){
3256 if (sl.Label == null){
3257 if (default_section != null){
3258 sl.Error_AlreadyOccurs (ec, SwitchType, (SwitchLabel)default_section.Labels [0]);
3259 error = true;
3260 }
3261 default_section = ss;
3262 continue;
3263 }
3264
3265 if (!sl.ResolveAndReduce (ec, SwitchType, HaveUnwrap)) {
3266 error = true;
3267 continue;
3268 }
3269
3270 object key = sl.Converted;
3271 if (key == SwitchLabel.NullStringCase)
3272 has_null_case = true;
3273
3274 try {
3275 Elements.Add (key, sl);
3276 } catch (ArgumentException) {
3277 sl.Error_AlreadyOccurs (ec, SwitchType, (SwitchLabel)Elements [key]);
3278 error = true;
3279 }
3280 }
3281 }
3282 return !error;
3283 }
3284
3285 void EmitObjectInteger (ILGenerator ig, object k)
3286 {
3287 if (k is int)
3288 IntConstant.EmitInt (ig, (int) k);
3289 else if (k is Constant) {
3290 EmitObjectInteger (ig, ((Constant) k).GetValue ());
3291 }
3292 else if (k is uint)
3293 IntConstant.EmitInt (ig, unchecked ((int) (uint) k));
3294 else if (k is long)
3295 {
3296 if ((long) k >= int.MinValue && (long) k <= int.MaxValue)
3297 {
3298 IntConstant.EmitInt (ig, (int) (long) k);
3299 ig.Emit (OpCodes.Conv_I8);
3300 }
3301 else
3302 LongConstant.EmitLong (ig, (long) k);
3303 }
3304 else if (k is ulong)
3305 {
3306 ulong ul = (ulong) k;
3307 if (ul < (1L<<32))
3308 {
3309 IntConstant.EmitInt (ig, unchecked ((int) ul));
3310 ig.Emit (OpCodes.Conv_U8);
3311 }
3312 else
3313 {
3314 LongConstant.EmitLong (ig, unchecked ((long) ul));
3315 }
3316 }
3317 else if (k is char)
3318 IntConstant.EmitInt (ig, (int) ((char) k));
3319 else if (k is sbyte)
3320 IntConstant.EmitInt (ig, (int) ((sbyte) k));
3321 else if (k is byte)
3322 IntConstant.EmitInt (ig, (int) ((byte) k));
3323 else if (k is short)
3324 IntConstant.EmitInt (ig, (int) ((short) k));
3325 else if (k is ushort)
3326 IntConstant.EmitInt (ig, (int) ((ushort) k));
3327 else if (k is bool)
3328 IntConstant.EmitInt (ig, ((bool) k) ? 1 : 0);
3329 else
3330 throw new Exception ("Unhandled case");
3331 }
3332
3333 // structure used to hold blocks of keys while calculating table switch
3334 class KeyBlock : IComparable
3335 {
3336 public KeyBlock (long _first)
3337 {
3338 first = last = _first;
3339 }
3340 public long first;
3341 public long last;
3342 public ArrayList element_keys = null;
3343 // how many items are in the bucket
3344 public int Size = 1;
3345 public int Length
3346 {
3347 get { return (int) (last - first + 1); }
3348 }
3349 public static long TotalLength (KeyBlock kb_first, KeyBlock kb_last)
3350 {
3351 return kb_last.last - kb_first.first + 1;
3352 }
3353 public int CompareTo (object obj)
3354 {
3355 KeyBlock kb = (KeyBlock) obj;
3356 int nLength = Length;
3357 int nLengthOther = kb.Length;
3358 if (nLengthOther == nLength)
3359 return (int) (kb.first - first);
3360 return nLength - nLengthOther;
3361 }
3362 }
3363
3364 /// <summary>
3365 /// This method emits code for a lookup-based switch statement (non-string)
3366 /// Basically it groups the cases into blocks that are at least half full,
3367 /// and then spits out individual lookup opcodes for each block.
3368 /// It emits the longest blocks first, and short blocks are just
3369 /// handled with direct compares.
3370 /// </summary>
3371 /// <param name="ec"></param>
3372 /// <param name="val"></param>
3373 /// <returns></returns>
3374 void TableSwitchEmit (EmitContext ec, Expression val)
3375 {
3376 int element_count = Elements.Count;
3377 object [] element_keys = new object [element_count];
3378 Elements.Keys.CopyTo (element_keys, 0);
3379 Array.Sort (element_keys);
3380
3381 // initialize the block list with one element per key
3382 ArrayList key_blocks = new ArrayList (element_count);
3383 foreach (object key in element_keys)
3384 key_blocks.Add (new KeyBlock (System.Convert.ToInt64 (key)));
3385
3386 KeyBlock current_kb;
3387 // iteratively merge the blocks while they are at least half full
3388 // there's probably a really cool way to do this with a tree...
3389 while (key_blocks.Count > 1)
3390 {
3391 ArrayList key_blocks_new = new ArrayList ();
3392 current_kb = (KeyBlock) key_blocks [0];
3393 for (int ikb = 1; ikb < key_blocks.Count; ikb++)
3394 {
3395 KeyBlock kb = (KeyBlock) key_blocks [ikb];
3396 if ((current_kb.Size + kb.Size) * 2 >= KeyBlock.TotalLength (current_kb, kb))
3397 {
3398 // merge blocks
3399 current_kb.last = kb.last;
3400 current_kb.Size += kb.Size;
3401 }
3402 else
3403 {
3404 // start a new block
3405 key_blocks_new.Add (current_kb);
3406 current_kb = kb;
3407 }
3408 }
3409 key_blocks_new.Add (current_kb);
3410 if (key_blocks.Count == key_blocks_new.Count)
3411 break;
3412 key_blocks = key_blocks_new;
3413 }
3414
3415 // initialize the key lists
3416 foreach (KeyBlock kb in key_blocks)
3417 kb.element_keys = new ArrayList ();
3418
3419 // fill the key lists
3420 int iBlockCurr = 0;
3421 if (key_blocks.Count > 0) {
3422 current_kb = (KeyBlock) key_blocks [0];
3423 foreach (object key in element_keys)
3424 {
3425 bool next_block = (key is UInt64) ? (ulong) key > (ulong) current_kb.last :
3426 System.Convert.ToInt64 (key) > current_kb.last;
3427 if (next_block)
3428 current_kb = (KeyBlock) key_blocks [++iBlockCurr];
3429 current_kb.element_keys.Add (key);
3430 }
3431 }
3432
3433 // sort the blocks so we can tackle the largest ones first
3434 key_blocks.Sort ();
3435
3436 // okay now we can start...
3437 ILGenerator ig = ec.ig;
3438 Label lbl_end = ig.DefineLabel (); // at the end ;-)
3439 Label lbl_default = default_target;
3440
3441 Type type_keys = null;
3442 if (element_keys.Length > 0)
3443 type_keys = element_keys [0].GetType (); // used for conversions
3444
3445 Type compare_type;
3446
3447 if (TypeManager.IsEnumType (SwitchType))
3448 compare_type = TypeManager.GetEnumUnderlyingType (SwitchType);
3449 else
3450 compare_type = SwitchType;
3451
3452 for (int iBlock = key_blocks.Count - 1; iBlock >= 0; --iBlock)
3453 {
3454 KeyBlock kb = ((KeyBlock) key_blocks [iBlock]);
3455 lbl_default = (iBlock == 0) ? default_target : ig.DefineLabel ();
3456 if (kb.Length <= 2)
3457 {
3458 foreach (object key in kb.element_keys) {
3459 SwitchLabel sl = (SwitchLabel) Elements [key];
3460 if (key is int && (int) key == 0) {
3461 val.EmitBranchable (ec, sl.GetILLabel (ec), false);
3462 } else {
3463 val.Emit (ec);
3464 EmitObjectInteger (ig, key);
3465 ig.Emit (OpCodes.Beq, sl.GetILLabel (ec));
3466 }
3467 }
3468 }
3469 else
3470 {
3471 // TODO: if all the keys in the block are the same and there are
3472 // no gaps/defaults then just use a range-check.
3473 if (compare_type == TypeManager.int64_type ||
3474 compare_type == TypeManager.uint64_type)
3475 {
3476 // TODO: optimize constant/I4 cases
3477
3478 // check block range (could be > 2^31)
3479 val.Emit (ec);
3480 EmitObjectInteger (ig, System.Convert.ChangeType (kb.first, type_keys));
3481 ig.Emit (OpCodes.Blt, lbl_default);
3482 val.Emit (ec);
3483 EmitObjectInteger (ig, System.Convert.ChangeType (kb.last, type_keys));
3484 ig.Emit (OpCodes.Bgt, lbl_default);
3485
3486 // normalize range
3487 val.Emit (ec);
3488 if (kb.first != 0)
3489 {
3490 EmitObjectInteger (ig, System.Convert.ChangeType (kb.first, type_keys));
3491 ig.Emit (OpCodes.Sub);
3492 }
3493 ig.Emit (OpCodes.Conv_I4); // assumes < 2^31 labels!
3494 }
3495 else
3496 {
3497 // normalize range
3498 val.Emit (ec);
3499 int first = (int) kb.first;
3500 if (first > 0)
3501 {
3502 IntConstant.EmitInt (ig, first);
3503 ig.Emit (OpCodes.Sub);
3504 }
3505 else if (first < 0)
3506 {
3507 IntConstant.EmitInt (ig, -first);
3508 ig.Emit (OpCodes.Add);
3509 }
3510 }
3511
3512 // first, build the list of labels for the switch
3513 int iKey = 0;
3514 int cJumps = kb.Length;
3515 Label [] switch_labels = new Label [cJumps];
3516 for (int iJump = 0; iJump < cJumps; iJump++)
3517 {
3518 object key = kb.element_keys [iKey];
3519 if (System.Convert.ToInt64 (key) == kb.first + iJump)
3520 {
3521 SwitchLabel sl = (SwitchLabel) Elements [key];
3522 switch_labels [iJump] = sl.GetILLabel (ec);
3523 iKey++;
3524 }
3525 else
3526 switch_labels [iJump] = lbl_default;
3527 }
3528 // emit the switch opcode
3529 ig.Emit (OpCodes.Switch, switch_labels);
3530 }
3531
3532 // mark the default for this block
3533 if (iBlock != 0)
3534 ig.MarkLabel (lbl_default);
3535 }
3536
3537 // TODO: find the default case and emit it here,
3538 // to prevent having to do the following jump.
3539 // make sure to mark other labels in the default section
3540
3541 // the last default just goes to the end
3542 if (element_keys.Length > 0)
3543 ig.Emit (OpCodes.Br, lbl_default);
3544
3545 // now emit the code for the sections
3546 bool found_default = false;
3547
3548 foreach (SwitchSection ss in Sections) {
3549 foreach (SwitchLabel sl in ss.Labels) {
3550 if (sl.Converted == SwitchLabel.NullStringCase) {
3551 ig.MarkLabel (null_target);
3552 } else if (sl.Label == null) {
3553 ig.MarkLabel (lbl_default);
3554 found_default = true;
3555 if (!has_null_case)
3556 ig.MarkLabel (null_target);
3557 }
3558 ig.MarkLabel (sl.GetILLabel (ec));
3559 ig.MarkLabel (sl.GetILLabelCode (ec));
3560 }
3561 ss.Block.Emit (ec);
3562 }
3563
3564 if (!found_default) {
3565 ig.MarkLabel (lbl_default);
3566 if (!has_null_case) {
3567 ig.MarkLabel (null_target);
3568 }
3569 }
3570
3571 ig.MarkLabel (lbl_end);
3572 }
3573
3574 SwitchSection FindSection (SwitchLabel label)
3575 {
3576 foreach (SwitchSection ss in Sections){
3577 foreach (SwitchLabel sl in ss.Labels){
3578 if (label == sl)
3579 return ss;
3580 }
3581 }
3582
3583 return null;
3584 }
3585
3586 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
3587 {
3588 foreach (SwitchSection ss in Sections)
3589 ss.Block.MutateHoistedGenericType (storey);
3590 }
3591
3592 public static void Reset ()
3593 {
3594 unique_counter = 0;
3595 allowed_types = null;
3596 }
3597
3598 public override bool Resolve (BlockContext ec)
3599 {
3600 Expr = Expr.Resolve (ec);
3601 if (Expr == null)
3602 return false;
3603
3604 new_expr = SwitchGoverningType (ec, Expr);
3605
3606 if ((new_expr == null) && TypeManager.IsNullableType (Expr.Type)) {
3607 unwrap = Nullable.Unwrap.Create (Expr, false);
3608 if (unwrap == null)
3609 return false;
3610
3611 new_expr = SwitchGoverningType (ec, unwrap);
3612 }
3613
3614 if (new_expr == null){
3615 ec.Report.Error (151, loc,
3616 "A switch expression of type `{0}' cannot be converted to an integral type, bool, char, string, enum or nullable type",
3617 TypeManager.CSharpName (Expr.Type));
3618 return false;
3619 }
3620
3621 // Validate switch.
3622 SwitchType = new_expr.Type;
3623
3624 if (RootContext.Version == LanguageVersion.ISO_1 && SwitchType == TypeManager.bool_type) {
3625 ec.Report.FeatureIsNotAvailable (loc, "switch expression of boolean type");
3626 return false;
3627 }
3628
3629 if (!CheckSwitch (ec))
3630 return false;
3631
3632 if (HaveUnwrap)
3633 Elements.Remove (SwitchLabel.NullStringCase);
3634
3635 Switch old_switch = ec.Switch;
3636 ec.Switch = this;
3637 ec.Switch.SwitchType = SwitchType;
3638
3639 Report.Debug (1, "START OF SWITCH BLOCK", loc, ec.CurrentBranching);
3640 ec.StartFlowBranching (FlowBranching.BranchingType.Switch, loc);
3641
3642 is_constant = new_expr is Constant;
3643 if (is_constant) {
3644 object key = ((Constant) new_expr).GetValue ();
3645 SwitchLabel label = (SwitchLabel) Elements [key];
3646
3647 constant_section = FindSection (label);
3648 if (constant_section == null)
3649 constant_section = default_section;
3650 }
3651
3652 bool first = true;
3653 bool ok = true;
3654 foreach (SwitchSection ss in Sections){
3655 if (!first)
3656 ec.CurrentBranching.CreateSibling (
3657 null, FlowBranching.SiblingType.SwitchSection);
3658 else
3659 first = false;
3660
3661 if (is_constant && (ss != constant_section)) {
3662 // If we're a constant switch, we're only emitting
3663 // one single section - mark all the others as
3664 // unreachable.
3665 ec.CurrentBranching.CurrentUsageVector.Goto ();
3666 if (!ss.Block.ResolveUnreachable (ec, true)) {
3667 ok = false;
3668 }
3669 } else {
3670 if (!ss.Block.Resolve (ec))
3671 ok = false;
3672 }
3673 }
3674
3675 if (default_section == null)
3676 ec.CurrentBranching.CreateSibling (
3677 null, FlowBranching.SiblingType.SwitchSection);
3678
3679 ec.EndFlowBranching ();
3680 ec.Switch = old_switch;
3681
3682 Report.Debug (1, "END OF SWITCH BLOCK", loc, ec.CurrentBranching);
3683
3684 if (!ok)
3685 return false;
3686
3687 if (SwitchType == TypeManager.string_type && !is_constant) {
3688 // TODO: Optimize single case, and single+default case
3689 ResolveStringSwitchMap (ec);
3690 }
3691
3692 return true;
3693 }
3694
3695 void ResolveStringSwitchMap (ResolveContext ec)
3696 {
3697 FullNamedExpression string_dictionary_type;
3698 if (TypeManager.generic_ienumerable_type != null) {
3699 MemberAccess system_collections_generic = new MemberAccess (new MemberAccess (
3700 new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Collections", loc), "Generic", loc);
3701
3702 string_dictionary_type = new MemberAccess (system_collections_generic, "Dictionary",
3703 new TypeArguments (
3704 new TypeExpression (TypeManager.string_type, loc),
3705 new TypeExpression (TypeManager.int32_type, loc)), loc);
3706 } else {
3707 MemberAccess system_collections_generic = new MemberAccess (
3708 new QualifiedAliasMember (QualifiedAliasMember.GlobalAlias, "System", loc), "Collections", loc);
3709
3710 string_dictionary_type = new MemberAccess (system_collections_generic, "Hashtable", loc);
3711 }
3712
3713 Field field = new Field (ec.CurrentTypeDefinition, string_dictionary_type,
3714 Modifiers.STATIC | Modifiers.PRIVATE | Modifiers.COMPILER_GENERATED,
3715 new MemberName (CompilerGeneratedClass.MakeName (null, "f", "switch$map", unique_counter++), loc), null);
3716 if (!field.Define ())
3717 return;
3718 ec.CurrentTypeDefinition.PartialContainer.AddField (field);
3719
3720 ArrayList init = new ArrayList ();
3721 int counter = 0;
3722 Elements.Clear ();
3723 string value = null;
3724 foreach (SwitchSection section in Sections) {
3725 int last_count = init.Count;
3726 foreach (SwitchLabel sl in section.Labels) {
3727 if (sl.Label == null || sl.Converted == SwitchLabel.NullStringCase)
3728 continue;
3729
3730 value = (string) sl.Converted;
3731 ArrayList init_args = new ArrayList (2);
3732 init_args.Add (new StringLiteral (value, sl.Location));
3733 init_args.Add (new IntConstant (counter, loc));
3734 init.Add (new CollectionElementInitializer (init_args, loc));
3735 }
3736
3737 //
3738 // Don't add empty sections
3739 //
3740 if (last_count == init.Count)
3741 continue;
3742
3743 Elements.Add (counter, section.Labels [0]);
3744 ++counter;
3745 }
3746
3747 Arguments args = new Arguments (1);
3748 args.Add (new Argument (new IntConstant (init.Count, loc)));
3749 Expression initializer = new NewInitialize (string_dictionary_type, args,
3750 new CollectionOrObjectInitializers (init, loc), loc);
3751
3752 switch_cache_field = new FieldExpr (field.FieldBuilder, loc);
3753 string_dictionary = new SimpleAssign (switch_cache_field, initializer.Resolve (ec));
3754 }
3755
3756 void DoEmitStringSwitch (LocalTemporary value, EmitContext ec)
3757 {
3758 ILGenerator ig = ec.ig;
3759 Label l_initialized = ig.DefineLabel ();
3760
3761 //
3762 // Skip initialization when value is null
3763 //
3764 value.EmitBranchable (ec, null_target, false);
3765
3766 //
3767 // Check if string dictionary is initialized and initialize
3768 //
3769 switch_cache_field.EmitBranchable (ec, l_initialized, true);
3770 string_dictionary.EmitStatement (ec);
3771 ig.MarkLabel (l_initialized);
3772
3773 LocalTemporary string_switch_variable = new LocalTemporary (TypeManager.int32_type);
3774
3775 ResolveContext rc = new ResolveContext (ec.MemberContext);
3776
3777 if (TypeManager.generic_ienumerable_type != null) {
3778 Arguments get_value_args = new Arguments (2);
3779 get_value_args.Add (new Argument (value));
3780 get_value_args.Add (new Argument (string_switch_variable, Argument.AType.Out));
3781 Expression get_item = new Invocation (new MemberAccess (switch_cache_field, "TryGetValue", loc), get_value_args).Resolve (rc);
3782 if (get_item == null)
3783 return;
3784
3785 //
3786 // A value was not found, go to default case
3787 //
3788 get_item.EmitBranchable (ec, default_target, false);
3789 } else {
3790 Arguments get_value_args = new Arguments (1);
3791 get_value_args.Add (new Argument (value));
3792
3793 Expression get_item = new IndexerAccess (new ElementAccess (switch_cache_field, get_value_args), loc).Resolve (rc);
3794 if (get_item == null)
3795 return;
3796
3797 LocalTemporary get_item_object = new LocalTemporary (TypeManager.object_type);
3798 get_item_object.EmitAssign (ec, get_item, true, false);
3799 ec.ig.Emit (OpCodes.Brfalse, default_target);
3800
3801 ExpressionStatement get_item_int = (ExpressionStatement) new SimpleAssign (string_switch_variable,
3802 new Cast (new TypeExpression (TypeManager.int32_type, loc), get_item_object, loc)).Resolve (rc);
3803
3804 get_item_int.EmitStatement (ec);
3805 get_item_object.Release (ec);
3806 }
3807
3808 TableSwitchEmit (ec, string_switch_variable);
3809 string_switch_variable.Release (ec);
3810 }
3811
3812 protected override void DoEmit (EmitContext ec)
3813 {
3814 ILGenerator ig = ec.ig;
3815
3816 default_target = ig.DefineLabel ();
3817 null_target = ig.DefineLabel ();
3818
3819 // Store variable for comparission purposes
3820 // TODO: Don't duplicate non-captured VariableReference
3821 LocalTemporary value;
3822 if (HaveUnwrap) {
3823 value = new LocalTemporary (SwitchType);
3824 unwrap.EmitCheck (ec);
3825 ig.Emit (OpCodes.Brfalse, null_target);
3826 new_expr.Emit (ec);
3827 value.Store (ec);
3828 } else if (!is_constant) {
3829 value = new LocalTemporary (SwitchType);
3830 new_expr.Emit (ec);
3831 value.Store (ec);
3832 } else
3833 value = null;
3834
3835 //
3836 // Setup the codegen context
3837 //
3838 Label old_end = ec.LoopEnd;
3839 Switch old_switch = ec.Switch;
3840
3841 ec.LoopEnd = ig.DefineLabel ();
3842 ec.Switch = this;
3843
3844 // Emit Code.
3845 if (is_constant) {
3846 if (constant_section != null)
3847 constant_section.Block.Emit (ec);
3848 } else if (string_dictionary != null) {
3849 DoEmitStringSwitch (value, ec);
3850 } else {
3851 TableSwitchEmit (ec, value);
3852 }
3853
3854 if (value != null)
3855 value.Release (ec);
3856
3857 // Restore context state.
3858 ig.MarkLabel (ec.LoopEnd);
3859
3860 //
3861 // Restore the previous context
3862 //
3863 ec.LoopEnd = old_end;
3864 ec.Switch = old_switch;
3865 }
3866
3867 protected override void CloneTo (CloneContext clonectx, Statement t)
3868 {
3869 Switch target = (Switch) t;
3870
3871 target.Expr = Expr.Clone (clonectx);
3872 target.Sections = new ArrayList ();
3873 foreach (SwitchSection ss in Sections){
3874 target.Sections.Add (ss.Clone (clonectx));
3875 }
3876 }
3877 }
3878
3879 // A place where execution can restart in an iterator
3880 public abstract class ResumableStatement : Statement
3881 {
3882 bool prepared;
3883 protected Label resume_point;
3884
3885 public Label PrepareForEmit (EmitContext ec)
3886 {
3887 if (!prepared) {
3888 prepared = true;
3889 resume_point = ec.ig.DefineLabel ();
3890 }
3891 return resume_point;
3892 }
3893
3894 public virtual Label PrepareForDispose (EmitContext ec, Label end)
3895 {
3896 return end;
3897 }
3898 public virtual void EmitForDispose (EmitContext ec, Iterator iterator, Label end, bool have_dispatcher)
3899 {
3900 }
3901 }
3902
3903 // Base class for statements that are implemented in terms of try...finally
3904 public abstract class ExceptionStatement : ResumableStatement
3905 {
3906 bool code_follows;
3907 Iterator iter;
3908
3909 protected abstract void EmitPreTryBody (EmitContext ec);
3910 protected abstract void EmitTryBody (EmitContext ec);
3911 protected abstract void EmitFinallyBody (EmitContext ec);
3912
3913 protected sealed override void DoEmit (EmitContext ec)
3914 {
3915 ILGenerator ig = ec.ig;
3916
3917 EmitPreTryBody (ec);
3918
3919 if (resume_points != null) {
3920 IntConstant.EmitInt (ig, (int) Iterator.State.Running);
3921 ig.Emit (OpCodes.Stloc, iter.CurrentPC);
3922 }
3923
3924 ig.BeginExceptionBlock ();
3925
3926 if (resume_points != null) {
3927 ig.MarkLabel (resume_point);
3928
3929 // For normal control flow, we want to fall-through the Switch
3930 // So, we use CurrentPC rather than the $PC field, and initialize it to an outside value above
3931 ig.Emit (OpCodes.Ldloc, iter.CurrentPC);
3932 IntConstant.EmitInt (ig, first_resume_pc);
3933 ig.Emit (OpCodes.Sub);
3934
3935 Label [] labels = new Label [resume_points.Count];
3936 for (int i = 0; i < resume_points.Count; ++i)
3937 labels [i] = ((ResumableStatement) resume_points [i]).PrepareForEmit (ec);
3938 ig.Emit (OpCodes.Switch, labels);
3939 }
3940
3941 EmitTryBody (ec);
3942
3943 ig.BeginFinallyBlock ();
3944
3945 Label start_finally = ec.ig.DefineLabel ();
3946 if (resume_points != null) {
3947 ig.Emit (OpCodes.Ldloc, iter.SkipFinally);
3948 ig.Emit (OpCodes.Brfalse_S, start_finally);
3949 ig.Emit (OpCodes.Endfinally);
3950 }
3951
3952 ig.MarkLabel (start_finally);
3953 EmitFinallyBody (ec);
3954
3955 ig.EndExceptionBlock ();
3956 }
3957
3958 public void SomeCodeFollows ()
3959 {
3960 code_follows = true;
3961 }
3962
3963 public override bool Resolve (BlockContext ec)
3964 {
3965 // System.Reflection.Emit automatically emits a 'leave' at the end of a try clause
3966 // So, ensure there's some IL code after this statement.
3967 if (!code_follows && resume_points == null && ec.CurrentBranching.CurrentUsageVector.IsUnreachable)
3968 ec.NeedReturnLabel ();
3969
3970 iter = ec.CurrentIterator;
3971 return true;
3972 }
3973
3974 ArrayList resume_points;
3975 int first_resume_pc;
3976 public void AddResumePoint (ResumableStatement stmt, int pc)
3977 {
3978 if (resume_points == null) {
3979 resume_points = new ArrayList ();
3980 first_resume_pc = pc;
3981 }
3982
3983 if (pc != first_resume_pc + resume_points.Count)
3984 throw new InternalErrorException ("missed an intervening AddResumePoint?");
3985
3986 resume_points.Add (stmt);
3987 }
3988
3989 Label dispose_try_block;
3990 bool prepared_for_dispose, emitted_dispose;
3991 public override Label PrepareForDispose (EmitContext ec, Label end)
3992 {
3993 if (!prepared_for_dispose) {
3994 prepared_for_dispose = true;
3995 dispose_try_block = ec.ig.DefineLabel ();
3996 }
3997 return dispose_try_block;
3998 }
3999
4000 public override void EmitForDispose (EmitContext ec, Iterator iterator, Label end, bool have_dispatcher)
4001 {
4002 if (emitted_dispose)
4003 return;
4004
4005 emitted_dispose = true;
4006
4007 ILGenerator ig = ec.ig;
4008
4009 Label end_of_try = ig.DefineLabel ();
4010
4011 // Ensure that the only way we can get into this code is through a dispatcher
4012 if (have_dispatcher)
4013 ig.Emit (OpCodes.Br, end);
4014
4015 ig.BeginExceptionBlock ();
4016
4017 ig.MarkLabel (dispose_try_block);
4018
4019 Label [] labels = null;
4020 for (int i = 0; i < resume_points.Count; ++i) {
4021 ResumableStatement s = (ResumableStatement) resume_points [i];
4022 Label ret = s.PrepareForDispose (ec, end_of_try);
4023 if (ret.Equals (end_of_try) && labels == null)
4024 continue;
4025 if (labels == null) {
4026 labels = new Label [resume_points.Count];
4027 for (int j = 0; j < i; ++j)
4028 labels [j] = end_of_try;
4029 }
4030 labels [i] = ret;
4031 }
4032
4033 if (labels != null) {
4034 int j;
4035 for (j = 1; j < labels.Length; ++j)
4036 if (!labels [0].Equals (labels [j]))
4037 break;
4038 bool emit_dispatcher = j < labels.Length;
4039
4040 if (emit_dispatcher) {
4041 //SymbolWriter.StartIteratorDispatcher (ec.ig);
4042 ig.Emit (OpCodes.Ldloc, iterator.CurrentPC);
4043 IntConstant.EmitInt (ig, first_resume_pc);
4044 ig.Emit (OpCodes.Sub);
4045 ig.Emit (OpCodes.Switch, labels);
4046 //SymbolWriter.EndIteratorDispatcher (ec.ig);
4047 }
4048
4049 foreach (ResumableStatement s in resume_points)
4050 s.EmitForDispose (ec, iterator, end_of_try, emit_dispatcher);
4051 }
4052
4053 ig.MarkLabel (end_of_try);
4054
4055 ig.BeginFinallyBlock ();
4056
4057 EmitFinallyBody (ec);
4058
4059 ig.EndExceptionBlock ();
4060 }
4061 }
4062
4063 public class Lock : ExceptionStatement {
4064 Expression expr;
4065 public Statement Statement;
4066 TemporaryVariable temp;
4067
4068 public Lock (Expression expr, Statement stmt, Location l)
4069 {
4070 this.expr = expr;
4071 Statement = stmt;
4072 loc = l;
4073 }
4074
4075 public override bool Resolve (BlockContext ec)
4076 {
4077 expr = expr.Resolve (ec);
4078 if (expr == null)
4079 return false;
4080
4081 if (!TypeManager.IsReferenceType (expr.Type)){
4082 ec.Report.Error (185, loc,
4083 "`{0}' is not a reference type as required by the lock statement",
4084 TypeManager.CSharpName (expr.Type));
4085 return false;
4086 }
4087
4088 ec.StartFlowBranching (this);
4089 bool ok = Statement.Resolve (ec);
4090 ec.EndFlowBranching ();
4091
4092 ok &= base.Resolve (ec);
4093
4094 // Avoid creating libraries that reference the internal
4095 // mcs NullType:
4096 Type t = expr.Type;
4097 if (t == TypeManager.null_type)
4098 t = TypeManager.object_type;
4099
4100 temp = new TemporaryVariable (t, loc);
4101 temp.Resolve (ec);
4102
4103 if (TypeManager.void_monitor_enter_object == null || TypeManager.void_monitor_exit_object == null) {
4104 Type monitor_type = TypeManager.CoreLookupType (ec.Compiler, "System.Threading", "Monitor", Kind.Class, true);
4105 TypeManager.void_monitor_enter_object = TypeManager.GetPredefinedMethod (
4106 monitor_type, "Enter", loc, TypeManager.object_type);
4107 TypeManager.void_monitor_exit_object = TypeManager.GetPredefinedMethod (
4108 monitor_type, "Exit", loc, TypeManager.object_type);
4109 }
4110
4111 return ok;
4112 }
4113
4114 protected override void EmitPreTryBody (EmitContext ec)
4115 {
4116 ILGenerator ig = ec.ig;
4117
4118 temp.EmitAssign (ec, expr);
4119 temp.Emit (ec);
4120 ig.Emit (OpCodes.Call, TypeManager.void_monitor_enter_object);
4121 }
4122
4123 protected override void EmitTryBody (EmitContext ec)
4124 {
4125 Statement.Emit (ec);
4126 }
4127
4128 protected override void EmitFinallyBody (EmitContext ec)
4129 {
4130 temp.Emit (ec);
4131 ec.ig.Emit (OpCodes.Call, TypeManager.void_monitor_exit_object);
4132 }
4133
4134 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4135 {
4136 expr.MutateHoistedGenericType (storey);
4137 temp.MutateHoistedGenericType (storey);
4138 Statement.MutateHoistedGenericType (storey);
4139 }
4140
4141 protected override void CloneTo (CloneContext clonectx, Statement t)
4142 {
4143 Lock target = (Lock) t;
4144
4145 target.expr = expr.Clone (clonectx);
4146 target.Statement = Statement.Clone (clonectx);
4147 }
4148 }
4149
4150 public class Unchecked : Statement {
4151 public Block Block;
4152
4153 public Unchecked (Block b)
4154 {
4155 Block = b;
4156 b.Unchecked = true;
4157 }
4158
4159 public override bool Resolve (BlockContext ec)
4160 {
4161 using (ec.With (ResolveContext.Options.AllCheckStateFlags, false))
4162 return Block.Resolve (ec);
4163 }
4164
4165 protected override void DoEmit (EmitContext ec)
4166 {
4167 using (ec.With (EmitContext.Options.AllCheckStateFlags, false))
4168 Block.Emit (ec);
4169 }
4170
4171 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4172 {
4173 Block.MutateHoistedGenericType (storey);
4174 }
4175
4176 protected override void CloneTo (CloneContext clonectx, Statement t)
4177 {
4178 Unchecked target = (Unchecked) t;
4179
4180 target.Block = clonectx.LookupBlock (Block);
4181 }
4182 }
4183
4184 public class Checked : Statement {
4185 public Block Block;
4186
4187 public Checked (Block b)
4188 {
4189 Block = b;
4190 b.Unchecked = false;
4191 }
4192
4193 public override bool Resolve (BlockContext ec)
4194 {
4195 using (ec.With (ResolveContext.Options.AllCheckStateFlags, true))
4196 return Block.Resolve (ec);
4197 }
4198
4199 protected override void DoEmit (EmitContext ec)
4200 {
4201 using (ec.With (EmitContext.Options.AllCheckStateFlags, true))
4202 Block.Emit (ec);
4203 }
4204
4205 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4206 {
4207 Block.MutateHoistedGenericType (storey);
4208 }
4209
4210 protected override void CloneTo (CloneContext clonectx, Statement t)
4211 {
4212 Checked target = (Checked) t;
4213
4214 target.Block = clonectx.LookupBlock (Block);
4215 }
4216 }
4217
4218 public class Unsafe : Statement {
4219 public Block Block;
4220
4221 public Unsafe (Block b)
4222 {
4223 Block = b;
4224 Block.Unsafe = true;
4225 loc = b.StartLocation;
4226 }
4227
4228 public override bool Resolve (BlockContext ec)
4229 {
4230 if (ec.CurrentIterator != null)
4231 ec.Report.Error (1629, loc, "Unsafe code may not appear in iterators");
4232
4233 using (ec.Set (ResolveContext.Options.UnsafeScope))
4234 return Block.Resolve (ec);
4235 }
4236
4237 protected override void DoEmit (EmitContext ec)
4238 {
4239 Block.Emit (ec);
4240 }
4241
4242 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4243 {
4244 Block.MutateHoistedGenericType (storey);
4245 }
4246
4247 protected override void CloneTo (CloneContext clonectx, Statement t)
4248 {
4249 Unsafe target = (Unsafe) t;
4250
4251 target.Block = clonectx.LookupBlock (Block);
4252 }
4253 }
4254
4255 //
4256 // Fixed statement
4257 //
4258 public class Fixed : Statement {
4259 Expression type;
4260 ArrayList declarators;
4261 Statement statement;
4262 Type expr_type;
4263 Emitter[] data;
4264 bool has_ret;
4265
4266 abstract class Emitter
4267 {
4268 protected LocalInfo vi;
4269 protected Expression converted;
4270
4271 protected Emitter (Expression expr, LocalInfo li)
4272 {
4273 converted = expr;
4274 vi = li;
4275 }
4276
4277 public abstract void Emit (EmitContext ec);
4278 public abstract void EmitExit (EmitContext ec);
4279 }
4280
4281 class ExpressionEmitter : Emitter {
4282 public ExpressionEmitter (Expression converted, LocalInfo li) :
4283 base (converted, li)
4284 {
4285 }
4286
4287 public override void Emit (EmitContext ec) {
4288 //
4289 // Store pointer in pinned location
4290 //
4291 converted.Emit (ec);
4292 vi.EmitAssign (ec);
4293 }
4294
4295 public override void EmitExit (EmitContext ec)
4296 {
4297 ec.ig.Emit (OpCodes.Ldc_I4_0);
4298 ec.ig.Emit (OpCodes.Conv_U);
4299 vi.EmitAssign (ec);
4300 }
4301 }
4302
4303 class StringEmitter : Emitter
4304 {
4305 LocalInfo pinned_string;
4306
4307 public StringEmitter (Expression expr, LocalInfo li, Location loc):
4308 base (expr, li)
4309 {
4310 pinned_string = new LocalInfo (new TypeExpression (TypeManager.string_type, loc), null, null, loc);
4311 pinned_string.Pinned = true;
4312 }
4313
4314 public StringEmitter Resolve (ResolveContext rc)
4315 {
4316 pinned_string.Resolve (rc);
4317
4318 if (TypeManager.int_get_offset_to_string_data == null) {
4319 TypeManager.int_get_offset_to_string_data = TypeManager.GetPredefinedProperty (
4320 TypeManager.runtime_helpers_type, "OffsetToStringData", pinned_string.Location, TypeManager.int32_type);
4321 }
4322
4323 return this;
4324 }
4325
4326 public override void Emit (EmitContext ec)
4327 {
4328 pinned_string.ResolveVariable (ec);
4329
4330 converted.Emit (ec);
4331 pinned_string.EmitAssign (ec);
4332
4333 // TODO: Should use Binary::Add
4334 pinned_string.Emit (ec);
4335 ec.ig.Emit (OpCodes.Conv_I);
4336
4337 PropertyExpr pe = new PropertyExpr (pinned_string.VariableType, TypeManager.int_get_offset_to_string_data, pinned_string.Location);
4338 //pe.InstanceExpression = pinned_string;
4339 pe.Resolve (new ResolveContext (ec.MemberContext)).Emit (ec);
4340
4341 ec.ig.Emit (OpCodes.Add);
4342 vi.EmitAssign (ec);
4343 }
4344
4345 public override void EmitExit (EmitContext ec)
4346 {
4347 ec.ig.Emit (OpCodes.Ldnull);
4348 pinned_string.EmitAssign (ec);
4349 }
4350 }
4351
4352 public Fixed (Expression type, ArrayList decls, Statement stmt, Location l)
4353 {
4354 this.type = type;
4355 declarators = decls;
4356 statement = stmt;
4357 loc = l;
4358 }
4359
4360 public Statement Statement {
4361 get { return statement; }
4362 }
4363
4364 public override bool Resolve (BlockContext ec)
4365 {
4366 if (!ec.IsUnsafe){
4367 Expression.UnsafeError (ec, loc);
4368 return false;
4369 }
4370
4371 TypeExpr texpr = type.ResolveAsContextualType (ec, false);
4372 if (texpr == null) {
4373 if (type is VarExpr)
4374 ec.Report.Error (821, type.Location, "A fixed statement cannot use an implicitly typed local variable");
4375
4376 return false;
4377 }
4378
4379 expr_type = texpr.Type;
4380
4381 data = new Emitter [declarators.Count];
4382
4383 if (!expr_type.IsPointer){
4384 ec.Report.Error (209, loc, "The type of locals declared in a fixed statement must be a pointer type");
4385 return false;
4386 }
4387
4388 int i = 0;
4389 foreach (Pair p in declarators){
4390 LocalInfo vi = (LocalInfo) p.First;
4391 Expression e = (Expression) p.Second;
4392
4393 vi.VariableInfo.SetAssigned (ec);
4394 vi.SetReadOnlyContext (LocalInfo.ReadOnlyContext.Fixed);
4395
4396 //
4397 // The rules for the possible declarators are pretty wise,
4398 // but the production on the grammar is more concise.
4399 //
4400 // So we have to enforce these rules here.
4401 //
4402 // We do not resolve before doing the case 1 test,
4403 // because the grammar is explicit in that the token &
4404 // is present, so we need to test for this particular case.
4405 //
4406
4407 if (e is Cast){
4408 ec.Report.Error (254, loc, "The right hand side of a fixed statement assignment may not be a cast expression");
4409 return false;
4410 }
4411
4412 using (ec.Set (ResolveContext.Options.FixedInitializerScope)) {
4413 e = e.Resolve (ec);
4414 }
4415
4416 if (e == null)
4417 return false;
4418
4419 //
4420 // Case 2: Array
4421 //
4422 if (e.Type.IsArray){
4423 Type array_type = TypeManager.GetElementType (e.Type);
4424
4425 //
4426 // Provided that array_type is unmanaged,
4427 //
4428 if (!TypeManager.VerifyUnManaged (array_type, loc))
4429 return false;
4430
4431 //
4432 // and T* is implicitly convertible to the
4433 // pointer type given in the fixed statement.
4434 //
4435 ArrayPtr array_ptr = new ArrayPtr (e, array_type, loc);
4436
4437 Expression converted = Convert.ImplicitConversionRequired (
4438 ec, array_ptr, vi.VariableType, loc);
4439 if (converted == null)
4440 return false;
4441
4442 //
4443 // fixed (T* e_ptr = (e == null || e.Length == 0) ? null : converted [0])
4444 //
4445 converted = new Conditional (new BooleanExpression (new Binary (Binary.Operator.LogicalOr,
4446 new Binary (Binary.Operator.Equality, e, new NullLiteral (loc)),
4447 new Binary (Binary.Operator.Equality, new MemberAccess (e, "Length"), new IntConstant (0, loc)))),
4448 new NullPointer (loc),
4449 converted);
4450
4451 converted = converted.Resolve (ec);
4452
4453 data [i] = new ExpressionEmitter (converted, vi);
4454 i++;
4455
4456 continue;
4457 }
4458
4459 //
4460 // Case 3: string
4461 //
4462 if (e.Type == TypeManager.string_type){
4463 data [i] = new StringEmitter (e, vi, loc).Resolve (ec);
4464 i++;
4465 continue;
4466 }
4467
4468 // Case 4: fixed buffer
4469 if (e is FixedBufferPtr) {
4470 data [i++] = new ExpressionEmitter (e, vi);
4471 continue;
4472 }
4473
4474 //
4475 // Case 1: & object.
4476 //
4477 Unary u = e as Unary;
4478 if (u != null && u.Oper == Unary.Operator.AddressOf) {
4479 IVariableReference vr = u.Expr as IVariableReference;
4480 if (vr == null || !vr.IsFixed) {
4481 data [i] = new ExpressionEmitter (e, vi);
4482 }
4483 }
4484
4485 if (data [i++] == null)
4486 ec.Report.Error (213, vi.Location, "You cannot use the fixed statement to take the address of an already fixed expression");
4487
4488 e = Convert.ImplicitConversionRequired (ec, e, expr_type, loc);
4489 }
4490
4491 ec.StartFlowBranching (FlowBranching.BranchingType.Conditional, loc);
4492 bool ok = statement.Resolve (ec);
4493 bool flow_unreachable = ec.EndFlowBranching ();
4494 has_ret = flow_unreachable;
4495
4496 return ok;
4497 }
4498
4499 protected override void DoEmit (EmitContext ec)
4500 {
4501 for (int i = 0; i < data.Length; i++) {
4502 data [i].Emit (ec);
4503 }
4504
4505 statement.Emit (ec);
4506
4507 if (has_ret)
4508 return;
4509
4510 //
4511 // Clear the pinned variable
4512 //
4513 for (int i = 0; i < data.Length; i++) {
4514 data [i].EmitExit (ec);
4515 }
4516 }
4517
4518 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4519 {
4520 // Fixed statement cannot be used inside anonymous methods or lambdas
4521 throw new NotSupportedException ();
4522 }
4523
4524 protected override void CloneTo (CloneContext clonectx, Statement t)
4525 {
4526 Fixed target = (Fixed) t;
4527
4528 target.type = type.Clone (clonectx);
4529 target.declarators = new ArrayList (declarators.Count);
4530 foreach (Pair p in declarators) {
4531 LocalInfo vi = (LocalInfo) p.First;
4532 Expression e = (Expression) p.Second;
4533
4534 target.declarators.Add (
4535 new Pair (clonectx.LookupVariable (vi), e.Clone (clonectx)));
4536 }
4537
4538 target.statement = statement.Clone (clonectx);
4539 }
4540 }
4541
4542 public class Catch : Statement {
4543 public readonly string Name;
4544 public Block Block;
4545 public Block VarBlock;
4546
4547 Expression type_expr;
4548 Type type;
4549
4550 public Catch (Expression type, string name, Block block, Block var_block, Location l)
4551 {
4552 type_expr = type;
4553 Name = name;
4554 Block = block;
4555 VarBlock = var_block;
4556 loc = l;
4557 }
4558
4559 public Type CatchType {
4560 get {
4561 return type;
4562 }
4563 }
4564
4565 public bool IsGeneral {
4566 get {
4567 return type_expr == null;
4568 }
4569 }
4570
4571 protected override void DoEmit (EmitContext ec)
4572 {
4573 ILGenerator ig = ec.ig;
4574
4575 if (CatchType != null)
4576 ig.BeginCatchBlock (CatchType);
4577 else
4578 ig.BeginCatchBlock (TypeManager.object_type);
4579
4580 if (VarBlock != null)
4581 VarBlock.Emit (ec);
4582
4583 if (Name != null) {
4584 // TODO: Move to resolve
4585 LocalVariableReference lvr = new LocalVariableReference (Block, Name, loc);
4586 lvr.Resolve (new ResolveContext (ec.MemberContext));
4587
4588 // Only to make verifier happy
4589 if (TypeManager.IsGenericParameter (lvr.Type))
4590 ig.Emit (OpCodes.Unbox_Any, lvr.Type);
4591
4592 Expression source;
4593 if (lvr.IsHoisted) {
4594 LocalTemporary lt = new LocalTemporary (lvr.Type);
4595 lt.Store (ec);
4596 source = lt;
4597 } else {
4598 // Variable is at the top of the stack
4599 source = EmptyExpression.Null;
4600 }
4601
4602 lvr.EmitAssign (ec, source, false, false);
4603 } else
4604 ig.Emit (OpCodes.Pop);
4605
4606 Block.Emit (ec);
4607 }
4608
4609 public override bool Resolve (BlockContext ec)
4610 {
4611 using (ec.With (ResolveContext.Options.CatchScope, true)) {
4612 if (type_expr != null) {
4613 TypeExpr te = type_expr.ResolveAsTypeTerminal (ec, false);
4614 if (te == null)
4615 return false;
4616
4617 type = te.Type;
4618
4619 if (type != TypeManager.exception_type && !TypeManager.IsSubclassOf (type, TypeManager.exception_type)){
4620 ec.Report.Error (155, loc, "The type caught or thrown must be derived from System.Exception");
4621 return false;
4622 }
4623 } else
4624 type = null;
4625
4626 if (!Block.Resolve (ec))
4627 return false;
4628
4629 // Even though VarBlock surrounds 'Block' we resolve it later, so that we can correctly
4630 // emit the "unused variable" warnings.
4631 if (VarBlock != null)
4632 return VarBlock.Resolve (ec);
4633
4634 return true;
4635 }
4636 }
4637
4638 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4639 {
4640 if (type != null)
4641 type = storey.MutateType (type);
4642 if (VarBlock != null)
4643 VarBlock.MutateHoistedGenericType (storey);
4644 Block.MutateHoistedGenericType (storey);
4645 }
4646
4647 protected override void CloneTo (CloneContext clonectx, Statement t)
4648 {
4649 Catch target = (Catch) t;
4650
4651 if (type_expr != null)
4652 target.type_expr = type_expr.Clone (clonectx);
4653 if (VarBlock != null)
4654 target.VarBlock = clonectx.LookupBlock (VarBlock);
4655 target.Block = clonectx.LookupBlock (Block);
4656 }
4657 }
4658
4659 public class TryFinally : ExceptionStatement {
4660 Statement stmt;
4661 Block fini;
4662
4663 public TryFinally (Statement stmt, Block fini, Location l)
4664 {
4665 this.stmt = stmt;
4666 this.fini = fini;
4667 loc = l;
4668 }
4669
4670 public override bool Resolve (BlockContext ec)
4671 {
4672 bool ok = true;
4673
4674 ec.StartFlowBranching (this);
4675
4676 if (!stmt.Resolve (ec))
4677 ok = false;
4678
4679 if (ok)
4680 ec.CurrentBranching.CreateSibling (fini, FlowBranching.SiblingType.Finally);
4681 using (ec.With (ResolveContext.Options.FinallyScope, true)) {
4682 if (!fini.Resolve (ec))
4683 ok = false;
4684 }
4685
4686 ec.EndFlowBranching ();
4687
4688 ok &= base.Resolve (ec);
4689
4690 return ok;
4691 }
4692
4693 protected override void EmitPreTryBody (EmitContext ec)
4694 {
4695 }
4696
4697 protected override void EmitTryBody (EmitContext ec)
4698 {
4699 stmt.Emit (ec);
4700 }
4701
4702 protected override void EmitFinallyBody (EmitContext ec)
4703 {
4704 fini.Emit (ec);
4705 }
4706
4707 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4708 {
4709 stmt.MutateHoistedGenericType (storey);
4710 fini.MutateHoistedGenericType (storey);
4711 }
4712
4713 protected override void CloneTo (CloneContext clonectx, Statement t)
4714 {
4715 TryFinally target = (TryFinally) t;
4716
4717 target.stmt = (Statement) stmt.Clone (clonectx);
4718 if (fini != null)
4719 target.fini = clonectx.LookupBlock (fini);
4720 }
4721 }
4722
4723 public class TryCatch : Statement {
4724 public Block Block;
4725 public ArrayList Specific;
4726 public Catch General;
4727 bool inside_try_finally, code_follows;
4728
4729 public TryCatch (Block block, ArrayList catch_clauses, Location l, bool inside_try_finally)
4730 {
4731 this.Block = block;
4732 this.Specific = catch_clauses;
4733 this.inside_try_finally = inside_try_finally;
4734
4735 Catch c = (Catch) catch_clauses [0];
4736 if (c.IsGeneral) {
4737 this.General = c;
4738 catch_clauses.RemoveAt (0);
4739 }
4740
4741 loc = l;
4742 }
4743
4744 public override bool Resolve (BlockContext ec)
4745 {
4746 bool ok = true;
4747
4748 ec.StartFlowBranching (this);
4749
4750 if (!Block.Resolve (ec))
4751 ok = false;
4752
4753 Type[] prev_catches = new Type [Specific.Count];
4754 int last_index = 0;
4755 foreach (Catch c in Specific){
4756 ec.CurrentBranching.CreateSibling (c.Block, FlowBranching.SiblingType.Catch);
4757
4758 if (c.Name != null) {
4759 LocalInfo vi = c.Block.GetLocalInfo (c.Name);
4760 if (vi == null)
4761 throw new Exception ();
4762
4763 vi.VariableInfo = null;
4764 }
4765
4766 if (!c.Resolve (ec)) {
4767 ok = false;
4768 continue;
4769 }
4770
4771 Type resolved_type = c.CatchType;
4772 for (int ii = 0; ii < last_index; ++ii) {
4773 if (resolved_type == prev_catches [ii] || TypeManager.IsSubclassOf (resolved_type, prev_catches [ii])) {
4774 ec.Report.Error (160, c.loc,
4775 "A previous catch clause already catches all exceptions of this or a super type `{0}'",
4776 TypeManager.CSharpName (prev_catches [ii]));
4777 ok = false;
4778 }
4779 }
4780
4781 prev_catches [last_index++] = resolved_type;
4782 }
4783
4784 if (General != null) {
4785 if (CodeGen.Assembly.WrapNonExceptionThrows) {
4786 foreach (Catch c in Specific){
4787 if (c.CatchType == TypeManager.exception_type && PredefinedAttributes.Get.RuntimeCompatibility.IsDefined) {
4788 ec.Report.Warning (1058, 1, c.loc, "A previous catch clause already catches all exceptions. All non-exceptions thrown will be wrapped in a `System.Runtime.CompilerServices.RuntimeWrappedException'");
4789 }
4790 }
4791 }
4792
4793 ec.CurrentBranching.CreateSibling (General.Block, FlowBranching.SiblingType.Catch);
4794
4795 if (!General.Resolve (ec))
4796 ok = false;
4797 }
4798
4799 ec.EndFlowBranching ();
4800
4801 // System.Reflection.Emit automatically emits a 'leave' at the end of a try/catch clause
4802 // So, ensure there's some IL code after this statement
4803 if (!inside_try_finally && !code_follows && ec.CurrentBranching.CurrentUsageVector.IsUnreachable)
4804 ec.NeedReturnLabel ();
4805
4806 return ok;
4807 }
4808
4809 public void SomeCodeFollows ()
4810 {
4811 code_follows = true;
4812 }
4813
4814 protected override void DoEmit (EmitContext ec)
4815 {
4816 ILGenerator ig = ec.ig;
4817
4818 if (!inside_try_finally)
4819 ig.BeginExceptionBlock ();
4820
4821 Block.Emit (ec);
4822
4823 foreach (Catch c in Specific)
4824 c.Emit (ec);
4825
4826 if (General != null)
4827 General.Emit (ec);
4828
4829 if (!inside_try_finally)
4830 ig.EndExceptionBlock ();
4831 }
4832
4833 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4834 {
4835 Block.MutateHoistedGenericType (storey);
4836
4837 if (General != null)
4838 General.MutateHoistedGenericType (storey);
4839 if (Specific != null) {
4840 foreach (Catch c in Specific)
4841 c.MutateHoistedGenericType (storey);
4842 }
4843 }
4844
4845 protected override void CloneTo (CloneContext clonectx, Statement t)
4846 {
4847 TryCatch target = (TryCatch) t;
4848
4849 target.Block = clonectx.LookupBlock (Block);
4850 if (General != null)
4851 target.General = (Catch) General.Clone (clonectx);
4852 if (Specific != null){
4853 target.Specific = new ArrayList ();
4854 foreach (Catch c in Specific)
4855 target.Specific.Add (c.Clone (clonectx));
4856 }
4857 }
4858 }
4859
4860 // FIXME: Why is it almost exact copy of Using ??
4861 public class UsingTemporary : ExceptionStatement {
4862 TemporaryVariable local_copy;
4863 public Statement Statement;
4864 Expression expr;
4865 Type expr_type;
4866
4867 public UsingTemporary (Expression expr, Statement stmt, Location l)
4868 {
4869 this.expr = expr;
4870 Statement = stmt;
4871 loc = l;
4872 }
4873
4874 public override bool Resolve (BlockContext ec)
4875 {
4876 expr = expr.Resolve (ec);
4877 if (expr == null)
4878 return false;
4879
4880 expr_type = expr.Type;
4881
4882 if (!TypeManager.ImplementsInterface (expr_type, TypeManager.idisposable_type)) {
4883 if (Convert.ImplicitConversion (ec, expr, TypeManager.idisposable_type, loc) == null) {
4884 Using.Error_IsNotConvertibleToIDisposable (ec, expr);
4885 return false;
4886 }
4887 }
4888
4889 local_copy = new TemporaryVariable (expr_type, loc);
4890 local_copy.Resolve (ec);
4891
4892 ec.StartFlowBranching (this);
4893
4894 bool ok = Statement.Resolve (ec);
4895
4896 ec.EndFlowBranching ();
4897
4898 ok &= base.Resolve (ec);
4899
4900 if (TypeManager.void_dispose_void == null) {
4901 TypeManager.void_dispose_void = TypeManager.GetPredefinedMethod (
4902 TypeManager.idisposable_type, "Dispose", loc, Type.EmptyTypes);
4903 }
4904
4905 return ok;
4906 }
4907
4908 protected override void EmitPreTryBody (EmitContext ec)
4909 {
4910 local_copy.EmitAssign (ec, expr);
4911 }
4912
4913 protected override void EmitTryBody (EmitContext ec)
4914 {
4915 Statement.Emit (ec);
4916 }
4917
4918 protected override void EmitFinallyBody (EmitContext ec)
4919 {
4920 ILGenerator ig = ec.ig;
4921 if (!TypeManager.IsStruct (expr_type)) {
4922 Label skip = ig.DefineLabel ();
4923 local_copy.Emit (ec);
4924 ig.Emit (OpCodes.Brfalse, skip);
4925 local_copy.Emit (ec);
4926 ig.Emit (OpCodes.Callvirt, TypeManager.void_dispose_void);
4927 ig.MarkLabel (skip);
4928 return;
4929 }
4930
4931 Expression ml = Expression.MemberLookup (RootContext.ToplevelTypes.Compiler,
4932 ec.CurrentType, TypeManager.idisposable_type, expr_type,
4933 "Dispose", Location.Null);
4934
4935 if (!(ml is MethodGroupExpr)) {
4936 local_copy.Emit (ec);
4937 ig.Emit (OpCodes.Box, expr_type);
4938 ig.Emit (OpCodes.Callvirt, TypeManager.void_dispose_void);
4939 return;
4940 }
4941
4942 MethodInfo mi = null;
4943
4944 foreach (MethodInfo mk in ((MethodGroupExpr) ml).Methods) {
4945 if (TypeManager.GetParameterData (mk).Count == 0) {
4946 mi = mk;
4947 break;
4948 }
4949 }
4950
4951 if (mi == null) {
4952 RootContext.ToplevelTypes.Compiler.Report.Error(-100, Mono.CSharp.Location.Null, "Internal error: No Dispose method which takes 0 parameters.");
4953 return;
4954 }
4955
4956 local_copy.AddressOf (ec, AddressOp.Load);
4957 ig.Emit (OpCodes.Call, mi);
4958 }
4959
4960 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
4961 {
4962 expr_type = storey.MutateType (expr_type);
4963 local_copy.MutateHoistedGenericType (storey);
4964 Statement.MutateHoistedGenericType (storey);
4965 }
4966
4967 protected override void CloneTo (CloneContext clonectx, Statement t)
4968 {
4969 UsingTemporary target = (UsingTemporary) t;
4970
4971 target.expr = expr.Clone (clonectx);
4972 target.Statement = Statement.Clone (clonectx);
4973 }
4974 }
4975
4976 public class Using : ExceptionStatement {
4977 Statement stmt;
4978 public Statement EmbeddedStatement {
4979 get { return stmt is Using ? ((Using) stmt).EmbeddedStatement : stmt; }
4980 }
4981
4982 Expression var;
4983 Expression init;
4984
4985 ExpressionStatement assign;
4986
4987 public Using (Expression var, Expression init, Statement stmt, Location l)
4988 {
4989 this.var = var;
4990 this.init = init;
4991 this.stmt = stmt;
4992 loc = l;
4993 }
4994
4995 static public void Error_IsNotConvertibleToIDisposable (BlockContext ec, Expression expr)
4996 {
4997 ec.Report.SymbolRelatedToPreviousError (expr.Type);
4998 ec.Report.Error (1674, expr.Location, "`{0}': type used in a using statement must be implicitly convertible to `System.IDisposable'",
4999 TypeManager.CSharpName (expr.Type));
5000 }
5001
5002 protected override void EmitPreTryBody (EmitContext ec)
5003 {
5004 assign.EmitStatement (ec);
5005 }
5006
5007 protected override void EmitTryBody (EmitContext ec)
5008 {
5009 stmt.Emit (ec);
5010 }
5011
5012 protected override void EmitFinallyBody (EmitContext ec)
5013 {
5014 ILGenerator ig = ec.ig;
5015 Label skip = ig.DefineLabel ();
5016
5017 bool emit_null_check = !TypeManager.IsValueType (var.Type);
5018 if (emit_null_check) {
5019 var.Emit (ec);
5020 ig.Emit (OpCodes.Brfalse, skip);
5021 }
5022
5023 Invocation.EmitCall (ec, false, var, TypeManager.void_dispose_void, null, loc);
5024
5025 if (emit_null_check)
5026 ig.MarkLabel (skip);
5027 }
5028
5029 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5030 {
5031 assign.MutateHoistedGenericType (storey);
5032 var.MutateHoistedGenericType (storey);
5033 stmt.MutateHoistedGenericType (storey);
5034 }
5035
5036 public override bool Resolve (BlockContext ec)
5037 {
5038 if (!ResolveVariable (ec))
5039 return false;
5040
5041 ec.StartFlowBranching (this);
5042
5043 bool ok = stmt.Resolve (ec);
5044
5045 ec.EndFlowBranching ();
5046
5047 ok &= base.Resolve (ec);
5048
5049 if (TypeManager.void_dispose_void == null) {
5050 TypeManager.void_dispose_void = TypeManager.GetPredefinedMethod (
5051 TypeManager.idisposable_type, "Dispose", loc, Type.EmptyTypes);
5052 }
5053
5054 return ok;
5055 }
5056
5057 bool ResolveVariable (BlockContext ec)
5058 {
5059 assign = new SimpleAssign (var, init, loc);
5060 assign = assign.ResolveStatement (ec);
5061 if (assign == null)
5062 return false;
5063
5064 if (assign.Type == TypeManager.idisposable_type ||
5065 TypeManager.ImplementsInterface (assign.Type, TypeManager.idisposable_type)) {
5066 return true;
5067 }
5068
5069 Expression e = Convert.ImplicitConversionStandard (ec, assign, TypeManager.idisposable_type, var.Location);
5070 if (e == null) {
5071 Error_IsNotConvertibleToIDisposable (ec, var);
5072 return false;
5073 }
5074
5075 throw new NotImplementedException ("covariance?");
5076 }
5077
5078 protected override void CloneTo (CloneContext clonectx, Statement t)
5079 {
5080 Using target = (Using) t;
5081
5082 target.var = var.Clone (clonectx);
5083 target.init = init.Clone (clonectx);
5084 target.stmt = stmt.Clone (clonectx);
5085 }
5086 }
5087
5088 /// <summary>
5089 /// Implementation of the foreach C# statement
5090 /// </summary>
5091 public class Foreach : Statement {
5092
5093 sealed class ArrayForeach : Statement
5094 {
5095 class ArrayCounter : TemporaryVariable
5096 {
5097 StatementExpression increment;
5098
5099 public ArrayCounter (Location loc)
5100 : base (TypeManager.int32_type, loc)
5101 {
5102 }
5103
5104 public void ResolveIncrement (BlockContext ec)
5105 {
5106 increment = new StatementExpression (new UnaryMutator (UnaryMutator.Mode.PostIncrement, this));
5107 increment.Resolve (ec);
5108 }
5109
5110 public void EmitIncrement (EmitContext ec)
5111 {
5112 increment.Emit (ec);
5113 }
5114 }
5115
5116 readonly Foreach for_each;
5117 readonly Statement statement;
5118
5119 Expression conv;
5120 TemporaryVariable[] lengths;
5121 Expression [] length_exprs;
5122 ArrayCounter[] counter;
5123
5124 TemporaryVariable copy;
5125 Expression access;
5126
5127 public ArrayForeach (Foreach @foreach, int rank)
5128 {
5129 for_each = @foreach;
5130 statement = for_each.statement;
5131 loc = @foreach.loc;
5132
5133 counter = new ArrayCounter [rank];
5134 length_exprs = new Expression [rank];
5135
5136 //
5137 // Only use temporary length variables when dealing with
5138 // multi-dimensional arrays
5139 //
5140 if (rank > 1)
5141 lengths = new TemporaryVariable [rank];
5142 }
5143
5144 protected override void CloneTo (CloneContext clonectx, Statement target)
5145 {
5146 throw new NotImplementedException ();
5147 }
5148
5149 public override bool Resolve (BlockContext ec)
5150 {
5151 copy = new TemporaryVariable (for_each.expr.Type, loc);
5152 copy.Resolve (ec);
5153
5154 int rank = length_exprs.Length;
5155 Arguments list = new Arguments (rank);
5156 for (int i = 0; i < rank; i++) {
5157 counter [i] = new ArrayCounter (loc);
5158 counter [i].ResolveIncrement (ec);
5159
5160 if (rank == 1) {
5161 length_exprs [i] = new MemberAccess (copy, "Length").Resolve (ec);
5162 } else {
5163 lengths [i] = new TemporaryVariable (TypeManager.int32_type, loc);
5164 lengths [i].Resolve (ec);
5165
5166 Arguments args = new Arguments (1);
5167 args.Add (new Argument (new IntConstant (i, loc)));
5168 length_exprs [i] = new Invocation (new MemberAccess (copy, "GetLength"), args).Resolve (ec);
5169 }
5170
5171 list.Add (new Argument (counter [i]));
5172 }
5173
5174 access = new ElementAccess (copy, list).Resolve (ec);
5175 if (access == null)
5176 return false;
5177
5178 Expression var_type = for_each.type;
5179 VarExpr ve = var_type as VarExpr;
5180 if (ve != null) {
5181 // Infer implicitly typed local variable from foreach array type
5182 var_type = new TypeExpression (access.Type, ve.Location);
5183 }
5184
5185 var_type = var_type.ResolveAsTypeTerminal (ec, false);
5186 if (var_type == null)
5187 return false;
5188
5189 conv = Convert.ExplicitConversion (ec, access, var_type.Type, loc);
5190 if (conv == null)
5191 return false;
5192
5193 bool ok = true;
5194
5195 ec.StartFlowBranching (FlowBranching.BranchingType.Loop, loc);
5196 ec.CurrentBranching.CreateSibling ();
5197
5198 for_each.variable = for_each.variable.ResolveLValue (ec, conv);
5199 if (for_each.variable == null)
5200 ok = false;
5201
5202 ec.StartFlowBranching (FlowBranching.BranchingType.Embedded, loc);
5203 if (!statement.Resolve (ec))
5204 ok = false;
5205 ec.EndFlowBranching ();
5206
5207 // There's no direct control flow from the end of the embedded statement to the end of the loop
5208 ec.CurrentBranching.CurrentUsageVector.Goto ();
5209
5210 ec.EndFlowBranching ();
5211
5212 return ok;
5213 }
5214
5215 protected override void DoEmit (EmitContext ec)
5216 {
5217 ILGenerator ig = ec.ig;
5218
5219 copy.EmitAssign (ec, for_each.expr);
5220
5221 int rank = length_exprs.Length;
5222 Label[] test = new Label [rank];
5223 Label[] loop = new Label [rank];
5224
5225 for (int i = 0; i < rank; i++) {
5226 test [i] = ig.DefineLabel ();
5227 loop [i] = ig.DefineLabel ();
5228
5229 if (lengths != null)
5230 lengths [i].EmitAssign (ec, length_exprs [i]);
5231 }
5232
5233 IntConstant zero = new IntConstant (0, loc);
5234 for (int i = 0; i < rank; i++) {
5235 counter [i].EmitAssign (ec, zero);
5236
5237 ig.Emit (OpCodes.Br, test [i]);
5238 ig.MarkLabel (loop [i]);
5239 }
5240
5241 ((IAssignMethod) for_each.variable).EmitAssign (ec, conv, false, false);
5242
5243 statement.Emit (ec);
5244
5245 ig.MarkLabel (ec.LoopBegin);
5246
5247 for (int i = rank - 1; i >= 0; i--){
5248 counter [i].EmitIncrement (ec);
5249
5250 ig.MarkLabel (test [i]);
5251 counter [i].Emit (ec);
5252
5253 if (lengths != null)
5254 lengths [i].Emit (ec);
5255 else
5256 length_exprs [i].Emit (ec);
5257
5258 ig.Emit (OpCodes.Blt, loop [i]);
5259 }
5260
5261 ig.MarkLabel (ec.LoopEnd);
5262 }
5263
5264 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5265 {
5266 for_each.expr.MutateHoistedGenericType (storey);
5267
5268 copy.MutateHoistedGenericType (storey);
5269 conv.MutateHoistedGenericType (storey);
5270 statement.MutateHoistedGenericType (storey);
5271
5272 for (int i = 0; i < counter.Length; i++) {
5273 counter [i].MutateHoistedGenericType (storey);
5274 if (lengths != null)
5275 lengths [i].MutateHoistedGenericType (storey);
5276 }
5277 }
5278 }
5279
5280 sealed class CollectionForeach : Statement
5281 {
5282 class CollectionForeachStatement : Statement
5283 {
5284 Type type;
5285 Expression variable, current, conv;
5286 Statement statement;
5287 Assign assign;
5288
5289 public CollectionForeachStatement (Type type, Expression variable,
5290 Expression current, Statement statement,
5291 Location loc)
5292 {
5293 this.type = type;
5294 this.variable = variable;
5295 this.current = current;
5296 this.statement = statement;
5297 this.loc = loc;
5298 }
5299
5300 protected override void CloneTo (CloneContext clonectx, Statement target)
5301 {
5302 throw new NotImplementedException ();
5303 }
5304
5305 public override bool Resolve (BlockContext ec)
5306 {
5307 current = current.Resolve (ec);
5308 if (current == null)
5309 return false;
5310
5311 conv = Convert.ExplicitConversion (ec, current, type, loc);
5312 if (conv == null)
5313 return false;
5314
5315 assign = new SimpleAssign (variable, conv, loc);
5316 if (assign.Resolve (ec) == null)
5317 return false;
5318
5319 if (!statement.Resolve (ec))
5320 return false;
5321
5322 return true;
5323 }
5324
5325 protected override void DoEmit (EmitContext ec)
5326 {
5327 assign.EmitStatement (ec);
5328 statement.Emit (ec);
5329 }
5330
5331 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5332 {
5333 assign.MutateHoistedGenericType (storey);
5334 statement.MutateHoistedGenericType (storey);
5335 }
5336 }
5337
5338 Expression variable, expr;
5339 Statement statement;
5340
5341 TemporaryVariable enumerator;
5342 Expression init;
5343 Statement loop;
5344 Statement wrapper;
5345
5346 MethodGroupExpr get_enumerator;
5347 PropertyExpr get_current;
5348 MethodInfo move_next;
5349 Expression var_type;
5350 Type enumerator_type;
5351 bool enumerator_found;
5352
5353 public CollectionForeach (Expression var_type, Expression var,
5354 Expression expr, Statement stmt, Location l)
5355 {
5356 this.var_type = var_type;
5357 this.variable = var;
5358 this.expr = expr;
5359 statement = stmt;
5360 loc = l;
5361 }
5362
5363 protected override void CloneTo (CloneContext clonectx, Statement target)
5364 {
5365 throw new NotImplementedException ();
5366 }
5367
5368 bool GetEnumeratorFilter (ResolveContext ec, MethodInfo mi)
5369 {
5370 Type return_type = mi.ReturnType;
5371
5372 //
5373 // Ok, we can access it, now make sure that we can do something
5374 // with this `GetEnumerator'
5375 //
5376
5377 if (return_type == TypeManager.ienumerator_type ||
5378 TypeManager.ImplementsInterface (return_type, TypeManager.ienumerator_type)) {
5379 //
5380 // If it is not an interface, lets try to find the methods ourselves.
5381 // For example, if we have:
5382 // public class Foo : IEnumerator { public bool MoveNext () {} public int Current { get {}}}
5383 // We can avoid the iface call. This is a runtime perf boost.
5384 // even bigger if we have a ValueType, because we avoid the cost
5385 // of boxing.
5386 //
5387 // We have to make sure that both methods exist for us to take
5388 // this path. If one of the methods does not exist, we will just
5389 // use the interface. Sadly, this complex if statement is the only
5390 // way I could do this without a goto
5391 //
5392
5393 if (TypeManager.bool_movenext_void == null) {
5394 TypeManager.bool_movenext_void = TypeManager.GetPredefinedMethod (
5395 TypeManager.ienumerator_type, "MoveNext", loc, Type.EmptyTypes);
5396 }
5397
5398 if (TypeManager.ienumerator_getcurrent == null) {
5399 TypeManager.ienumerator_getcurrent = TypeManager.GetPredefinedProperty (
5400 TypeManager.ienumerator_type, "Current", loc, TypeManager.object_type);
5401 }
5402
5403 //
5404 // Prefer a generic enumerator over a non-generic one.
5405 //
5406 if (return_type.IsInterface && TypeManager.IsGenericType (return_type)) {
5407 enumerator_type = return_type;
5408 if (!FetchGetCurrent (ec, return_type))
5409 get_current = new PropertyExpr (
5410 ec.CurrentType, TypeManager.ienumerator_getcurrent, loc);
5411 if (!FetchMoveNext (return_type))
5412 move_next = TypeManager.bool_movenext_void;
5413 return true;
5414 }
5415
5416 if (return_type.IsInterface ||
5417 !FetchMoveNext (return_type) ||
5418 !FetchGetCurrent (ec, return_type)) {
5419 enumerator_type = return_type;
5420 move_next = TypeManager.bool_movenext_void;
5421 get_current = new PropertyExpr (
5422 ec.CurrentType, TypeManager.ienumerator_getcurrent, loc);
5423 return true;
5424 }
5425 } else {
5426 //
5427 // Ok, so they dont return an IEnumerable, we will have to
5428 // find if they support the GetEnumerator pattern.
5429 //
5430
5431 if (TypeManager.HasElementType (return_type) || !FetchMoveNext (return_type) || !FetchGetCurrent (ec, return_type)) {
5432 ec.Report.Error (202, loc, "foreach statement requires that the return type `{0}' of `{1}' must have a suitable public MoveNext method and public Current property",
5433 TypeManager.CSharpName (return_type), TypeManager.CSharpSignature (mi));
5434 return false;
5435 }
5436 }
5437
5438 enumerator_type = return_type;
5439
5440 return true;
5441 }
5442
5443 //
5444 // Retrieves a `public bool MoveNext ()' method from the Type `t'
5445 //
5446 bool FetchMoveNext (Type t)
5447 {
5448 MemberInfo[] move_next_list = TypeManager.MemberLookup (null, null, t,
5449 MemberTypes.Method,
5450 BindingFlags.Public | BindingFlags.Instance,
5451 "MoveNext", null);
5452
5453 if (move_next_list == null)
5454 return false;
5455
5456 foreach (MemberInfo m in move_next_list){
5457 MethodInfo mi = (MethodInfo) m;
5458
5459 if ((TypeManager.GetParameterData (mi).Count == 0) &&
5460 TypeManager.TypeToCoreType (mi.ReturnType) == TypeManager.bool_type) {
5461 move_next = mi;
5462 return true;
5463 }
5464 }
5465
5466 return false;
5467 }
5468
5469 //
5470 // Retrieves a `public T get_Current ()' method from the Type `t'
5471 //
5472 bool FetchGetCurrent (ResolveContext ec, Type t)
5473 {
5474 PropertyExpr pe = Expression.MemberLookup (ec.Compiler,
5475 ec.CurrentType, t, "Current", MemberTypes.Property,
5476 Expression.AllBindingFlags, loc) as PropertyExpr;
5477 if (pe == null)
5478 return false;
5479
5480 get_current = pe;
5481 return true;
5482 }
5483
5484 void Error_Enumerator (BlockContext ec)
5485 {
5486 if (enumerator_found) {
5487 return;
5488 }
5489
5490 ec.Report.Error (1579, loc,
5491 "foreach statement cannot operate on variables of type `{0}' because it does not contain a definition for `GetEnumerator' or is not accessible",
5492 TypeManager.CSharpName (expr.Type));
5493 }
5494
5495 bool IsOverride (MethodInfo m)
5496 {
5497 m = (MethodInfo) TypeManager.DropGenericMethodArguments (m);
5498
5499 if (!m.IsVirtual || ((m.Attributes & MethodAttributes.NewSlot) != 0))
5500 return false;
5501 if (m is MethodBuilder)
5502 return true;
5503
5504 MethodInfo base_method = m.GetBaseDefinition ();
5505 return base_method != m;
5506 }
5507
5508 bool TryType (ResolveContext ec, Type t)
5509 {
5510 MethodGroupExpr mg = Expression.MemberLookup (ec.Compiler,
5511 ec.CurrentType, t, "GetEnumerator", MemberTypes.Method,
5512 Expression.AllBindingFlags, loc) as MethodGroupExpr;
5513 if (mg == null)
5514 return false;
5515
5516 MethodInfo result = null;
5517 MethodInfo tmp_move_next = null;
5518 PropertyExpr tmp_get_cur = null;
5519 Type tmp_enumerator_type = enumerator_type;
5520 foreach (MethodInfo mi in mg.Methods) {
5521 if (TypeManager.GetParameterData (mi).Count != 0)
5522 continue;
5523
5524 // Check whether GetEnumerator is public
5525 if ((mi.Attributes & MethodAttributes.Public) != MethodAttributes.Public)
5526 continue;
5527
5528 if (IsOverride (mi))
5529 continue;
5530
5531 enumerator_found = true;
5532
5533 if (!GetEnumeratorFilter (ec, mi))
5534 continue;
5535
5536 if (result != null) {
5537 if (TypeManager.IsGenericType (result.ReturnType)) {
5538 if (!TypeManager.IsGenericType (mi.ReturnType))
5539 continue;
5540
5541 MethodBase mb = TypeManager.DropGenericMethodArguments (mi);
5542 ec.Report.SymbolRelatedToPreviousError (t);
5543 ec.Report.Error(1640, loc, "foreach statement cannot operate on variables of type `{0}' " +
5544 "because it contains multiple implementation of `{1}'. Try casting to a specific implementation",
5545 TypeManager.CSharpName (t), TypeManager.CSharpSignature (mb));
5546 return false;
5547 }
5548
5549 // Always prefer generics enumerators
5550 if (!TypeManager.IsGenericType (mi.ReturnType)) {
5551 if (TypeManager.ImplementsInterface (mi.DeclaringType, result.DeclaringType) ||
5552 TypeManager.ImplementsInterface (result.DeclaringType, mi.DeclaringType))
5553 continue;
5554
5555 ec.Report.SymbolRelatedToPreviousError (result);
5556 ec.Report.SymbolRelatedToPreviousError (mi);
5557 ec.Report.Warning (278, 2, loc, "`{0}' contains ambiguous implementation of `{1}' pattern. Method `{2}' is ambiguous with method `{3}'",
5558 TypeManager.CSharpName (t), "enumerable", TypeManager.CSharpSignature (result), TypeManager.CSharpSignature (mi));
5559 return false;
5560 }
5561 }
5562 result = mi;
5563 tmp_move_next = move_next;
5564 tmp_get_cur = get_current;
5565 tmp_enumerator_type = enumerator_type;
5566 if (mi.DeclaringType == t)
5567 break;
5568 }
5569
5570 if (result != null) {
5571 move_next = tmp_move_next;
5572 get_current = tmp_get_cur;
5573 enumerator_type = tmp_enumerator_type;
5574 MethodInfo[] mi = new MethodInfo[] { (MethodInfo) result };
5575 get_enumerator = new MethodGroupExpr (mi, enumerator_type, loc);
5576
5577 if (t != expr.Type) {
5578 expr = Convert.ExplicitConversion (
5579 ec, expr, t, loc);
5580 if (expr == null)
5581 throw new InternalErrorException ();
5582 }
5583
5584 get_enumerator.InstanceExpression = expr;
5585 get_enumerator.IsBase = t != expr.Type;
5586
5587 return true;
5588 }
5589
5590 return false;
5591 }
5592
5593 bool ProbeCollectionType (ResolveContext ec, Type t)
5594 {
5595 int errors = ec.Report.Errors;
5596 for (Type tt = t; tt != null && tt != TypeManager.object_type;){
5597 if (TryType (ec, tt))
5598 return true;
5599 tt = tt.BaseType;
5600 }
5601
5602 if (ec.Report.Errors > errors)
5603 return false;
5604
5605 //
5606 // Now try to find the method in the interfaces
5607 //
5608 Type [] ifaces = TypeManager.GetInterfaces (t);
5609 foreach (Type i in ifaces){
5610 if (TryType (ec, i))
5611 return true;
5612 }
5613
5614 return false;
5615 }
5616
5617 public override bool Resolve (BlockContext ec)
5618 {
5619 enumerator_type = TypeManager.ienumerator_type;
5620
5621 if (!ProbeCollectionType (ec, expr.Type)) {
5622 Error_Enumerator (ec);
5623 return false;
5624 }
5625
5626 VarExpr ve = var_type as VarExpr;
5627 if (ve != null) {
5628 // Infer implicitly typed local variable from foreach enumerable type
5629 var_type = new TypeExpression (get_current.PropertyInfo.PropertyType, var_type.Location);
5630 }
5631
5632 var_type = var_type.ResolveAsTypeTerminal (ec, false);
5633 if (var_type == null)
5634 return false;
5635
5636 enumerator = new TemporaryVariable (enumerator_type, loc);
5637 enumerator.Resolve (ec);
5638
5639 init = new Invocation (get_enumerator, null);
5640 init = init.Resolve (ec);
5641 if (init == null)
5642 return false;
5643
5644 Expression move_next_expr;
5645 {
5646 MemberInfo[] mi = new MemberInfo[] { move_next };
5647 MethodGroupExpr mg = new MethodGroupExpr (mi, var_type.Type, loc);
5648 mg.InstanceExpression = enumerator;
5649
5650 move_next_expr = new Invocation (mg, null);
5651 }
5652
5653 get_current.InstanceExpression = enumerator;
5654
5655 Statement block = new CollectionForeachStatement (
5656 var_type.Type, variable, get_current, statement, loc);
5657
5658 loop = new While (new BooleanExpression (move_next_expr), block, loc);
5659
5660
5661 bool implements_idisposable = TypeManager.ImplementsInterface (enumerator_type, TypeManager.idisposable_type);
5662 if (implements_idisposable || !enumerator_type.IsSealed) {
5663 wrapper = new DisposableWrapper (this, implements_idisposable);
5664 } else {
5665 wrapper = new NonDisposableWrapper (this);
5666 }
5667
5668 return wrapper.Resolve (ec);
5669 }
5670
5671 protected override void DoEmit (EmitContext ec)
5672 {
5673 wrapper.Emit (ec);
5674 }
5675
5676 class NonDisposableWrapper : Statement {
5677 CollectionForeach parent;
5678
5679 internal NonDisposableWrapper (CollectionForeach parent)
5680 {
5681 this.parent = parent;
5682 }
5683
5684 protected override void CloneTo (CloneContext clonectx, Statement target)
5685 {
5686 throw new NotSupportedException ();
5687 }
5688
5689 public override bool Resolve (BlockContext ec)
5690 {
5691 return parent.ResolveLoop (ec);
5692 }
5693
5694 protected override void DoEmit (EmitContext ec)
5695 {
5696 parent.EmitLoopInit (ec);
5697 parent.EmitLoopBody (ec);
5698 }
5699
5700 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5701 {
5702 throw new NotSupportedException ();
5703 }
5704 }
5705
5706 sealed class DisposableWrapper : ExceptionStatement
5707 {
5708 CollectionForeach parent;
5709 bool implements_idisposable;
5710
5711 internal DisposableWrapper (CollectionForeach parent, bool implements)
5712 {
5713 this.parent = parent;
5714 this.implements_idisposable = implements;
5715 }
5716
5717 protected override void CloneTo (CloneContext clonectx, Statement target)
5718 {
5719 throw new NotSupportedException ();
5720 }
5721
5722 public override bool Resolve (BlockContext ec)
5723 {
5724 bool ok = true;
5725
5726 ec.StartFlowBranching (this);
5727
5728 if (!parent.ResolveLoop (ec))
5729 ok = false;
5730
5731 ec.EndFlowBranching ();
5732
5733 ok &= base.Resolve (ec);
5734
5735 if (TypeManager.void_dispose_void == null) {
5736 TypeManager.void_dispose_void = TypeManager.GetPredefinedMethod (
5737 TypeManager.idisposable_type, "Dispose", loc, Type.EmptyTypes);
5738 }
5739 return ok;
5740 }
5741
5742 protected override void EmitPreTryBody (EmitContext ec)
5743 {
5744 parent.EmitLoopInit (ec);
5745 }
5746
5747 protected override void EmitTryBody (EmitContext ec)
5748 {
5749 parent.EmitLoopBody (ec);
5750 }
5751
5752 protected override void EmitFinallyBody (EmitContext ec)
5753 {
5754 Expression instance = parent.enumerator;
5755 if (!TypeManager.IsValueType (parent.enumerator_type)) {
5756 ILGenerator ig = ec.ig;
5757
5758 parent.enumerator.Emit (ec);
5759
5760 Label call_dispose = ig.DefineLabel ();
5761
5762 if (!implements_idisposable) {
5763 ec.ig.Emit (OpCodes.Isinst, TypeManager.idisposable_type);
5764 LocalTemporary temp = new LocalTemporary (TypeManager.idisposable_type);
5765 temp.Store (ec);
5766 temp.Emit (ec);
5767 instance = temp;
5768 }
5769
5770 ig.Emit (OpCodes.Brtrue_S, call_dispose);
5771
5772 // using 'endfinally' to empty the evaluation stack
5773 ig.Emit (OpCodes.Endfinally);
5774 ig.MarkLabel (call_dispose);
5775 }
5776
5777 Invocation.EmitCall (ec, false, instance, TypeManager.void_dispose_void, null, loc);
5778 }
5779
5780 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5781 {
5782 throw new NotSupportedException ();
5783 }
5784 }
5785
5786 bool ResolveLoop (BlockContext ec)
5787 {
5788 return loop.Resolve (ec);
5789 }
5790
5791 void EmitLoopInit (EmitContext ec)
5792 {
5793 enumerator.EmitAssign (ec, init);
5794 }
5795
5796 void EmitLoopBody (EmitContext ec)
5797 {
5798 loop.Emit (ec);
5799 }
5800
5801 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5802 {
5803 enumerator_type = storey.MutateType (enumerator_type);
5804 init.MutateHoistedGenericType (storey);
5805 loop.MutateHoistedGenericType (storey);
5806 }
5807 }
5808
5809 Expression type;
5810 Expression variable;
5811 Expression expr;
5812 Statement statement;
5813
5814 public Foreach (Expression type, LocalVariableReference var, Expression expr,
5815 Statement stmt, Location l)
5816 {
5817 this.type = type;
5818 this.variable = var;
5819 this.expr = expr;
5820 statement = stmt;
5821 loc = l;
5822 }
5823
5824 public Statement Statement {
5825 get { return statement; }
5826 }
5827
5828 public override bool Resolve (BlockContext ec)
5829 {
5830 expr = expr.Resolve (ec);
5831 if (expr == null)
5832 return false;
5833
5834 if (expr.IsNull) {
5835 ec.Report.Error (186, loc, "Use of null is not valid in this context");
5836 return false;
5837 }
5838
5839 if (expr.Type == TypeManager.string_type) {
5840 statement = new ArrayForeach (this, 1);
5841 } else if (expr.Type.IsArray) {
5842 statement = new ArrayForeach (this, expr.Type.GetArrayRank ());
5843 } else {
5844 if (expr.eclass == ExprClass.MethodGroup || expr is AnonymousMethodExpression) {
5845 ec.Report.Error (446, expr.Location, "Foreach statement cannot operate on a `{0}'",
5846 expr.ExprClassName);
5847 return false;
5848 }
5849
5850 statement = new CollectionForeach (type, variable, expr, statement, loc);
5851 }
5852
5853 return statement.Resolve (ec);
5854 }
5855
5856 protected override void DoEmit (EmitContext ec)
5857 {
5858 ILGenerator ig = ec.ig;
5859
5860 Label old_begin = ec.LoopBegin, old_end = ec.LoopEnd;
5861 ec.LoopBegin = ig.DefineLabel ();
5862 ec.LoopEnd = ig.DefineLabel ();
5863
5864 statement.Emit (ec);
5865
5866 ec.LoopBegin = old_begin;
5867 ec.LoopEnd = old_end;
5868 }
5869
5870 protected override void CloneTo (CloneContext clonectx, Statement t)
5871 {
5872 Foreach target = (Foreach) t;
5873
5874 target.type = type.Clone (clonectx);
5875 target.variable = variable.Clone (clonectx);
5876 target.expr = expr.Clone (clonectx);
5877 target.statement = statement.Clone (clonectx);
5878 }
5879
5880 public override void MutateHoistedGenericType (AnonymousMethodStorey storey)
5881 {
5882 statement.MutateHoistedGenericType (storey);
5883 }
5884 }
5885 }
git-svn mirror of mcs