mcs/rootcontext.cs

   1 //
   2 // rootcontext.cs: keeps track of our tree representation, and assemblies loaded.
   3 //
   4 // Author: Miguel de Icaza (miguel@ximian.com)
   5 //            Ravi Pratap  (ravi@ximian.com)
   6 //            Marek Safar  (marek.safar@gmail.com)
   7 //
   8 //
   9 // Dual licensed under the terms of the MIT X11 or GNU GPL
  10 //
  11 // Copyright 2001 Ximian, Inc (http://www.ximian.com)
  12 // Copyright 2004-2008 Novell, Inc
  13
  14 using System;
  15 using System.Collections;
  16 using System.Reflection;
  17 using System.Reflection.Emit;
  18 using System.Diagnostics;
  19
  20 namespace Mono.CSharp {
  21
  22         public enum LanguageVersion
  23         {
  24                 ISO_1           = 1,
  25                 Default_MCS     = 2,
  26                 ISO_2           = 3,
  27                 LINQ            = 4,
  28                 Future          = 5,
  29
  30 #if GMCS_SOURCE
  31                 Default         = LINQ
  32 #else
  33                 Default         = Default_MCS
  34 #endif
  35         }
  36
  37         public class RootContext {
  38
  39                 //
  40                 // COMPILER OPTIONS CLASS
  41                 //
  42                 public static Target Target;
  43                 public static string TargetExt;
  44                 public static bool VerifyClsCompliance = true;
  45                 public static bool Optimize = true;
  46                 public static LanguageVersion Version;
  47
  48                 //
  49                 // We keep strongname related info here because
  50                 // it's also used as complier options from CSC 8.x
  51                 //
  52                 public static string StrongNameKeyFile;
  53                 public static string StrongNameKeyContainer;
  54                 public static bool StrongNameDelaySign;
  55
  56                 //
  57                 // If set, enable XML documentation generation
  58                 //
  59                 public static Documentation Documentation;
  60
  61                 static public string MainClass;
  62
  63                 //
  64                 // The default compiler checked state
  65                 //
  66                 static public bool Checked;
  67
  68                 //
  69                 // If true, it means that the compiler is executing as
  70                 // in eval mode so unresolved variables are resolved in
  71                 // static classes maintained by the eval engine.
  72                 //
  73                 static public bool EvalMode;
  74
  75                 //
  76                 // If true, the compiler is operating in statement mode,
  77                 // this currently turns local variable declaration into
  78                 // static variables of a class
  79                 //
  80                 static public bool StatementMode;
  81
  82                 //
  83                 // Whether to allow Unsafe code
  84                 //
  85                 static public bool Unsafe;
  86
  87                 //
  88                 // Whether we are being linked against the standard libraries.
  89                 // This is only used to tell whether `System.Object' should
  90                 // have a base class or not.
  91                 //
  92                 public static bool StdLib;
  93
  94                 public static bool NeedsEntryPoint {
  95                         get { return Target == Target.Exe || Target == Target.WinExe; }
  96                 }
  97
  98                 //
  99                 // COMPILER OPTIONS CLASS END
 100                 //
 101
 102                 //
 103                 // Contains the parsed tree
 104                 //
 105                 static ModuleContainer root;
 106
 107                 //
 108                 // This hashtable contains all of the #definitions across the source code
 109                 // it is used by the ConditionalAttribute handler.
 110                 //
 111                 static ArrayList AllDefines;
 112
 113                 //
 114                 // This keeps track of the order in which classes were defined
 115                 // so that we can poulate them in that order.
 116                 //
 117                 // Order is important, because we need to be able to tell, by
 118                 // examining the list of methods of the base class, which ones are virtual
 119                 // or abstract as well as the parent names (to implement new,
 120                 // override).
 121                 //
 122                 static ArrayList type_container_resolve_order;
 123
 124                 //
 125                 // Holds a reference to the Private Implementation Details
 126                 // class.
 127                 //
 128                 static ArrayList helper_classes;
 129
 130                 static TypeBuilder impl_details_class;
 131
 132                 //
 133                 // Constructor
 134                 //
 135                 static RootContext ()
 136                 {
 137                         Reset (true);
 138                 }
 139
 140                 public static void PartialReset ()
 141                 {
 142                         Reset (false);
 143                 }
 144
 145                 public static void Reset (bool full)
 146                 {
 147                         if (full)
 148                                 root = null;
 149
 150                         type_container_resolve_order = new ArrayList ();
 151                         EntryPoint = null;
 152                         Report.WarningLevel = 4;
 153                         Checked = false;
 154                         Unsafe = false;
 155                         StdLib = true;
 156                         StrongNameKeyFile = null;
 157                         StrongNameKeyContainer = null;
 158                         StrongNameDelaySign = false;
 159                         MainClass = null;
 160                         Target = Target.Exe;
 161                         TargetExt = ".exe";
 162                         Version = LanguageVersion.Default;
 163                         Documentation = null;
 164                         impl_details_class = null;
 165                         helper_classes = null;
 166
 167                         //
 168                         // Setup default defines
 169                         //
 170                         AllDefines = new ArrayList ();
 171                         AddConditional ("__MonoCS__");
 172                 }
 173
 174                 public static void AddConditional (string p)
 175                 {
 176                         if (AllDefines.Contains (p))
 177                                 return;
 178                         AllDefines.Add (p);
 179                 }
 180
 181                 public static bool IsConditionalDefined (string value)
 182                 {
 183                         return AllDefines.Contains (value);
 184                 }
 185
 186                 static public ModuleContainer ToplevelTypes {
 187                         get { return root; }
 188                         set { root = value; }
 189                 }
 190
 191                 public static void RegisterOrder (TypeContainer tc)
 192                 {
 193                         type_container_resolve_order.Add (tc);
 194                 }
 195
 196                 // <remarks>
 197                 //   This function is used to resolve the hierarchy tree.
 198                 //   It processes interfaces, structs and classes in that order.
 199                 //
 200                 //   It creates the TypeBuilder's as it processes the user defined
 201                 //   types.
 202                 // </remarks>
 203                 static public void ResolveTree ()
 204                 {
 205                         root.Resolve ();
 206
 207                         //
 208                         // Interfaces are processed next, as classes and
 209                         // structs might inherit from an object or implement
 210                         // a set of interfaces, we need to be able to tell
 211                         // them appart by just using the TypeManager.
 212                         //
 213                         foreach (TypeContainer tc in root.Types)
 214                                 tc.CreateType ();
 215
 216                         foreach (TypeContainer tc in root.Types)
 217                                 tc.DefineType ();
 218
 219                         if (root.Delegates != null)
 220                                 foreach (Delegate d in root.Delegates)
 221                                         d.DefineType ();
 222                 }
 223
 224                 // <summary>
 225                 //   Closes all open types
 226                 // </summary>
 227                 //
 228                 // <remarks>
 229                 //   We usually use TypeBuilder types.  When we are done
 230                 //   creating the type (which will happen after we have added
 231                 //   methods, fields, etc) we need to "Define" them before we
 232                 //   can save the Assembly
 233                 // </remarks>
 234                 static public void CloseTypes ()
 235                 {
 236                         //
 237                         // We do this in two passes, first we close the structs,
 238                         // then the classes, because it seems the code needs it this
 239                         // way.  If this is really what is going on, we should probably
 240                         // make sure that we define the structs in order as well.
 241                         //
 242                         foreach (TypeContainer tc in type_container_resolve_order){
 243                                 if (tc.Kind == Kind.Struct && tc.Parent == root){
 244                                         tc.CloseType ();
 245                                 }
 246                         }
 247
 248                         foreach (TypeContainer tc in type_container_resolve_order){
 249                                 if (!(tc.Kind == Kind.Struct && tc.Parent == root))
 250                                         tc.CloseType ();
 251                         }
 252
 253                         if (root.Delegates != null)
 254                                 foreach (Delegate d in root.Delegates)
 255                                         d.CloseType ();
 256
 257
 258                         //
 259                         // If we have a <PrivateImplementationDetails> class, close it
 260                         //
 261                         if (helper_classes != null){
 262                                 foreach (TypeBuilder type_builder in helper_classes) {
 263 #if GMCS_SOURCE
 264                                         PredefinedAttributes.Get.CompilerGenerated.EmitAttribute (type_builder);
 265 #endif
 266                                         type_builder.CreateType ();
 267                                 }
 268                         }
 269
 270                         type_container_resolve_order = null;
 271                         helper_classes = null;
 272                         //root = null;
 273                         TypeManager.CleanUp ();
 274                 }
 275
 276                 /// <summary>
 277                 ///   Used to register classes that need to be closed after all the
 278                 ///   user defined classes
 279                 /// </summary>
 280                 public static void RegisterCompilerGeneratedType (TypeBuilder helper_class)
 281                 {
 282                         if (helper_classes == null)
 283                                 helper_classes = new ArrayList ();
 284
 285                         helper_classes.Add (helper_class);
 286                 }
 287
 288                 static public void PopulateCoreType (TypeContainer root, string name)
 289                 {
 290                         DeclSpace ds = (DeclSpace) root.GetDefinition (name);
 291                         // Core type was imported
 292                         if (ds == null)
 293                                 return;
 294
 295                         ds.Define ();
 296                 }
 297
 298                 static public void BootCorlib_PopulateCoreTypes ()
 299                 {
 300                         PopulateCoreType (root, "System.Object");
 301                         PopulateCoreType (root, "System.ValueType");
 302                         PopulateCoreType (root, "System.Attribute");
 303                         PopulateCoreType (root, "System.Runtime.CompilerServices.IndexerNameAttribute");
 304                 }
 305
 306                 // <summary>
 307                 //   Populates the structs and classes with fields and methods
 308                 // </summary>
 309                 //
 310                 // This is invoked after all interfaces, structs and classes
 311                 // have been defined through `ResolveTree'
 312                 static public void PopulateTypes ()
 313                 {
 314
 315                         if (type_container_resolve_order != null){
 316                                 foreach (TypeContainer tc in type_container_resolve_order)
 317                                         tc.ResolveType ();
 318                                 foreach (TypeContainer tc in type_container_resolve_order) {
 319                                         try {
 320                                                 tc.Define ();
 321                                         } catch (Exception e) {
 322                                                 throw new InternalErrorException (tc, e);
 323                                         }
 324                                 }
 325                         }
 326
 327                         ArrayList delegates = root.Delegates;
 328                         if (delegates != null){
 329                                 foreach (Delegate d in delegates)
 330                                         d.Define ();
 331                         }
 332
 333                         //
 334                         // Check for cycles in the struct layout
 335                         //
 336                         if (type_container_resolve_order != null){
 337                                 Hashtable seen = new Hashtable ();
 338                                 foreach (TypeContainer tc in type_container_resolve_order)
 339                                         TypeManager.CheckStructCycles (tc, seen);
 340                         }
 341                 }
 342
 343                 static public void EmitCode ()
 344                 {
 345                         if (type_container_resolve_order != null) {
 346                                 foreach (TypeContainer tc in type_container_resolve_order)
 347                                         tc.EmitType ();
 348
 349                                 if (Report.Errors > 0)
 350                                         return;
 351
 352                                 foreach (TypeContainer tc in type_container_resolve_order)
 353                                         tc.VerifyMembers ();
 354                         }
 355
 356                         if (root.Delegates != null) {
 357                                 foreach (Delegate d in root.Delegates)
 358                                         d.Emit ();
 359                         }
 360
 361                         CodeGen.Assembly.Emit (root);
 362                         root.Emit ();
 363                 }
 364
 365                 //
 366                 // Public Field, used to track which method is the public entry
 367                 // point.
 368                 //
 369                 static public Method EntryPoint;
 370
 371                 //
 372                 // These are used to generate unique names on the structs and fields.
 373                 //
 374                 static int field_count;
 375
 376                 //
 377                 // Makes an initialized struct, returns the field builder that
 378                 // references the data.  Thanks go to Sergey Chaban for researching
 379                 // how to do this.  And coming up with a shorter mechanism than I
 380                 // was able to figure out.
 381                 //
 382                 // This works but makes an implicit public struct $ArrayType$SIZE and
 383                 // makes the fields point to it.  We could get more control if we did
 384                 // use instead:
 385                 //
 386                 // 1. DefineNestedType on the impl_details_class with our struct.
 387                 //
 388                 // 2. Define the field on the impl_details_class
 389                 //
 390                 static public FieldBuilder MakeStaticData (byte [] data)
 391                 {
 392                         FieldBuilder fb;
 393
 394                         if (impl_details_class == null){
 395                                 impl_details_class = ToplevelTypes.Builder.DefineType (
 396                                         "<PrivateImplementationDetails>",
 397                                         TypeAttributes.NotPublic,
 398                                         TypeManager.object_type);
 399
 400                                 RegisterCompilerGeneratedType (impl_details_class);
 401                         }
 402
 403                         fb = impl_details_class.DefineInitializedData (
 404                                 "$$field-" + (field_count++), data,
 405                                 FieldAttributes.Static | FieldAttributes.Assembly);
 406
 407                         return fb;
 408                 }
 409
 410                 public static void CheckUnsafeOption (Location loc)
 411                 {
 412                         if (!Unsafe) {
 413                                 Report.Error (227, loc,
 414                                         "Unsafe code requires the `unsafe' command line option to be specified");
 415                         }
 416                 }
 417         }
 418 }
 419
 420