mcs/roottypes.cs

   1 //
   2 // roottypes.cs: keeps a tree representation of the generated code
   3 //
   4 // Authors: Miguel de Icaza (miguel@gnu.org)
   5 //          Marek Safar  (marek.safar@gmail.com)
   6 //
   7 // Dual licensed under the terms of the MIT X11 or GNU GPL
   8 //
   9 // Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
  10 // Copyright 2003-2008 Novell, Inc.
  11 //
  12
  13 using System;
  14 using System.Collections;
  15 using System.Reflection;
  16 using System.Reflection.Emit;
  17 using System.Runtime.InteropServices;
  18
  19 namespace Mono.CSharp
  20 {
  21         //
  22         // Compiled top-level types
  23         //
  24         public sealed class ModuleContainer : TypeContainer
  25         {
  26                 // TODO: It'd be so nice to have generics
  27                 Hashtable anonymous_types;
  28                 public ModuleBuilder Builder;
  29                 readonly bool is_unsafe;
  30                 readonly CompilerContext context;
  31
  32                 bool has_default_charset;
  33
  34                 public CharSet DefaultCharSet = CharSet.Ansi;
  35                 public TypeAttributes DefaultCharSetType = TypeAttributes.AnsiClass;
  36
  37                 static readonly string[] attribute_targets = new string[] { "module" };
  38
  39                 public ModuleContainer (CompilerContext context, bool isUnsafe)
  40                         : base (null, null, MemberName.Null, null, Kind.Root)
  41                 {
  42                         this.is_unsafe = isUnsafe;
  43                         this.context = context;
  44
  45                         types = new ArrayList ();
  46                         anonymous_types = new Hashtable ();
  47                 }
  48
  49                 public override AttributeTargets AttributeTargets {
  50                         get {
  51                                 return AttributeTargets.Module;
  52                         }
  53                 }
  54
  55                 public void AddAnonymousType (AnonymousTypeClass type)
  56                 {
  57                         ArrayList existing = (ArrayList)anonymous_types [type.Parameters.Count];
  58                         if (existing == null) {
  59                                 existing = new ArrayList ();
  60                                 anonymous_types.Add (type.Parameters.Count, existing);
  61                         }
  62                         existing.Add (type);
  63                 }
  64
  65                 public void AddAttributes (ArrayList attrs)
  66                 {
  67                         foreach (Attribute a in attrs)
  68                                 a.AttachTo (this, CodeGen.Assembly);
  69
  70                         if (attributes == null) {
  71                                 attributes = new Attributes (attrs);
  72                                 return;
  73                         }
  74
  75                         attributes.AddAttributes (attrs);
  76                 }
  77
  78                 public override TypeContainer AddPartial (TypeContainer nextPart)
  79                 {
  80                         return AddPartial (nextPart, nextPart.Name);
  81                 }
  82
  83                 public override void ApplyAttributeBuilder (Attribute a, CustomAttributeBuilder cb, PredefinedAttributes pa)
  84                 {
  85                         if (a.Type == pa.CLSCompliant) {
  86                                 if (CodeGen.Assembly.ClsCompliantAttribute == null) {
  87                                         Report.Warning (3012, 1, a.Location, "You must specify the CLSCompliant attribute on the assembly, not the module, to enable CLS compliance checking");
  88                                 } else if (CodeGen.Assembly.IsClsCompliant != a.GetBoolean ()) {
  89                                         Report.SymbolRelatedToPreviousError (CodeGen.Assembly.ClsCompliantAttribute.Location, CodeGen.Assembly.ClsCompliantAttribute.GetSignatureForError ());
  90                                         Report.Warning (3017, 1, a.Location, "You cannot specify the CLSCompliant attribute on a module that differs from the CLSCompliant attribute on the assembly");
  91                                         return;
  92                                 }
  93                         }
  94
  95                         Builder.SetCustomAttribute (cb);
  96                 }
  97
  98                 public override CompilerContext Compiler {
  99                         get { return context; }
 100                 }
 101
 102                 public override void Emit ()
 103                 {
 104                         if (OptAttributes != null)
 105                                 OptAttributes.Emit ();
 106
 107                         if (is_unsafe) {
 108                                 Type t = TypeManager.CoreLookupType (context, "System.Security", "UnverifiableCodeAttribute", Kind.Class, true);
 109                                 if (t != null) {
 110                                         ConstructorInfo unverifiable_code_ctor = TypeManager.GetPredefinedConstructor (t, Location.Null, Type.EmptyTypes);
 111                                         if (unverifiable_code_ctor != null)
 112                                                 Builder.SetCustomAttribute (new CustomAttributeBuilder (unverifiable_code_ctor, new object [0]));
 113                                 }
 114                         }
 115                 }
 116
 117                 public AnonymousTypeClass GetAnonymousType (ArrayList parameters)
 118                 {
 119                         ArrayList candidates = (ArrayList) anonymous_types [parameters.Count];
 120                         if (candidates == null)
 121                                 return null;
 122
 123                         int i;
 124                         foreach (AnonymousTypeClass at in candidates) {
 125                                 for (i = 0; i < parameters.Count; ++i) {
 126                                         if (!parameters [i].Equals (at.Parameters [i]))
 127                                                 break;
 128                                 }
 129
 130                                 if (i == parameters.Count)
 131                                         return at;
 132                         }
 133
 134                         return null;
 135                 }
 136
 137                 public override bool GetClsCompliantAttributeValue ()
 138                 {
 139                         return CodeGen.Assembly.IsClsCompliant;
 140                 }
 141
 142                 public bool HasDefaultCharSet {
 143                         get {
 144                                 return has_default_charset;
 145                         }
 146                 }
 147
 148                 public override string GetSignatureForError ()
 149                 {
 150                         return "<module>";
 151                 }
 152
 153                 public override bool IsClsComplianceRequired ()
 154                 {
 155                         return true;
 156                 }
 157
 158                 public override ModuleContainer Module {
 159                         get {
 160                                 return this;
 161                         }
 162                 }
 163
 164                 protected override bool AddMemberType (DeclSpace ds)
 165                 {
 166                         if (!AddToContainer (ds, ds.Name))
 167                                 return false;
 168                         ds.NamespaceEntry.NS.AddDeclSpace (ds.Basename, ds);
 169                         return true;
 170                 }
 171
 172                 protected override void RemoveMemberType (DeclSpace ds)
 173                 {
 174                         ds.NamespaceEntry.NS.RemoveDeclSpace (ds.Basename);
 175                         base.RemoveMemberType (ds);
 176                 }
 177
 178                 /// <summary>
 179                 /// It is called very early therefore can resolve only predefined attributes
 180                 /// </summary>
 181                 public void Resolve ()
 182                 {
 183                         if (OptAttributes == null)
 184                                 return;
 185
 186                         if (!OptAttributes.CheckTargets ())
 187                                 return;
 188
 189                         Attribute a = ResolveAttribute (PredefinedAttributes.Get.DefaultCharset);
 190                         if (a != null) {
 191                                 has_default_charset = true;
 192                                 DefaultCharSet = a.GetCharSetValue ();
 193                                 switch (DefaultCharSet) {
 194                                 case CharSet.Ansi:
 195                                 case CharSet.None:
 196                                         break;
 197                                 case CharSet.Auto:
 198                                         DefaultCharSetType = TypeAttributes.AutoClass;
 199                                         break;
 200                                 case CharSet.Unicode:
 201                                         DefaultCharSetType = TypeAttributes.UnicodeClass;
 202                                         break;
 203                                 default:
 204                                         Report.Error (1724, a.Location, "Value specified for the argument to 'System.Runtime.InteropServices.DefaultCharSetAttribute' is not valid");
 205                                         break;
 206                                 }
 207                         }
 208                 }
 209
 210                 Attribute ResolveAttribute (PredefinedAttribute a_type)
 211                 {
 212                         Attribute a = OptAttributes.Search (a_type);
 213                         if (a != null) {
 214                                 a.Resolve ();
 215                         }
 216                         return a;
 217                 }
 218
 219                 public override string[] ValidAttributeTargets {
 220                         get {
 221                                 return attribute_targets;
 222                         }
 223                 }
 224         }
 225
 226         class RootDeclSpace : DeclSpace {
 227                 public RootDeclSpace (NamespaceEntry ns)
 228                         : base (ns, null, MemberName.Null, null)
 229                 {
 230                         PartialContainer = RootContext.ToplevelTypes;
 231                 }
 232
 233                 public override AttributeTargets AttributeTargets {
 234                         get { throw new InternalErrorException ("should not be called"); }
 235                 }
 236
 237                 public override CompilerContext Compiler {
 238                         get {
 239                                 return PartialContainer.Compiler;
 240                         }
 241                 }
 242
 243                 public override string DocCommentHeader {
 244                         get { throw new InternalErrorException ("should not be called"); }
 245                 }
 246
 247                 public override bool Define ()
 248                 {
 249                         throw new InternalErrorException ("should not be called");
 250                 }
 251
 252                 public override TypeBuilder DefineType ()
 253                 {
 254                         throw new InternalErrorException ("should not be called");
 255                 }
 256
 257                 public override MemberCache MemberCache {
 258                         get { return PartialContainer.MemberCache; }
 259                 }
 260
 261                 public override ModuleContainer Module {
 262                         get {
 263                                 return PartialContainer.Module;
 264                         }
 265                 }
 266
 267                 public override bool GetClsCompliantAttributeValue ()
 268                 {
 269                         return PartialContainer.GetClsCompliantAttributeValue ();
 270                 }
 271
 272                 public override bool IsClsComplianceRequired ()
 273                 {
 274                         return PartialContainer.IsClsComplianceRequired ();
 275                 }
 276
 277                 public override FullNamedExpression LookupNamespaceAlias (string name)
 278                 {
 279                         return NamespaceEntry.LookupNamespaceAlias (name);
 280                 }
 281         }
 282 }