2009-12-02 Jb Evain <jbevain@novell.com>
[mcs.git] / mcs / flowanalysis.cs
blobc9f58f9fc1b1e3267e5bbe16be1056193bfeb053
1 //
2 // flowanalyis.cs: The control flow analysis code
3 //
4 // Author:
5 // Martin Baulig (martin@ximian.com)
6 // Raja R Harinath (rharinath@novell.com)
7 //
8 // Copyright 2001, 2002, 2003 Ximian, Inc.
9 // Copyright 2003-2008 Novell, Inc.
12 using System;
13 using System.Text;
14 using System.Collections;
15 using System.Reflection;
16 using System.Reflection.Emit;
17 using System.Diagnostics;
19 namespace Mono.CSharp
21 // <summary>
22 // A new instance of this class is created every time a new block is resolved
23 // and if there's branching in the block's control flow.
24 // </summary>
25 public abstract class FlowBranching
27 // <summary>
28 // The type of a FlowBranching.
29 // </summary>
30 public enum BranchingType : byte {
31 // Normal (conditional or toplevel) block.
32 Block,
34 // Conditional.
35 Conditional,
37 // A loop block.
38 Loop,
40 // The statement embedded inside a loop
41 Embedded,
43 // part of a block headed by a jump target
44 Labeled,
46 // TryCatch block.
47 TryCatch,
49 // TryFinally, Using, Lock, CollectionForeach
50 Exception,
52 // Switch block.
53 Switch,
55 // The toplevel block of a function
56 Toplevel,
58 // An iterator block
59 Iterator
62 // <summary>
63 // The type of one sibling of a branching.
64 // </summary>
65 public enum SiblingType : byte {
66 Block,
67 Conditional,
68 SwitchSection,
69 Try,
70 Catch,
71 Finally
74 public static FlowBranching CreateBranching (FlowBranching parent, BranchingType type, Block block, Location loc)
76 switch (type) {
77 case BranchingType.Exception:
78 case BranchingType.Labeled:
79 case BranchingType.Toplevel:
80 case BranchingType.TryCatch:
81 throw new InvalidOperationException ();
83 case BranchingType.Switch:
84 return new FlowBranchingBreakable (parent, type, SiblingType.SwitchSection, block, loc);
86 case BranchingType.Block:
87 return new FlowBranchingBlock (parent, type, SiblingType.Block, block, loc);
89 case BranchingType.Loop:
90 return new FlowBranchingBreakable (parent, type, SiblingType.Conditional, block, loc);
92 case BranchingType.Embedded:
93 return new FlowBranchingContinuable (parent, type, SiblingType.Conditional, block, loc);
95 default:
96 return new FlowBranchingBlock (parent, type, SiblingType.Conditional, block, loc);
100 // <summary>
101 // The type of this flow branching.
102 // </summary>
103 public readonly BranchingType Type;
105 // <summary>
106 // The block this branching is contained in. This may be null if it's not
107 // a top-level block and it doesn't declare any local variables.
108 // </summary>
109 public readonly Block Block;
111 // <summary>
112 // The parent of this branching or null if this is the top-block.
113 // </summary>
114 public readonly FlowBranching Parent;
116 // <summary>
117 // Start-Location of this flow branching.
118 // </summary>
119 public readonly Location Location;
121 static int next_id = 0;
122 int id;
124 // <summary>
125 // The vector contains a BitArray with information about which local variables
126 // and parameters are already initialized at the current code position.
127 // </summary>
128 public class UsageVector {
129 // <summary>
130 // The type of this branching.
131 // </summary>
132 public readonly SiblingType Type;
134 // <summary>
135 // Start location of this branching.
136 // </summary>
137 public Location Location;
139 // <summary>
140 // This is only valid for SwitchSection, Try, Catch and Finally.
141 // </summary>
142 public readonly Block Block;
144 // <summary>
145 // The number of locals in this block.
146 // </summary>
147 public readonly int CountLocals;
149 // <summary>
150 // If not null, then we inherit our state from this vector and do a
151 // copy-on-write. If null, then we're the first sibling in a top-level
152 // block and inherit from the empty vector.
153 // </summary>
154 public readonly UsageVector InheritsFrom;
156 // <summary>
157 // This is used to construct a list of UsageVector's.
158 // </summary>
159 public UsageVector Next;
162 // Private.
164 MyBitVector locals;
165 bool is_unreachable;
167 static int next_id = 0;
168 int id;
171 // Normally, you should not use any of these constructors.
173 public UsageVector (SiblingType type, UsageVector parent, Block block, Location loc, int num_locals)
175 this.Type = type;
176 this.Block = block;
177 this.Location = loc;
178 this.InheritsFrom = parent;
179 this.CountLocals = num_locals;
181 locals = num_locals == 0
182 ? MyBitVector.Empty
183 : new MyBitVector (parent == null ? MyBitVector.Empty : parent.locals, num_locals);
185 if (parent != null)
186 is_unreachable = parent.is_unreachable;
188 id = ++next_id;
192 public UsageVector (SiblingType type, UsageVector parent, Block block, Location loc)
193 : this (type, parent, block, loc, parent.CountLocals)
196 private UsageVector (MyBitVector locals, bool is_unreachable, Block block, Location loc)
198 this.Type = SiblingType.Block;
199 this.Location = loc;
200 this.Block = block;
202 this.is_unreachable = is_unreachable;
204 this.locals = locals;
206 id = ++next_id;
210 // <summary>
211 // This does a deep copy of the usage vector.
212 // </summary>
213 public UsageVector Clone ()
215 UsageVector retval = new UsageVector (Type, null, Block, Location, CountLocals);
217 retval.locals = locals.Clone ();
218 retval.is_unreachable = is_unreachable;
220 return retval;
223 public bool IsAssigned (VariableInfo var, bool ignoreReachability)
225 if (!ignoreReachability && !var.IsParameter && IsUnreachable)
226 return true;
228 return var.IsAssigned (locals);
231 public void SetAssigned (VariableInfo var)
233 if (!var.IsParameter && IsUnreachable)
234 return;
236 var.SetAssigned (locals);
239 public bool IsFieldAssigned (VariableInfo var, string name)
241 if (!var.IsParameter && IsUnreachable)
242 return true;
244 return var.IsFieldAssigned (locals, name);
247 public void SetFieldAssigned (VariableInfo var, string name)
249 if (!var.IsParameter && IsUnreachable)
250 return;
252 var.SetFieldAssigned (locals, name);
255 public bool IsUnreachable {
256 get { return is_unreachable; }
259 public void ResetBarrier ()
261 is_unreachable = false;
264 public void Goto ()
266 is_unreachable = true;
269 public static UsageVector MergeSiblings (UsageVector sibling_list, Location loc)
271 if (sibling_list.Next == null)
272 return sibling_list;
274 MyBitVector locals = null;
275 bool is_unreachable = sibling_list.is_unreachable;
277 if (!sibling_list.IsUnreachable)
278 locals &= sibling_list.locals;
280 for (UsageVector child = sibling_list.Next; child != null; child = child.Next) {
281 is_unreachable &= child.is_unreachable;
283 if (!child.IsUnreachable)
284 locals &= child.locals;
287 return new UsageVector (locals, is_unreachable, null, loc);
290 // <summary>
291 // Merges a child branching.
292 // </summary>
293 public UsageVector MergeChild (UsageVector child, bool overwrite)
295 Report.Debug (2, " MERGING CHILD EFFECTS", this, child, Type);
297 bool new_isunr = child.is_unreachable;
300 // We've now either reached the point after the branching or we will
301 // never get there since we always return or always throw an exception.
303 // If we can reach the point after the branching, mark all locals and
304 // parameters as initialized which have been initialized in all branches
305 // we need to look at (see above).
308 if ((Type == SiblingType.SwitchSection) && !new_isunr) {
309 Report.Error (163, Location,
310 "Control cannot fall through from one " +
311 "case label to another");
312 return child;
315 locals |= child.locals;
317 // throw away un-necessary information about variables in child blocks
318 if (locals.Count != CountLocals)
319 locals = new MyBitVector (locals, CountLocals);
321 if (overwrite)
322 is_unreachable = new_isunr;
323 else
324 is_unreachable |= new_isunr;
326 return child;
329 public void MergeOrigins (UsageVector o_vectors)
331 Report.Debug (1, " MERGING BREAK ORIGINS", this);
333 if (o_vectors == null)
334 return;
336 if (IsUnreachable && locals != null)
337 locals.SetAll (true);
339 for (UsageVector vector = o_vectors; vector != null; vector = vector.Next) {
340 Report.Debug (1, " MERGING BREAK ORIGIN", vector);
341 if (vector.IsUnreachable)
342 continue;
343 locals &= vector.locals;
344 is_unreachable &= vector.is_unreachable;
347 Report.Debug (1, " MERGING BREAK ORIGINS DONE", this);
351 // Debugging stuff.
354 public override string ToString ()
356 return String.Format ("Vector ({0},{1},{2}-{3})", Type, id, is_unreachable, locals);
360 // <summary>
361 // Creates a new flow branching which is contained in `parent'.
362 // You should only pass non-null for the `block' argument if this block
363 // introduces any new variables - in this case, we need to create a new
364 // usage vector with a different size than our parent's one.
365 // </summary>
366 protected FlowBranching (FlowBranching parent, BranchingType type, SiblingType stype,
367 Block block, Location loc)
369 Parent = parent;
370 Block = block;
371 Location = loc;
372 Type = type;
373 id = ++next_id;
375 UsageVector vector;
376 if (Block != null) {
377 UsageVector parent_vector = parent != null ? parent.CurrentUsageVector : null;
378 vector = new UsageVector (stype, parent_vector, Block, loc, Block.AssignableSlots);
379 } else {
380 vector = new UsageVector (stype, Parent.CurrentUsageVector, null, loc);
383 AddSibling (vector);
386 public abstract UsageVector CurrentUsageVector {
387 get;
390 // <summary>
391 // Creates a sibling of the current usage vector.
392 // </summary>
393 public virtual void CreateSibling (Block block, SiblingType type)
395 UsageVector vector = new UsageVector (
396 type, Parent.CurrentUsageVector, block, Location);
397 AddSibling (vector);
399 Report.Debug (1, " CREATED SIBLING", CurrentUsageVector);
402 public void CreateSibling ()
404 CreateSibling (null, SiblingType.Conditional);
407 protected abstract void AddSibling (UsageVector uv);
409 protected abstract UsageVector Merge ();
411 public UsageVector MergeChild (FlowBranching child)
413 return CurrentUsageVector.MergeChild (child.Merge (), true);
416 public virtual bool CheckRethrow (Location loc)
418 return Parent.CheckRethrow (loc);
421 public virtual bool AddResumePoint (ResumableStatement stmt, Location loc, out int pc)
423 return Parent.AddResumePoint (stmt, loc, out pc);
426 // returns true if we crossed an unwind-protected region (try/catch/finally, lock, using, ...)
427 public virtual bool AddBreakOrigin (UsageVector vector, Location loc)
429 return Parent.AddBreakOrigin (vector, loc);
432 // returns true if we crossed an unwind-protected region (try/catch/finally, lock, using, ...)
433 public virtual bool AddContinueOrigin (UsageVector vector, Location loc)
435 return Parent.AddContinueOrigin (vector, loc);
438 // returns true if we crossed an unwind-protected region (try/catch/finally, lock, using, ...)
439 public virtual bool AddReturnOrigin (UsageVector vector, ExitStatement stmt)
441 return Parent.AddReturnOrigin (vector, stmt);
444 // returns true if we crossed an unwind-protected region (try/catch/finally, lock, using, ...)
445 public virtual bool AddGotoOrigin (UsageVector vector, Goto goto_stmt)
447 return Parent.AddGotoOrigin (vector, goto_stmt);
450 public bool IsAssigned (VariableInfo vi)
452 return CurrentUsageVector.IsAssigned (vi, false);
455 public bool IsFieldAssigned (VariableInfo vi, string field_name)
457 return CurrentUsageVector.IsAssigned (vi, false) || CurrentUsageVector.IsFieldAssigned (vi, field_name);
460 protected static Report Report {
461 get { return RootContext.ToplevelTypes.Compiler.Report; }
464 public void SetAssigned (VariableInfo vi)
466 CurrentUsageVector.SetAssigned (vi);
469 public void SetFieldAssigned (VariableInfo vi, string name)
471 CurrentUsageVector.SetFieldAssigned (vi, name);
474 public override string ToString ()
476 StringBuilder sb = new StringBuilder ();
477 sb.Append (GetType ());
478 sb.Append (" (");
480 sb.Append (id);
481 sb.Append (",");
482 sb.Append (Type);
483 if (Block != null) {
484 sb.Append (" - ");
485 sb.Append (Block.ID);
486 sb.Append (" - ");
487 sb.Append (Block.StartLocation);
489 sb.Append (" - ");
490 // sb.Append (Siblings.Length);
491 // sb.Append (" - ");
492 sb.Append (CurrentUsageVector);
493 sb.Append (")");
494 return sb.ToString ();
497 public string Name {
498 get { return String.Format ("{0} ({1}:{2}:{3})", GetType (), id, Type, Location); }
502 public class FlowBranchingBlock : FlowBranching
504 UsageVector sibling_list = null;
506 public FlowBranchingBlock (FlowBranching parent, BranchingType type,
507 SiblingType stype, Block block, Location loc)
508 : base (parent, type, stype, block, loc)
511 public override UsageVector CurrentUsageVector {
512 get { return sibling_list; }
515 protected override void AddSibling (UsageVector sibling)
517 if (sibling_list != null && sibling_list.Type == SiblingType.Block)
518 throw new InternalErrorException ("Blocks don't have sibling flow paths");
519 sibling.Next = sibling_list;
520 sibling_list = sibling;
523 public override bool AddGotoOrigin (UsageVector vector, Goto goto_stmt)
525 LabeledStatement stmt = Block == null ? null : Block.LookupLabel (goto_stmt.Target);
526 if (stmt == null)
527 return Parent.AddGotoOrigin (vector, goto_stmt);
529 // forward jump
530 goto_stmt.SetResolvedTarget (stmt);
531 stmt.AddUsageVector (vector);
532 return false;
535 public static void Error_UnknownLabel (Location loc, string label, Report Report)
537 Report.Error(159, loc, "The label `{0}:' could not be found within the scope of the goto statement",
538 label);
541 protected override UsageVector Merge ()
543 Report.Debug (2, " MERGING SIBLINGS", Name);
544 UsageVector vector = UsageVector.MergeSiblings (sibling_list, Location);
545 Report.Debug (2, " MERGING SIBLINGS DONE", Name, vector);
546 return vector;
550 public class FlowBranchingBreakable : FlowBranchingBlock
552 UsageVector break_origins;
554 public FlowBranchingBreakable (FlowBranching parent, BranchingType type, SiblingType stype, Block block, Location loc)
555 : base (parent, type, stype, block, loc)
558 public override bool AddBreakOrigin (UsageVector vector, Location loc)
560 vector = vector.Clone ();
561 vector.Next = break_origins;
562 break_origins = vector;
563 return false;
566 protected override UsageVector Merge ()
568 UsageVector vector = base.Merge ();
569 vector.MergeOrigins (break_origins);
570 return vector;
574 public class FlowBranchingContinuable : FlowBranchingBlock
576 UsageVector continue_origins;
578 public FlowBranchingContinuable (FlowBranching parent, BranchingType type, SiblingType stype, Block block, Location loc)
579 : base (parent, type, stype, block, loc)
582 public override bool AddContinueOrigin (UsageVector vector, Location loc)
584 vector = vector.Clone ();
585 vector.Next = continue_origins;
586 continue_origins = vector;
587 return false;
590 protected override UsageVector Merge ()
592 UsageVector vector = base.Merge ();
593 vector.MergeOrigins (continue_origins);
594 return vector;
598 public class FlowBranchingLabeled : FlowBranchingBlock
600 LabeledStatement stmt;
601 UsageVector actual;
603 public FlowBranchingLabeled (FlowBranching parent, LabeledStatement stmt)
604 : base (parent, BranchingType.Labeled, SiblingType.Conditional, null, stmt.loc)
606 this.stmt = stmt;
607 CurrentUsageVector.MergeOrigins (stmt.JumpOrigins);
608 actual = CurrentUsageVector.Clone ();
610 // stand-in for backward jumps
611 CurrentUsageVector.ResetBarrier ();
614 public override bool AddGotoOrigin (UsageVector vector, Goto goto_stmt)
616 if (goto_stmt.Target != stmt.Name)
617 return Parent.AddGotoOrigin (vector, goto_stmt);
619 // backward jump
620 goto_stmt.SetResolvedTarget (stmt);
621 actual.MergeOrigins (vector.Clone ());
623 return false;
626 protected override UsageVector Merge ()
628 UsageVector vector = base.Merge ();
630 if (actual.IsUnreachable)
631 Report.Warning (162, 2, stmt.loc, "Unreachable code detected");
633 actual.MergeChild (vector, false);
634 return actual;
638 public class FlowBranchingIterator : FlowBranchingBlock
640 Iterator iterator;
641 public FlowBranchingIterator (FlowBranching parent, Iterator iterator)
642 : base (parent, BranchingType.Iterator, SiblingType.Block, null, iterator.Location)
644 this.iterator = iterator;
647 public override bool AddResumePoint (ResumableStatement stmt, Location loc, out int pc)
649 pc = iterator.AddResumePoint (stmt);
650 return false;
654 public class FlowBranchingToplevel : FlowBranchingBlock
656 UsageVector return_origins;
658 public FlowBranchingToplevel (FlowBranching parent, ToplevelBlock stmt)
659 : base (parent, BranchingType.Toplevel, SiblingType.Conditional, stmt, stmt.loc)
663 public override bool CheckRethrow (Location loc)
665 Report.Error (156, loc, "A throw statement with no arguments is not allowed outside of a catch clause");
666 return false;
669 public override bool AddResumePoint (ResumableStatement stmt, Location loc, out int pc)
671 throw new InternalErrorException ("A yield in a non-iterator block");
674 public override bool AddBreakOrigin (UsageVector vector, Location loc)
676 Report.Error (139, loc, "No enclosing loop out of which to break or continue");
677 return false;
680 public override bool AddContinueOrigin (UsageVector vector, Location loc)
682 Report.Error (139, loc, "No enclosing loop out of which to break or continue");
683 return false;
686 public override bool AddReturnOrigin (UsageVector vector, ExitStatement stmt)
688 vector = vector.Clone ();
689 vector.Location = stmt.loc;
690 vector.Next = return_origins;
691 return_origins = vector;
692 return false;
695 public override bool AddGotoOrigin (UsageVector vector, Goto goto_stmt)
697 string name = goto_stmt.Target;
698 LabeledStatement s = Block.LookupLabel (name);
699 if (s != null)
700 throw new InternalErrorException ("Shouldn't get here");
702 if (Parent == null) {
703 Error_UnknownLabel (goto_stmt.loc, name, Report);
704 return false;
707 int errors = Report.Errors;
708 Parent.AddGotoOrigin (vector, goto_stmt);
709 if (errors == Report.Errors)
710 Report.Error (1632, goto_stmt.loc, "Control cannot leave the body of an anonymous method");
711 return false;
714 protected override UsageVector Merge ()
716 for (UsageVector origin = return_origins; origin != null; origin = origin.Next)
717 Block.Toplevel.CheckOutParameters (origin, origin.Location);
719 UsageVector vector = base.Merge ();
720 Block.Toplevel.CheckOutParameters (vector, Block.loc);
721 // Note: we _do_not_ merge in the return origins
722 return vector;
725 public bool End ()
727 return Merge ().IsUnreachable;
731 public class FlowBranchingTryCatch : FlowBranchingBlock
733 TryCatch stmt;
734 public FlowBranchingTryCatch (FlowBranching parent, TryCatch stmt)
735 : base (parent, BranchingType.Block, SiblingType.Try, null, stmt.loc)
737 this.stmt = stmt;
740 public override bool CheckRethrow (Location loc)
742 return CurrentUsageVector.Next != null || Parent.CheckRethrow (loc);
745 public override bool AddResumePoint (ResumableStatement stmt, Location loc, out int pc)
747 int errors = Report.Errors;
748 Parent.AddResumePoint (stmt, loc, out pc);
749 if (errors == Report.Errors) {
750 if (CurrentUsageVector.Next == null)
751 Report.Error (1626, loc, "Cannot yield a value in the body of a try block with a catch clause");
752 else
753 Report.Error (1631, loc, "Cannot yield a value in the body of a catch clause");
755 return true;
758 public override bool AddBreakOrigin (UsageVector vector, Location loc)
760 Parent.AddBreakOrigin (vector, loc);
761 stmt.SomeCodeFollows ();
762 return true;
765 public override bool AddContinueOrigin (UsageVector vector, Location loc)
767 Parent.AddContinueOrigin (vector, loc);
768 stmt.SomeCodeFollows ();
769 return true;
772 public override bool AddReturnOrigin (UsageVector vector, ExitStatement exit_stmt)
774 Parent.AddReturnOrigin (vector, exit_stmt);
775 stmt.SomeCodeFollows ();
776 return true;
779 public override bool AddGotoOrigin (UsageVector vector, Goto goto_stmt)
781 Parent.AddGotoOrigin (vector, goto_stmt);
782 return true;
786 public class FlowBranchingException : FlowBranching
788 ExceptionStatement stmt;
789 UsageVector current_vector;
790 UsageVector try_vector;
791 UsageVector finally_vector;
793 abstract class SavedOrigin {
794 public readonly SavedOrigin Next;
795 public readonly UsageVector Vector;
797 protected SavedOrigin (SavedOrigin next, UsageVector vector)
799 Next = next;
800 Vector = vector.Clone ();
803 protected abstract void DoPropagateFinally (FlowBranching parent);
804 public void PropagateFinally (UsageVector finally_vector, FlowBranching parent)
806 if (finally_vector != null)
807 Vector.MergeChild (finally_vector, false);
808 DoPropagateFinally (parent);
812 class BreakOrigin : SavedOrigin {
813 Location Loc;
814 public BreakOrigin (SavedOrigin next, UsageVector vector, Location loc)
815 : base (next, vector)
817 Loc = loc;
820 protected override void DoPropagateFinally (FlowBranching parent)
822 parent.AddBreakOrigin (Vector, Loc);
826 class ContinueOrigin : SavedOrigin {
827 Location Loc;
828 public ContinueOrigin (SavedOrigin next, UsageVector vector, Location loc)
829 : base (next, vector)
831 Loc = loc;
834 protected override void DoPropagateFinally (FlowBranching parent)
836 parent.AddContinueOrigin (Vector, Loc);
840 class ReturnOrigin : SavedOrigin {
841 public ExitStatement Stmt;
843 public ReturnOrigin (SavedOrigin next, UsageVector vector, ExitStatement stmt)
844 : base (next, vector)
846 Stmt = stmt;
849 protected override void DoPropagateFinally (FlowBranching parent)
851 parent.AddReturnOrigin (Vector, Stmt);
855 class GotoOrigin : SavedOrigin {
856 public Goto Stmt;
858 public GotoOrigin (SavedOrigin next, UsageVector vector, Goto stmt)
859 : base (next, vector)
861 Stmt = stmt;
864 protected override void DoPropagateFinally (FlowBranching parent)
866 parent.AddGotoOrigin (Vector, Stmt);
870 SavedOrigin saved_origins;
872 public FlowBranchingException (FlowBranching parent,
873 ExceptionStatement stmt)
874 : base (parent, BranchingType.Exception, SiblingType.Try,
875 null, stmt.loc)
877 this.stmt = stmt;
880 protected override void AddSibling (UsageVector sibling)
882 switch (sibling.Type) {
883 case SiblingType.Try:
884 try_vector = sibling;
885 break;
886 case SiblingType.Finally:
887 finally_vector = sibling;
888 break;
889 default:
890 throw new InvalidOperationException ();
892 current_vector = sibling;
895 public override UsageVector CurrentUsageVector {
896 get { return current_vector; }
899 public override bool CheckRethrow (Location loc)
901 if (!Parent.CheckRethrow (loc))
902 return false;
903 if (finally_vector == null)
904 return true;
905 Report.Error (724, loc, "A throw statement with no arguments is not allowed inside of a finally clause nested inside of the innermost catch clause");
906 return false;
909 public override bool AddResumePoint (ResumableStatement stmt, Location loc, out int pc)
911 int errors = Report.Errors;
912 Parent.AddResumePoint (this.stmt, loc, out pc);
913 if (errors == Report.Errors) {
914 if (finally_vector == null)
915 this.stmt.AddResumePoint (stmt, pc);
916 else
917 Report.Error (1625, loc, "Cannot yield in the body of a finally clause");
919 return true;
922 public override bool AddBreakOrigin (UsageVector vector, Location loc)
924 if (finally_vector != null) {
925 int errors = Report.Errors;
926 Parent.AddBreakOrigin (vector, loc);
927 if (errors == Report.Errors)
928 Report.Error (157, loc, "Control cannot leave the body of a finally clause");
929 } else {
930 saved_origins = new BreakOrigin (saved_origins, vector, loc);
933 // either the loop test or a back jump will follow code
934 stmt.SomeCodeFollows ();
935 return true;
938 public override bool AddContinueOrigin (UsageVector vector, Location loc)
940 if (finally_vector != null) {
941 int errors = Report.Errors;
942 Parent.AddContinueOrigin (vector, loc);
943 if (errors == Report.Errors)
944 Report.Error (157, loc, "Control cannot leave the body of a finally clause");
945 } else {
946 saved_origins = new ContinueOrigin (saved_origins, vector, loc);
949 // either the loop test or a back jump will follow code
950 stmt.SomeCodeFollows ();
951 return true;
954 public override bool AddReturnOrigin (UsageVector vector, ExitStatement exit_stmt)
956 if (finally_vector != null) {
957 int errors = Report.Errors;
958 Parent.AddReturnOrigin (vector, exit_stmt);
959 if (errors == Report.Errors)
960 exit_stmt.Error_FinallyClause (Report);
961 } else {
962 saved_origins = new ReturnOrigin (saved_origins, vector, exit_stmt);
965 // sets ec.NeedReturnLabel()
966 stmt.SomeCodeFollows ();
967 return true;
970 public override bool AddGotoOrigin (UsageVector vector, Goto goto_stmt)
972 LabeledStatement s = current_vector.Block == null ? null : current_vector.Block.LookupLabel (goto_stmt.Target);
973 if (s != null)
974 throw new InternalErrorException ("Shouldn't get here");
976 if (finally_vector != null) {
977 int errors = Report.Errors;
978 Parent.AddGotoOrigin (vector, goto_stmt);
979 if (errors == Report.Errors)
980 Report.Error (157, goto_stmt.loc, "Control cannot leave the body of a finally clause");
981 } else {
982 saved_origins = new GotoOrigin (saved_origins, vector, goto_stmt);
984 return true;
987 protected override UsageVector Merge ()
989 UsageVector vector = try_vector.Clone ();
991 if (finally_vector != null)
992 vector.MergeChild (finally_vector, false);
994 for (SavedOrigin origin = saved_origins; origin != null; origin = origin.Next)
995 origin.PropagateFinally (finally_vector, Parent);
997 return vector;
1001 // <summary>
1002 // This is used by the flow analysis code to keep track of the type of local variables
1003 // and variables.
1005 // The flow code uses a BitVector to keep track of whether a variable has been assigned
1006 // or not. This is easy for fundamental types (int, char etc.) or reference types since
1007 // you can only assign the whole variable as such.
1009 // For structs, we also need to keep track of all its fields. To do this, we allocate one
1010 // bit for the struct itself (it's used if you assign/access the whole struct) followed by
1011 // one bit for each of its fields.
1013 // This class computes this `layout' for each type.
1014 // </summary>
1015 public class TypeInfo
1017 public readonly Type Type;
1019 // <summary>
1020 // Total number of bits a variable of this type consumes in the flow vector.
1021 // </summary>
1022 public readonly int TotalLength;
1024 // <summary>
1025 // Number of bits the simple fields of a variable of this type consume
1026 // in the flow vector.
1027 // </summary>
1028 public readonly int Length;
1030 // <summary>
1031 // This is only used by sub-structs.
1032 // </summary>
1033 public readonly int Offset;
1035 // <summary>
1036 // If this is a struct.
1037 // </summary>
1038 public readonly bool IsStruct;
1040 // <summary>
1041 // If this is a struct, all fields which are structs theirselves.
1042 // </summary>
1043 public TypeInfo[] SubStructInfo;
1045 readonly StructInfo struct_info;
1046 private static Hashtable type_hash;
1048 static TypeInfo ()
1050 Reset ();
1053 public static void Reset ()
1055 type_hash = new Hashtable ();
1056 StructInfo.field_type_hash = new Hashtable ();
1059 public static TypeInfo GetTypeInfo (Type type)
1061 TypeInfo info = (TypeInfo) type_hash [type];
1062 if (info != null)
1063 return info;
1065 info = new TypeInfo (type);
1066 type_hash.Add (type, info);
1067 return info;
1070 public static TypeInfo GetTypeInfo (TypeContainer tc)
1072 TypeInfo info = (TypeInfo) type_hash [tc.TypeBuilder];
1073 if (info != null)
1074 return info;
1076 info = new TypeInfo (tc);
1077 type_hash.Add (tc.TypeBuilder, info);
1078 return info;
1081 private TypeInfo (Type type)
1083 this.Type = type;
1085 struct_info = StructInfo.GetStructInfo (type);
1086 if (struct_info != null) {
1087 Length = struct_info.Length;
1088 TotalLength = struct_info.TotalLength;
1089 SubStructInfo = struct_info.StructFields;
1090 IsStruct = true;
1091 } else {
1092 Length = 0;
1093 TotalLength = 1;
1094 IsStruct = false;
1098 private TypeInfo (TypeContainer tc)
1100 this.Type = tc.TypeBuilder;
1102 struct_info = StructInfo.GetStructInfo (tc);
1103 if (struct_info != null) {
1104 Length = struct_info.Length;
1105 TotalLength = struct_info.TotalLength;
1106 SubStructInfo = struct_info.StructFields;
1107 IsStruct = true;
1108 } else {
1109 Length = 0;
1110 TotalLength = 1;
1111 IsStruct = false;
1115 TypeInfo (StructInfo struct_info, int offset)
1117 this.struct_info = struct_info;
1118 this.Offset = offset;
1119 this.Length = struct_info.Length;
1120 this.TotalLength = struct_info.TotalLength;
1121 this.SubStructInfo = struct_info.StructFields;
1122 this.Type = struct_info.Type;
1123 this.IsStruct = true;
1126 public int GetFieldIndex (string name)
1128 if (struct_info == null)
1129 return 0;
1131 return struct_info [name];
1134 public TypeInfo GetSubStruct (string name)
1136 if (struct_info == null)
1137 return null;
1139 return struct_info.GetStructField (name);
1142 // <summary>
1143 // A struct's constructor must always assign all fields.
1144 // This method checks whether it actually does so.
1145 // </summary>
1146 public bool IsFullyInitialized (BlockContext ec, VariableInfo vi, Location loc)
1148 if (struct_info == null)
1149 return true;
1151 bool ok = true;
1152 FlowBranching branching = ec.CurrentBranching;
1153 for (int i = 0; i < struct_info.Count; i++) {
1154 FieldInfo field = struct_info.Fields [i];
1156 if (!branching.IsFieldAssigned (vi, field.Name)) {
1157 FieldBase fb = TypeManager.GetField (field);
1158 if (fb is Property.BackingField) {
1159 ec.Report.Error (843, loc,
1160 "An automatically implemented property `{0}' must be fully assigned before control leaves the constructor. Consider calling default contructor",
1161 fb.GetSignatureForError ());
1162 } else {
1163 ec.Report.Error (171, loc,
1164 "Field `{0}' must be fully assigned before control leaves the constructor",
1165 TypeManager.GetFullNameSignature (field));
1167 ok = false;
1171 return ok;
1174 public override string ToString ()
1176 return String.Format ("TypeInfo ({0}:{1}:{2}:{3})",
1177 Type, Offset, Length, TotalLength);
1180 class StructInfo {
1181 public readonly Type Type;
1182 public readonly FieldInfo[] Fields;
1183 public readonly TypeInfo[] StructFields;
1184 public readonly int Count;
1185 public readonly int CountPublic;
1186 public readonly int CountNonPublic;
1187 public readonly int Length;
1188 public readonly int TotalLength;
1189 public readonly bool HasStructFields;
1191 public static Hashtable field_type_hash;
1192 private Hashtable struct_field_hash;
1193 private Hashtable field_hash;
1195 protected bool InTransit = false;
1197 // Private constructor. To save memory usage, we only need to create one instance
1198 // of this class per struct type.
1199 private StructInfo (Type type)
1201 this.Type = type;
1203 field_type_hash.Add (type, this);
1205 if (TypeManager.IsBeingCompiled (type)) {
1206 TypeContainer tc = TypeManager.LookupTypeContainer (TypeManager.DropGenericTypeArguments (type));
1208 ArrayList public_fields = new ArrayList ();
1209 ArrayList non_public_fields = new ArrayList ();
1212 // TODO: tc != null is needed because FixedBuffers are not cached
1214 if (tc != null) {
1215 ArrayList fields = tc.Fields;
1217 if (fields != null) {
1218 foreach (FieldBase field in fields) {
1219 if ((field.ModFlags & Modifiers.STATIC) != 0)
1220 continue;
1221 if ((field.ModFlags & Modifiers.PUBLIC) != 0)
1222 public_fields.Add (field.FieldBuilder);
1223 else
1224 non_public_fields.Add (field.FieldBuilder);
1229 CountPublic = public_fields.Count;
1230 CountNonPublic = non_public_fields.Count;
1231 Count = CountPublic + CountNonPublic;
1233 Fields = new FieldInfo [Count];
1234 public_fields.CopyTo (Fields, 0);
1235 non_public_fields.CopyTo (Fields, CountPublic);
1236 } else if (type is GenericTypeParameterBuilder) {
1237 CountPublic = CountNonPublic = Count = 0;
1239 Fields = new FieldInfo [0];
1240 } else {
1241 FieldInfo[] public_fields = type.GetFields (
1242 BindingFlags.Instance|BindingFlags.Public);
1243 FieldInfo[] non_public_fields = type.GetFields (
1244 BindingFlags.Instance|BindingFlags.NonPublic);
1246 CountPublic = public_fields.Length;
1247 CountNonPublic = non_public_fields.Length;
1248 Count = CountPublic + CountNonPublic;
1250 Fields = new FieldInfo [Count];
1251 public_fields.CopyTo (Fields, 0);
1252 non_public_fields.CopyTo (Fields, CountPublic);
1255 struct_field_hash = new Hashtable ();
1256 field_hash = new Hashtable ();
1258 Length = 0;
1259 StructFields = new TypeInfo [Count];
1260 StructInfo[] sinfo = new StructInfo [Count];
1262 InTransit = true;
1264 for (int i = 0; i < Count; i++) {
1265 FieldInfo field = (FieldInfo) Fields [i];
1267 sinfo [i] = GetStructInfo (field.FieldType);
1268 if (sinfo [i] == null)
1269 field_hash.Add (field.Name, ++Length);
1270 else if (sinfo [i].InTransit) {
1271 RootContext.ToplevelTypes.Compiler.Report.Error (523, String.Format (
1272 "Struct member `{0}.{1}' of type `{2}' causes " +
1273 "a cycle in the structure layout",
1274 type, field.Name, sinfo [i].Type));
1275 sinfo [i] = null;
1276 return;
1280 InTransit = false;
1282 TotalLength = Length + 1;
1283 for (int i = 0; i < Count; i++) {
1284 FieldInfo field = (FieldInfo) Fields [i];
1286 if (sinfo [i] == null)
1287 continue;
1289 field_hash.Add (field.Name, TotalLength);
1291 HasStructFields = true;
1292 StructFields [i] = new TypeInfo (sinfo [i], TotalLength);
1293 struct_field_hash.Add (field.Name, StructFields [i]);
1294 TotalLength += sinfo [i].TotalLength;
1298 public int this [string name] {
1299 get {
1300 if (field_hash.Contains (name))
1301 return (int) field_hash [name];
1302 else
1303 return 0;
1307 public TypeInfo GetStructField (string name)
1309 return (TypeInfo) struct_field_hash [name];
1312 public static StructInfo GetStructInfo (Type type)
1314 if (!TypeManager.IsValueType (type) || TypeManager.IsEnumType (type) ||
1315 TypeManager.IsBuiltinType (type))
1316 return null;
1318 if (TypeManager.IsGenericParameter (type))
1319 return null;
1321 StructInfo info = (StructInfo) field_type_hash [type];
1322 if (info != null)
1323 return info;
1325 return new StructInfo (type);
1328 public static StructInfo GetStructInfo (TypeContainer tc)
1330 StructInfo info = (StructInfo) field_type_hash [tc.TypeBuilder];
1331 if (info != null)
1332 return info;
1334 return new StructInfo (tc.TypeBuilder);
1339 // <summary>
1340 // This is used by the flow analysis code to store information about a single local variable
1341 // or parameter. Depending on the variable's type, we need to allocate one or more elements
1342 // in the BitVector - if it's a fundamental or reference type, we just need to know whether
1343 // it has been assigned or not, but for structs, we need this information for each of its fields.
1344 // </summary>
1345 public class VariableInfo {
1346 public readonly string Name;
1347 public readonly TypeInfo TypeInfo;
1349 // <summary>
1350 // The bit offset of this variable in the flow vector.
1351 // </summary>
1352 public readonly int Offset;
1354 // <summary>
1355 // The number of bits this variable needs in the flow vector.
1356 // The first bit always specifies whether the variable as such has been assigned while
1357 // the remaining bits contain this information for each of a struct's fields.
1358 // </summary>
1359 public readonly int Length;
1361 // <summary>
1362 // If this is a parameter of local variable.
1363 // </summary>
1364 public readonly bool IsParameter;
1366 public readonly LocalInfo LocalInfo;
1368 readonly VariableInfo Parent;
1369 VariableInfo[] sub_info;
1371 bool is_ever_assigned;
1372 public bool IsEverAssigned {
1373 get { return is_ever_assigned; }
1376 protected VariableInfo (string name, Type type, int offset)
1378 this.Name = name;
1379 this.Offset = offset;
1380 this.TypeInfo = TypeInfo.GetTypeInfo (type);
1382 Length = TypeInfo.TotalLength;
1384 Initialize ();
1387 protected VariableInfo (VariableInfo parent, TypeInfo type)
1389 this.Name = parent.Name;
1390 this.TypeInfo = type;
1391 this.Offset = parent.Offset + type.Offset;
1392 this.Parent = parent;
1393 this.Length = type.TotalLength;
1395 this.IsParameter = parent.IsParameter;
1396 this.LocalInfo = parent.LocalInfo;
1398 Initialize ();
1401 protected void Initialize ()
1403 TypeInfo[] sub_fields = TypeInfo.SubStructInfo;
1404 if (sub_fields != null) {
1405 sub_info = new VariableInfo [sub_fields.Length];
1406 for (int i = 0; i < sub_fields.Length; i++) {
1407 if (sub_fields [i] != null)
1408 sub_info [i] = new VariableInfo (this, sub_fields [i]);
1410 } else
1411 sub_info = new VariableInfo [0];
1414 public VariableInfo (LocalInfo local_info, int offset)
1415 : this (local_info.Name, local_info.VariableType, offset)
1417 this.LocalInfo = local_info;
1418 this.IsParameter = false;
1421 public VariableInfo (ParametersCompiled ip, int i, int offset)
1422 : this (ip.FixedParameters [i].Name, ip.Types [i], offset)
1424 this.IsParameter = true;
1427 public bool IsAssigned (ResolveContext ec)
1429 return !ec.DoFlowAnalysis ||
1430 ec.OmitStructFlowAnalysis && TypeInfo.IsStruct ||
1431 ec.CurrentBranching.IsAssigned (this);
1434 public bool IsAssigned (ResolveContext ec, Location loc)
1436 if (IsAssigned (ec))
1437 return true;
1439 ec.Report.Error (165, loc,
1440 "Use of unassigned local variable `" + Name + "'");
1441 ec.CurrentBranching.SetAssigned (this);
1442 return false;
1445 public bool IsAssigned (MyBitVector vector)
1447 if (vector == null)
1448 return true;
1450 if (vector [Offset])
1451 return true;
1453 // FIXME: Fix SetFieldAssigned to set the whole range like SetAssigned below. Then, get rid of this stanza
1454 for (VariableInfo parent = Parent; parent != null; parent = parent.Parent) {
1455 if (vector [parent.Offset]) {
1456 // 'parent' is assigned, but someone forgot to note that all its components are assigned too
1457 parent.SetAssigned (vector);
1458 return true;
1462 // Return unless this is a struct.
1463 if (!TypeInfo.IsStruct)
1464 return false;
1466 // Ok, so each field must be assigned.
1467 for (int i = 0; i < TypeInfo.Length; i++) {
1468 if (!vector [Offset + i + 1])
1469 return false;
1472 // Ok, now check all fields which are structs.
1473 for (int i = 0; i < sub_info.Length; i++) {
1474 VariableInfo sinfo = sub_info [i];
1475 if (sinfo == null)
1476 continue;
1478 if (!sinfo.IsAssigned (vector))
1479 return false;
1482 vector [Offset] = true;
1483 is_ever_assigned = true;
1484 return true;
1487 public void SetAssigned (ResolveContext ec)
1489 if (ec.DoFlowAnalysis)
1490 ec.CurrentBranching.SetAssigned (this);
1493 public void SetAssigned (MyBitVector vector)
1495 if (Length == 1)
1496 vector [Offset] = true;
1497 else
1498 vector.SetRange (Offset, Length);
1499 is_ever_assigned = true;
1502 public bool IsFieldAssigned (ResolveContext ec, string name, Location loc)
1504 if (!ec.DoFlowAnalysis ||
1505 ec.OmitStructFlowAnalysis && TypeInfo.IsStruct ||
1506 ec.CurrentBranching.IsFieldAssigned (this, name))
1507 return true;
1509 ec.Report.Error (170, loc,
1510 "Use of possibly unassigned field `" + name + "'");
1511 ec.CurrentBranching.SetFieldAssigned (this, name);
1512 return false;
1515 public bool IsFieldAssigned (MyBitVector vector, string field_name)
1517 int field_idx = TypeInfo.GetFieldIndex (field_name);
1519 if (field_idx == 0)
1520 return true;
1522 return vector [Offset + field_idx];
1525 public void SetFieldAssigned (ResolveContext ec, string name)
1527 if (ec.DoFlowAnalysis)
1528 ec.CurrentBranching.SetFieldAssigned (this, name);
1531 public void SetFieldAssigned (MyBitVector vector, string field_name)
1533 int field_idx = TypeInfo.GetFieldIndex (field_name);
1535 if (field_idx == 0)
1536 return;
1538 vector [Offset + field_idx] = true;
1539 is_ever_assigned = true;
1542 public VariableInfo GetSubStruct (string name)
1544 TypeInfo type = TypeInfo.GetSubStruct (name);
1546 if (type == null)
1547 return null;
1549 return new VariableInfo (this, type);
1552 public override string ToString ()
1554 return String.Format ("VariableInfo ({0}:{1}:{2}:{3}:{4})",
1555 Name, TypeInfo, Offset, Length, IsParameter);
1559 // <summary>
1560 // This is a special bit vector which can inherit from another bit vector doing a
1561 // copy-on-write strategy. The inherited vector may have a smaller size than the
1562 // current one.
1563 // </summary>
1564 public class MyBitVector {
1565 public readonly int Count;
1566 public static readonly MyBitVector Empty = new MyBitVector ();
1568 // Invariant: vector != null => vector.Count == Count
1569 // Invariant: vector == null || shared == null
1570 // i.e., at most one of 'vector' and 'shared' can be non-null. They can both be null -- that means all-ones
1571 // The object in 'shared' cannot be modified, while 'vector' can be freely modified
1572 BitArray vector, shared;
1574 MyBitVector ()
1576 shared = new BitArray (0, false);
1579 public MyBitVector (MyBitVector InheritsFrom, int Count)
1581 if (InheritsFrom != null)
1582 shared = InheritsFrom.MakeShared (Count);
1584 this.Count = Count;
1587 BitArray MakeShared (int new_count)
1589 // Post-condition: vector == null
1591 // ensure we don't leak out dirty bits from the BitVector we inherited from
1592 if (new_count > Count &&
1593 ((shared != null && shared.Count > Count) ||
1594 (shared == null && vector == null)))
1595 initialize_vector ();
1597 if (vector != null) {
1598 shared = vector;
1599 vector = null;
1602 return shared;
1605 // <summary>
1606 // Get/set bit `index' in the bit vector.
1607 // </summary>
1608 public bool this [int index] {
1609 get {
1610 if (index >= Count)
1611 // FIXME: Disabled due to missing anonymous method flow analysis
1612 // throw new ArgumentOutOfRangeException ();
1613 return true;
1615 if (vector != null)
1616 return vector [index];
1617 if (shared == null)
1618 return true;
1619 if (index < shared.Count)
1620 return shared [index];
1621 return false;
1624 set {
1625 // Only copy the vector if we're actually modifying it.
1626 if (this [index] != value) {
1627 if (vector == null)
1628 initialize_vector ();
1629 vector [index] = value;
1634 // <summary>
1635 // Performs an `or' operation on the bit vector. The `new_vector' may have a
1636 // different size than the current one.
1637 // </summary>
1638 private MyBitVector Or (MyBitVector new_vector)
1640 if (Count == 0 || new_vector.Count == 0)
1641 return this;
1643 BitArray o = new_vector.vector != null ? new_vector.vector : new_vector.shared;
1645 if (o == null) {
1646 int n = new_vector.Count;
1647 if (n < Count) {
1648 for (int i = 0; i < n; ++i)
1649 this [i] = true;
1650 } else {
1651 SetAll (true);
1653 return this;
1656 if (Count == o.Count) {
1657 if (vector == null) {
1658 if (shared == null)
1659 return this;
1660 initialize_vector ();
1662 vector.Or (o);
1663 return this;
1666 int min = o.Count;
1667 if (Count < min)
1668 min = Count;
1670 for (int i = 0; i < min; i++) {
1671 if (o [i])
1672 this [i] = true;
1675 return this;
1678 // <summary>
1679 // Performs an `and' operation on the bit vector. The `new_vector' may have
1680 // a different size than the current one.
1681 // </summary>
1682 private MyBitVector And (MyBitVector new_vector)
1684 if (Count == 0)
1685 return this;
1687 BitArray o = new_vector.vector != null ? new_vector.vector : new_vector.shared;
1689 if (o == null) {
1690 for (int i = new_vector.Count; i < Count; ++i)
1691 this [i] = false;
1692 return this;
1695 if (o.Count == 0) {
1696 SetAll (false);
1697 return this;
1700 if (Count == o.Count) {
1701 if (vector == null) {
1702 if (shared == null) {
1703 shared = new_vector.MakeShared (Count);
1704 return this;
1706 initialize_vector ();
1708 vector.And (o);
1709 return this;
1712 int min = o.Count;
1713 if (Count < min)
1714 min = Count;
1716 for (int i = 0; i < min; i++) {
1717 if (! o [i])
1718 this [i] = false;
1721 for (int i = min; i < Count; i++)
1722 this [i] = false;
1724 return this;
1727 public static MyBitVector operator & (MyBitVector a, MyBitVector b)
1729 if (a == b)
1730 return a;
1731 if (a == null)
1732 return b.Clone ();
1733 if (b == null)
1734 return a.Clone ();
1735 if (a.Count > b.Count)
1736 return a.Clone ().And (b);
1737 else
1738 return b.Clone ().And (a);
1741 public static MyBitVector operator | (MyBitVector a, MyBitVector b)
1743 if (a == b)
1744 return a;
1745 if (a == null)
1746 return new MyBitVector (null, b.Count);
1747 if (b == null)
1748 return new MyBitVector (null, a.Count);
1749 if (a.Count > b.Count)
1750 return a.Clone ().Or (b);
1751 else
1752 return b.Clone ().Or (a);
1755 public MyBitVector Clone ()
1757 return Count == 0 ? Empty : new MyBitVector (this, Count);
1760 public void SetRange (int offset, int length)
1762 if (offset > Count || offset + length > Count)
1763 throw new ArgumentOutOfRangeException ();
1765 if (shared == null && vector == null)
1766 return;
1768 int i = 0;
1769 if (shared != null) {
1770 if (offset + length <= shared.Count) {
1771 for (; i < length; ++i)
1772 if (!shared [i+offset])
1773 break;
1774 if (i == length)
1775 return;
1777 initialize_vector ();
1779 for (; i < length; ++i)
1780 vector [i+offset] = true;
1784 public void SetAll (bool value)
1786 // Don't clobber Empty
1787 if (Count == 0)
1788 return;
1789 shared = value ? null : Empty.MakeShared (Count);
1790 vector = null;
1793 void initialize_vector ()
1795 // Post-condition: vector != null
1796 if (shared == null) {
1797 vector = new BitArray (Count, true);
1798 return;
1801 vector = new BitArray (shared);
1802 if (Count != vector.Count)
1803 vector.Length = Count;
1804 shared = null;
1807 StringBuilder Dump (StringBuilder sb)
1809 BitArray dump = vector == null ? shared : vector;
1810 if (dump == null)
1811 return sb.Append ("/");
1812 if (dump == shared)
1813 sb.Append ("=");
1814 for (int i = 0; i < dump.Count; i++)
1815 sb.Append (dump [i] ? "1" : "0");
1816 return sb;
1819 public override string ToString ()
1821 return Dump (new StringBuilder ("{")).Append ("}").ToString ();