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