2 // rootcontext.cs: keeps track of our tree representation, and assemblies loaded.
4 // Author: Miguel de Icaza (miguel@ximian.com)
5 // Ravi Pratap (ravi@ximian.com)
6 // Marek Safar (marek.safar@gmail.com)
9 // Dual licensed under the terms of the MIT X11 or GNU GPL
11 // Copyright 2001 Ximian, Inc (http://www.ximian.com)
12 // Copyright 2004-2008 Novell, Inc
15 using System.Collections;
16 using System.Reflection;
17 using System.Reflection.Emit;
18 using System.Diagnostics;
20 namespace Mono.CSharp {
30 Default = LanguageVersion.V_4,
43 // COMPILER OPTIONS CLASS
45 public static Target Target;
47 public static Platform Platform;
49 public static string TargetExt;
50 public static bool VerifyClsCompliance = true;
51 public static bool Optimize = true;
52 public static LanguageVersion Version;
54 public static MetadataVersion MetadataCompatibilityVersion;
57 // We keep strongname related info here because
58 // it's also used as complier options from CSC 8.x
60 public static string StrongNameKeyFile;
61 public static string StrongNameKeyContainer;
62 public static bool StrongNameDelaySign;
65 // If set, enable XML documentation generation
67 public static Documentation Documentation;
69 static public string MainClass;
72 // The default compiler checked state
74 static public bool Checked;
77 // If true, it means that the compiler is executing as
78 // in eval mode so unresolved variables are resolved in
79 // static classes maintained by the eval engine.
81 static public bool EvalMode;
84 // If true, the compiler is operating in statement mode,
85 // this currently turns local variable declaration into
86 // static variables of a class
88 static public bool StatementMode;
91 // Whether to allow Unsafe code
93 static public bool Unsafe;
96 // Whether we are being linked against the standard libraries.
97 // This is only used to tell whether `System.Object' should
98 // have a base class or not.
100 public static bool StdLib;
102 public static bool NeedsEntryPoint {
103 get { return Target == Target.Exe || Target == Target.WinExe; }
107 // COMPILER OPTIONS CLASS END
111 // Contains the parsed tree
113 static ModuleContainer root;
116 // This hashtable contains all of the #definitions across the source code
117 // it is used by the ConditionalAttribute handler.
119 static ArrayList AllDefines;
122 // This keeps track of the order in which classes were defined
123 // so that we can poulate them in that order.
125 // Order is important, because we need to be able to tell, by
126 // examining the list of methods of the base class, which ones are virtual
127 // or abstract as well as the parent names (to implement new,
130 static ArrayList type_container_resolve_order;
133 // Holds a reference to the Private Implementation Details
136 static ArrayList helper_classes;
138 static TypeBuilder impl_details_class;
143 static RootContext ()
148 public static void PartialReset ()
153 public static void Reset (bool full)
158 type_container_resolve_order = new ArrayList ();
160 Report.WarningLevel = 4;
164 StrongNameKeyFile = null;
165 StrongNameKeyContainer = null;
166 StrongNameDelaySign = false;
171 Platform = Platform.AnyCPU;
173 Version = LanguageVersion.Default;
174 Documentation = null;
175 impl_details_class = null;
176 helper_classes = null;
179 MetadataCompatibilityVersion = MetadataVersion.v2;
181 MetadataCompatibilityVersion = MetadataVersion.v1;
185 // Setup default defines
187 AllDefines = new ArrayList ();
188 AddConditional ("__MonoCS__");
191 public static void AddConditional (string p)
193 if (AllDefines.Contains (p))
198 public static bool IsConditionalDefined (string value)
200 return AllDefines.Contains (value);
203 static public ModuleContainer ToplevelTypes {
205 set { root = value; }
208 public static void RegisterOrder (TypeContainer tc)
210 type_container_resolve_order.Add (tc);
214 // This function is used to resolve the hierarchy tree.
215 // It processes interfaces, structs and classes in that order.
217 // It creates the TypeBuilder's as it processes the user defined
220 static public void ResolveTree ()
225 // Interfaces are processed next, as classes and
226 // structs might inherit from an object or implement
227 // a set of interfaces, we need to be able to tell
228 // them appart by just using the TypeManager.
230 foreach (TypeContainer tc in root.Types)
233 foreach (TypeContainer tc in root.Types)
236 if (root.Delegates != null)
237 foreach (Delegate d in root.Delegates)
242 // Closes all open types
246 // We usually use TypeBuilder types. When we are done
247 // creating the type (which will happen after we have added
248 // methods, fields, etc) we need to "Define" them before we
249 // can save the Assembly
251 static public void CloseTypes ()
254 // We do this in two passes, first we close the structs,
255 // then the classes, because it seems the code needs it this
256 // way. If this is really what is going on, we should probably
257 // make sure that we define the structs in order as well.
259 foreach (TypeContainer tc in type_container_resolve_order){
260 if (tc.Kind == Kind.Struct && tc.Parent == root){
265 foreach (TypeContainer tc in type_container_resolve_order){
266 if (!(tc.Kind == Kind.Struct && tc.Parent == root))
270 if (root.Delegates != null)
271 foreach (Delegate d in root.Delegates)
276 // If we have a <PrivateImplementationDetails> class, close it
278 if (helper_classes != null){
279 foreach (TypeBuilder type_builder in helper_classes) {
280 PredefinedAttributes.Get.CompilerGenerated.EmitAttribute (type_builder);
281 type_builder.CreateType ();
285 type_container_resolve_order = null;
286 helper_classes = null;
288 TypeManager.CleanUp ();
292 /// Used to register classes that need to be closed after all the
293 /// user defined classes
295 public static void RegisterCompilerGeneratedType (TypeBuilder helper_class)
297 if (helper_classes == null)
298 helper_classes = new ArrayList ();
300 helper_classes.Add (helper_class);
303 static public void PopulateCoreType (TypeContainer root, string name)
305 DeclSpace ds = (DeclSpace) root.GetDefinition (name);
306 // Core type was imported
313 static public void BootCorlib_PopulateCoreTypes ()
315 PopulateCoreType (root, "System.Object");
316 PopulateCoreType (root, "System.ValueType");
317 PopulateCoreType (root, "System.Attribute");
318 PopulateCoreType (root, "System.Runtime.CompilerServices.IndexerNameAttribute");
322 // Populates the structs and classes with fields and methods
325 // This is invoked after all interfaces, structs and classes
326 // have been defined through `ResolveTree'
327 static public void PopulateTypes ()
330 if (type_container_resolve_order != null){
331 foreach (TypeContainer tc in type_container_resolve_order)
333 foreach (TypeContainer tc in type_container_resolve_order) {
336 } catch (Exception e) {
337 throw new InternalErrorException (tc, e);
342 ArrayList delegates = root.Delegates;
343 if (delegates != null){
344 foreach (Delegate d in delegates)
349 // Check for cycles in the struct layout
351 if (type_container_resolve_order != null){
352 Hashtable seen = new Hashtable ();
353 foreach (TypeContainer tc in type_container_resolve_order)
354 TypeManager.CheckStructCycles (tc, seen);
358 static public void EmitCode ()
360 if (type_container_resolve_order != null) {
361 foreach (TypeContainer tc in type_container_resolve_order)
364 if (Report.Errors > 0)
367 foreach (TypeContainer tc in type_container_resolve_order)
371 if (root.Delegates != null) {
372 foreach (Delegate d in root.Delegates)
376 CodeGen.Assembly.Emit (root);
381 // Public Field, used to track which method is the public entry
384 static public Method EntryPoint;
387 // These are used to generate unique names on the structs and fields.
389 static int field_count;
392 // Makes an initialized struct, returns the field builder that
393 // references the data. Thanks go to Sergey Chaban for researching
394 // how to do this. And coming up with a shorter mechanism than I
395 // was able to figure out.
397 // This works but makes an implicit public struct $ArrayType$SIZE and
398 // makes the fields point to it. We could get more control if we did
401 // 1. DefineNestedType on the impl_details_class with our struct.
403 // 2. Define the field on the impl_details_class
405 static public FieldBuilder MakeStaticData (byte [] data)
409 if (impl_details_class == null){
410 impl_details_class = ToplevelTypes.Builder.DefineType (
411 "<PrivateImplementationDetails>",
412 TypeAttributes.NotPublic,
413 TypeManager.object_type);
415 RegisterCompilerGeneratedType (impl_details_class);
418 fb = impl_details_class.DefineInitializedData (
419 "$$field-" + (field_count++), data,
420 FieldAttributes.Static | FieldAttributes.Assembly);
425 public static void CheckUnsafeOption (Location loc)
428 Report.Error (227, loc,
429 "Unsafe code requires the `unsafe' command line option to be specified");