2 // eval.cs: Evaluation and Hosting API for the C# compiler
5 // Miguel de Icaza (miguel@gnome.org)
7 // Dual licensed under the terms of the MIT X11 or GNU GPL
9 // Copyright 2001, 2002, 2003 Ximian, Inc (http://www.ximian.com)
10 // Copyright 2004, 2005, 2006, 2007, 2008 Novell, Inc
13 using System.Threading;
14 using System.Collections;
15 using System.Reflection;
16 using System.Reflection.Emit;
18 using System.Globalization;
21 namespace Mono.CSharp {
24 /// Evaluator: provides an API to evaluate C# statements and
25 /// expressions dynamically.
28 /// This class exposes static methods to evaluate expressions in the
31 /// To initialize the evaluator with a number of compiler
32 /// options call the Init(string[]args) method with a set of
33 /// command line options that the compiler recognizes.
35 /// To interrupt execution of a statement, you can invoke the
36 /// Evaluator.Interrupt method.
38 public class Evaluator {
41 // Parse silently, do not output any error messages
44 // Report errors during parse
47 // Auto-complete, means that the tokenizer will start producing
48 // GETCOMPLETIONS tokens when it reaches a certain point.
52 static object evaluator_lock = new object ();
54 static string current_debug_name;
56 static Thread invoke_thread;
58 static ArrayList using_alias_list = new ArrayList ();
59 internal static ArrayList using_list = new ArrayList ();
60 static Hashtable fields = new Hashtable ();
62 static Type interactive_base_class = typeof (InteractiveBase);
67 /// Optional initialization for the Evaluator.
70 /// Initializes the Evaluator with the command line options
71 /// that would be processed by the command line compiler. Only
72 /// the first call to Init will work, any future invocations are
75 /// You can safely avoid calling this method if your application
76 /// does not need any of the features exposed by the command line
79 public static void Init (string [] args)
81 InitAndGetStartupFiles (args);
86 /// Optional initialization for the Evaluator.
89 /// Initializes the Evaluator with the command line
90 /// options that would be processed by the command
91 /// line compiler. Only the first call to
92 /// InitAndGetStartupFiles or Init will work, any future
93 /// invocations are ignored.
95 /// You can safely avoid calling this method if your application
96 /// does not need any of the features exposed by the command line
99 /// This method return an array of strings that contains any
100 /// files that were specified in `args'.
102 public static string [] InitAndGetStartupFiles (string [] args)
104 lock (evaluator_lock){
106 return new string [0];
108 driver = Driver.Create (args, false);
110 throw new Exception ("Failed to create compiler driver with the given arguments");
112 driver.ProcessDefaultConfig ();
114 ArrayList startup_files = new ArrayList ();
115 foreach (CompilationUnit file in Location.SourceFiles)
116 startup_files.Add (file.Path);
118 CompilerCallableEntryPoint.Reset ();
119 driver.LoadReferences ();
120 RootContext.EvalMode = true;
123 return (string []) startup_files.ToArray (typeof (string));
129 Init (new string [0]);
134 CompilerCallableEntryPoint.PartialReset ();
137 // PartialReset should not reset the core types, this is very redundant.
139 if (!TypeManager.InitCoreTypes ())
140 throw new Exception ("Failed to InitCoreTypes");
141 TypeManager.InitOptionalCoreTypes ();
143 Location.AddFile ("{interactive}");
144 Location.Initialize ();
146 current_debug_name = "interactive" + (count++) + ".dll";
147 if (Environment.GetEnvironmentVariable ("SAVE") != null){
148 CodeGen.Init (current_debug_name, current_debug_name, false);
150 CodeGen.InitDynamic (current_debug_name);
154 /// The base class for the classes that host the user generated code
158 /// This is the base class that will host the code
159 /// executed by the Evaluator. By default
160 /// this is the Mono.CSharp.InteractiveBase class
161 /// which is useful for interactive use.
163 /// By changing this property you can control the
164 /// base class and the static members that are
165 /// available to your evaluated code.
167 static public Type InteractiveBaseClass {
169 return interactive_base_class;
174 throw new ArgumentNullException ();
176 lock (evaluator_lock)
177 interactive_base_class = value;
182 /// Interrupts the evaluation of an expression executing in Evaluate.
185 /// Use this method to interrupt long-running invocations.
187 public static void Interrupt ()
189 if (!inited || !invoking)
192 if (invoke_thread != null)
193 invoke_thread.Abort ();
197 /// Compiles the input string and returns a delegate that represents the compiled code.
201 /// Compiles the input string as a C# expression or
202 /// statement, unlike the Evaluate method, the
203 /// resulting delegate can be invoked multiple times
204 /// without incurring in the compilation overhead.
206 /// If the return value of this function is null,
207 /// this indicates that the parsing was complete.
208 /// If the return value is a string it indicates
209 /// that the input string was partial and that the
210 /// invoking code should provide more code before
211 /// the code can be successfully compiled.
213 /// If you know that you will always get full expressions or
214 /// statements and do not care about partial input, you can use
215 /// the other Compile overload.
217 /// On success, in addition to returning null, the
218 /// compiled parameter will be set to the delegate
219 /// that can be invoked to execute the code.
222 static public string Compile (string input, out CompiledMethod compiled)
224 if (input == null || input.Length == 0){
229 lock (evaluator_lock){
234 CSharpParser parser = ParseString (ParseMode.Silent, input, out partial_input);
240 ParseString (ParseMode.ReportErrors, input, out partial_input);
244 object parser_result = parser.InteractiveResult;
246 if (!(parser_result is Class)){
247 int errors = Report.Errors;
249 NamespaceEntry.VerifyAllUsing ();
250 if (errors == Report.Errors)
251 parser.CurrentNamespace.Extract (using_alias_list, using_list);
254 compiled = CompileBlock (parser_result as Class, parser.undo);
261 /// Compiles the input string and returns a delegate that represents the compiled code.
265 /// Compiles the input string as a C# expression or
266 /// statement, unlike the Evaluate method, the
267 /// resulting delegate can be invoked multiple times
268 /// without incurring in the compilation overhead.
270 /// This method can only deal with fully formed input
271 /// strings and does not provide a completion mechanism.
272 /// If you must deal with partial input (for example for
273 /// interactive use) use the other overload.
275 /// On success, a delegate is returned that can be used
276 /// to invoke the method.
279 static public CompiledMethod Compile (string input)
281 CompiledMethod compiled;
283 // Ignore partial inputs
284 if (Compile (input, out compiled) != null){
285 // Error, the input was partial.
289 // Either null (on error) or the compiled method.
294 // Todo: Should we handle errors, or expect the calling code to setup
295 // the recording themselves?
299 /// Evaluates and expression or statement and returns any result values.
302 /// Evaluates the input string as a C# expression or
303 /// statement. If the input string is an expression
304 /// the result will be stored in the result variable
305 /// and the result_set variable will be set to true.
307 /// It is necessary to use the result/result_set
308 /// pair to identify when a result was set (for
309 /// example, execution of user-provided input can be
310 /// an expression, a statement or others, and
311 /// result_set would only be set if the input was an
314 /// If the return value of this function is null,
315 /// this indicates that the parsing was complete.
316 /// If the return value is a string, it indicates
317 /// that the input is partial and that the user
318 /// should provide an updated string.
320 public static string Evaluate (string input, out object result, out bool result_set)
322 CompiledMethod compiled;
327 input = Compile (input, out compiled);
331 if (compiled == null)
335 // The code execution does not need to keep the compiler lock
337 object retval = typeof (NoValueSet);
340 invoke_thread = System.Threading.Thread.CurrentThread;
342 compiled (ref retval);
343 } catch (ThreadAbortException e){
344 Thread.ResetAbort ();
345 Console.WriteLine ("Interrupted!\n{0}", e);
351 // We use a reference to a compiler type, in this case
352 // Driver as a flag to indicate that this was a statement
354 if (retval != typeof (NoValueSet)){
362 public static string [] GetCompletions (string input, out string prefix)
365 if (input == null || input.Length == 0)
368 lock (evaluator_lock){
373 CSharpParser parser = ParseString (ParseMode.GetCompletions, input, out partial_input);
375 if (CSharpParser.yacc_verbose_flag != 0)
376 Console.WriteLine ("DEBUG: No completions available");
380 Class parser_result = parser.InteractiveResult as Class;
382 if (parser_result == null){
383 if (CSharpParser.yacc_verbose_flag != 0)
384 Console.WriteLine ("Do not know how to cope with !Class yet");
389 RootContext.ResolveTree ();
390 if (Report.Errors != 0)
393 RootContext.PopulateTypes ();
394 if (Report.Errors != 0)
397 MethodOrOperator method = null;
398 foreach (MemberCore member in parser_result.Methods){
399 if (member.Name != "Host")
402 method = (MethodOrOperator) member;
406 throw new InternalErrorException ("did not find the the Host method");
408 BlockContext bc = new BlockContext (method, method.Block, method.ReturnType);
411 method.Block.Resolve (null, bc, method.ParameterInfo, method);
412 } catch (CompletionResult cr){
413 prefix = cr.BaseText;
417 parser.undo.ExecuteUndo ();
425 /// Executes the given expression or statement.
428 /// Executes the provided statement, returns true
429 /// on success, false on parsing errors. Exceptions
430 /// might be thrown by the called code.
432 public static bool Run (string statement)
440 bool ok = Evaluate (statement, out result, out result_set) == null;
446 /// Evaluates and expression or statement and returns the result.
449 /// Evaluates the input string as a C# expression or
450 /// statement and returns the value.
452 /// This method will throw an exception if there is a syntax error,
453 /// of if the provided input is not an expression but a statement.
455 public static object Evaluate (string input)
460 string r = Evaluate (input, out result, out result_set);
463 throw new ArgumentException ("Syntax error on input: partial input");
465 if (result_set == false)
466 throw new ArgumentException ("The expression did not set a result");
473 StatementOrExpression,
479 // Deambiguates the input string to determine if we
480 // want to process a statement or if we want to
481 // process a compilation unit.
483 // This is done using a top-down predictive parser,
484 // since the yacc/jay parser can not deambiguage this
485 // without more than one lookahead token. There are very
488 static InputKind ToplevelOrStatement (SeekableStreamReader seekable)
490 Tokenizer tokenizer = new Tokenizer (seekable, (CompilationUnit) Location.SourceFiles [0]);
492 int t = tokenizer.token ();
495 return InputKind.EOF;
497 // These are toplevels
499 case Token.OPEN_BRACKET:
503 case Token.INTERFACE:
505 case Token.NAMESPACE:
507 case Token.PROTECTED:
512 return InputKind.CompilationUnit;
514 // Definitely expression
531 return InputKind.StatementOrExpression;
533 // These need deambiguation help
535 t = tokenizer.token ();
537 return InputKind.EOF;
539 if (t == Token.IDENTIFIER)
540 return InputKind.CompilationUnit;
541 return InputKind.StatementOrExpression;
544 // Distinguish between:
545 // delegate opt_anonymous_method_signature block
548 t = tokenizer.token ();
550 return InputKind.EOF;
551 if (t == Token.OPEN_PARENS || t == Token.OPEN_BRACE)
552 return InputKind.StatementOrExpression;
553 return InputKind.CompilationUnit;
555 // Distinguih between:
557 // unsafe as modifier of a type declaration
559 t = tokenizer.token ();
561 return InputKind.EOF;
562 if (t == Token.OPEN_PARENS)
563 return InputKind.StatementOrExpression;
564 return InputKind.CompilationUnit;
566 // These are errors: we list explicitly what we had
567 // from the grammar, ERROR and then everything else
572 return InputKind.Error;
574 // This catches everything else allowed by
575 // expressions. We could add one-by-one use cases
578 return InputKind.StatementOrExpression;
583 // Parses the string @input and returns a CSharpParser if succeeful.
585 // if @silent is set to true then no errors are
586 // reported to the user. This is used to do various calls to the
587 // parser and check if the expression is parsable.
589 // @partial_input: if @silent is true, then it returns whether the
590 // parsed expression was partial, and more data is needed
592 static CSharpParser ParseString (ParseMode mode, string input, out bool partial_input)
594 partial_input = false;
596 queued_fields.Clear ();
598 Stream s = new MemoryStream (Encoding.Default.GetBytes (input));
599 SeekableStreamReader seekable = new SeekableStreamReader (s, Encoding.Default);
601 InputKind kind = ToplevelOrStatement (seekable);
602 if (kind == InputKind.Error){
603 if (mode == ParseMode.ReportErrors)
604 Report.Error (-25, "Detection Parsing Error");
605 partial_input = false;
609 if (kind == InputKind.EOF){
610 if (mode == ParseMode.ReportErrors)
611 Console.Error.WriteLine ("Internal error: EOF condition should have been detected in a previous call with silent=true");
612 partial_input = true;
616 seekable.Position = 0;
618 CSharpParser parser = new CSharpParser (seekable, (CompilationUnit) Location.SourceFiles [0]);
619 parser.ErrorOutput = Report.Stderr;
621 if (kind == InputKind.StatementOrExpression){
622 parser.Lexer.putback_char = Tokenizer.EvalStatementParserCharacter;
623 RootContext.StatementMode = true;
626 // Do not activate EvalCompilationUnitParserCharacter until
627 // I have figured out all the limitations to invoke methods
628 // in the generated classes. See repl.txt
630 parser.Lexer.putback_char = Tokenizer.EvalUsingDeclarationsParserCharacter;
631 //parser.Lexer.putback_char = Tokenizer.EvalCompilationUnitParserCharacter;
632 RootContext.StatementMode = false;
635 if (mode == ParseMode.GetCompletions)
636 parser.Lexer.CompleteOnEOF = true;
638 bool disable_error_reporting;
639 if ((mode == ParseMode.Silent || mode == ParseMode.GetCompletions) && CSharpParser.yacc_verbose_flag == 0)
640 disable_error_reporting = true;
642 disable_error_reporting = false;
644 if (disable_error_reporting)
645 Report.DisableReporting ();
649 if (Report.Errors != 0){
650 if (mode != ParseMode.ReportErrors && parser.UnexpectedEOF)
651 partial_input = true;
653 parser.undo.ExecuteUndo ();
657 if (disable_error_reporting)
658 Report.EnableReporting ();
664 // Queue all the fields that we use, as we need to then go from FieldBuilder to FieldInfo
665 // or reflection gets confused (it basically gets confused, and variables override each
668 static ArrayList queued_fields = new ArrayList ();
670 //static ArrayList types = new ArrayList ();
672 static volatile bool invoking;
674 static CompiledMethod CompileBlock (Class host, Undo undo)
676 RootContext.ResolveTree ();
677 if (Report.Errors != 0){
682 RootContext.PopulateTypes ();
684 if (Report.Errors != 0){
689 TypeBuilder tb = null;
690 MethodBuilder mb = null;
693 tb = host.TypeBuilder;
695 foreach (MemberCore member in host.Methods){
696 if (member.Name != "Host")
699 MethodOrOperator method = (MethodOrOperator) member;
700 mb = method.MethodBuilder;
705 throw new Exception ("Internal error: did not find the method builder for the generated method");
708 RootContext.EmitCode ();
709 if (Report.Errors != 0)
712 RootContext.CloseTypes ();
714 if (Environment.GetEnvironmentVariable ("SAVE") != null)
715 CodeGen.Save (current_debug_name, false);
721 // Unlike Mono, .NET requires that the MethodInfo is fetched, it cant
722 // work from MethodBuilders. Retarded, I know.
724 Type tt = CodeGen.Assembly.Builder.GetType (tb.Name);
725 MethodInfo mi = tt.GetMethod (mb.Name);
727 // Pull the FieldInfos from the type, and keep track of them
728 foreach (Field field in queued_fields){
729 FieldInfo fi = tt.GetField (field.Name);
731 FieldInfo old = (FieldInfo) fields [field.Name];
733 // If a previous value was set, nullify it, so that we do
736 if (TypeManager.IsStruct (old.FieldType)){
738 // TODO: Clear fields for structs
742 old.SetValue (null, null);
748 fields [field.Name] = fi;
752 queued_fields.Clear ();
754 return (CompiledMethod) System.Delegate.CreateDelegate (typeof (CompiledMethod), mi);
757 static internal void LoadAliases (NamespaceEntry ns)
759 ns.Populate (using_alias_list, using_list);
763 /// A sentinel value used to indicate that no value was
764 /// was set by the compiled function. This is used to
765 /// differentiate between a function not returning a
768 public class NoValueSet {
771 static internal FieldInfo LookupField (string name)
773 FieldInfo fi = (FieldInfo) fields [name];
779 // Puts the FieldBuilder into a queue of names that will be
780 // registered. We can not register FieldBuilders directly
781 // we need to fetch the FieldInfo after Reflection cooks the
782 // types, or bad things happen (bad means: FieldBuilders behave
783 // incorrectly across multiple assemblies, causing assignments to
786 // This also serves for the parser to register Field classes
787 // that should be exposed as global variables
789 static internal void QueueField (Field f)
791 queued_fields.Add (f);
794 static string Quote (string s)
796 if (s.IndexOf ('"') != -1)
797 s = s.Replace ("\"", "\\\"");
799 return "\"" + s + "\"";
802 static public string GetUsing ()
804 lock (evaluator_lock){
805 StringBuilder sb = new StringBuilder ();
807 foreach (object x in using_alias_list)
808 sb.Append (String.Format ("using {0};\n", x));
810 foreach (object x in using_list)
811 sb.Append (String.Format ("using {0};\n", x));
813 return sb.ToString ();
817 static internal ICollection GetUsingList ()
819 ArrayList res = new ArrayList (using_list.Count);
820 foreach (object ue in using_list)
821 res.Add (ue.ToString ());
825 static internal string [] GetVarNames ()
827 lock (evaluator_lock){
828 return (string []) new ArrayList (fields.Keys).ToArray (typeof (string));
832 static public string GetVars ()
834 lock (evaluator_lock){
835 StringBuilder sb = new StringBuilder ();
837 foreach (DictionaryEntry de in fields){
838 FieldInfo fi = LookupField ((string) de.Key);
845 value = fi.GetValue (null);
847 value = Quote ((string)value);
853 sb.Append (String.Format ("{0} {1} <error reading value>", TypeManager.CSharpName(fi.FieldType), de.Key));
855 sb.Append (String.Format ("{0} {1} = {2}", TypeManager.CSharpName(fi.FieldType), de.Key, value));
858 return sb.ToString ();
863 /// Loads the given assembly and exposes the API to the user.
865 static public void LoadAssembly (string file)
867 lock (evaluator_lock){
868 Driver.LoadAssembly (file, false);
869 GlobalRootNamespace.Instance.ComputeNamespaces ();
874 /// Exposes the API of the given assembly to the Evaluator
876 static public void ReferenceAssembly (Assembly a)
878 lock (evaluator_lock){
879 GlobalRootNamespace.Instance.AddAssemblyReference (a);
880 GlobalRootNamespace.Instance.ComputeNamespaces ();
888 /// A delegate that can be used to invoke the
889 /// compiled expression or statement.
892 /// Since the Compile methods will compile
893 /// statements and expressions into the same
894 /// delegate, you can tell if a value was returned
895 /// by checking whether the returned value is of type
899 public delegate void CompiledMethod (ref object retvalue);
902 /// The default base class for every interaction line
905 /// The expressions and statements behave as if they were
906 /// a static method of this class. The InteractiveBase class
907 /// contains a number of useful methods, but can be overwritten
908 /// by setting the InteractiveBaseType property in the Evaluator
910 public class InteractiveBase {
912 /// Determines where the standard output of methods in this class will go.
914 public static TextWriter Output = Console.Out;
917 /// Determines where the standard error of methods in this class will go.
919 public static TextWriter Error = Console.Error;
922 /// The primary prompt used for interactive use.
924 public static string Prompt = "csharp> ";
927 /// The secondary prompt used for interactive use (used when
928 /// an expression is incomplete).
930 public static string ContinuationPrompt = " > ";
933 /// Used to signal that the user has invoked the `quit' statement.
935 public static bool QuitRequested;
938 /// Shows all the variables defined so far.
940 static public void ShowVars ()
942 Output.Write (Evaluator.GetVars ());
947 /// Displays the using statements in effect at this point.
949 static public void ShowUsing ()
951 Output.Write (Evaluator.GetUsing ());
955 public delegate void Simple ();
958 /// Times the execution of the given delegate
960 static public TimeSpan Time (Simple a)
962 DateTime start = DateTime.Now;
964 return DateTime.Now - start;
969 /// Loads the assemblies from a package
972 /// Loads the assemblies from a package. This is equivalent
973 /// to passing the -pkg: command line flag to the C# compiler
974 /// on the command line.
976 static public void LoadPackage (string pkg)
979 Error.WriteLine ("Invalid package specified");
983 string pkgout = Driver.GetPackageFlags (pkg, false);
987 string [] xargs = pkgout.Trim (new Char [] {' ', '\n', '\r', '\t'}).
988 Split (new Char [] { ' ', '\t'});
990 foreach (string s in xargs){
991 if (s.StartsWith ("-r:") || s.StartsWith ("/r:") || s.StartsWith ("/reference:")){
992 string lib = s.Substring (s.IndexOf (':')+1);
994 Evaluator.LoadAssembly (lib);
1002 /// Loads the assembly
1005 /// Loads the specified assembly and makes its types
1006 /// available to the evaluator. This is equivalent
1007 /// to passing the -pkg: command line flag to the C#
1008 /// compiler on the command line.
1010 static public void LoadAssembly (string assembly)
1012 Evaluator.LoadAssembly (assembly);
1016 /// Returns a list of available static methods.
1018 static public string help {
1020 return "Static methods:\n"+
1021 " Describe(obj) - Describes the object's type\n" +
1022 " LoadPackage (pkg); - Loads the given Package (like -pkg:FILE)\n" +
1023 " LoadAssembly (ass) - Loads the given assembly (like -r:ASS)\n" +
1024 " ShowVars (); - Shows defined local variables.\n" +
1025 " ShowUsing (); - Show active using decltions.\n" +
1026 " Prompt - The prompt used by the C# shell\n" +
1027 " ContinuationPrompt - The prompt for partial input\n" +
1028 " Time(() -> { }) - Times the specified code\n" +
1035 /// Indicates to the read-eval-print-loop that the interaction should be finished.
1037 static public object quit {
1039 QuitRequested = true;
1046 /// Describes an object or a type.
1049 /// This method will show a textual representation
1050 /// of the object's type. If the object is a
1051 /// System.Type it renders the type directly,
1052 /// otherwise it renders the type returned by
1053 /// invoking GetType on the object.
1055 static public string Describe (object x)
1064 StringWriter sw = new StringWriter ();
1065 new Outline (t, sw, true, false, false).OutlineType ();
1066 return sw.ToString ();
1072 // A local variable reference that will create a Field in a
1073 // Class with the resolved type. This is necessary so we can
1074 // support "var" as a field type in a class declaration.
1076 // We allow LocalVariableReferece to do the heavy lifting, and
1077 // then we insert the field with the resolved type
1079 public class LocalVariableReferenceWithClassSideEffect : LocalVariableReference {
1080 TypeContainer container;
1083 public LocalVariableReferenceWithClassSideEffect (TypeContainer container, string name, Block current_block, string local_variable_id, LocalInfo li, Location loc)
1084 : base (current_block, local_variable_id, loc, li, false)
1086 this.container = container;
1090 public override bool Equals (object obj)
1092 LocalVariableReferenceWithClassSideEffect lvr = obj as LocalVariableReferenceWithClassSideEffect;
1096 if (lvr.name != name || lvr.container != container)
1099 return base.Equals (obj);
1102 public override int GetHashCode ()
1104 return name.GetHashCode ();
1107 override public Expression DoResolveLValue (ResolveContext ec, Expression right_side)
1109 Expression ret = base.DoResolveLValue (ec, right_side);
1113 Field f = new Field (container, new TypeExpression (ret.Type, Location),
1114 Modifiers.PUBLIC | Modifiers.STATIC,
1115 new MemberName (name, Location), null);
1116 container.AddField (f);
1118 Evaluator.QueueField (f);
1125 /// A class used to assign values if the source expression is not void
1127 /// Used by the interactive shell to allow it to call this code to set
1128 /// the return value for an invocation.
1130 class OptionalAssign : SimpleAssign {
1131 public OptionalAssign (Expression t, Expression s, Location loc)
1136 public override Expression DoResolve (ResolveContext ec)
1138 CloneContext cc = new CloneContext ();
1139 Expression clone = source.Clone (cc);
1141 clone = clone.Resolve (ec);
1145 // This means its really a statement.
1146 if (clone.Type == TypeManager.void_type){
1147 source = source.Resolve (ec);
1149 type = TypeManager.void_type;
1150 eclass = ExprClass.Value;
1154 return base.DoResolve (ec);
1157 public override void Emit (EmitContext ec)
1165 public override void EmitStatement (EmitContext ec)
1170 base.EmitStatement (ec);
1175 ArrayList undo_types;
1179 undo_types = new ArrayList ();
1182 public void AddTypeContainer (TypeContainer current_container, TypeContainer tc)
1184 if (current_container == tc){
1185 Console.Error.WriteLine ("Internal error: inserting container into itself");
1189 if (undo_types == null)
1190 undo_types = new ArrayList ();
1191 undo_types.Add (new Pair (current_container, tc));
1194 public void ExecuteUndo ()
1196 if (undo_types == null)
1199 foreach (Pair p in undo_types){
1200 TypeContainer current_container = (TypeContainer) p.First;
1202 current_container.RemoveTypeContainer ((TypeContainer) p.Second);