mcs/ilasm/codegen/GenericTypeInst.cs

   1 //
   2 // Mono.ILASM.GenericTypeInst
   3 //
   4 // Author(s):
   5 //  Jackson Harper (Jackson@LatitudeGeo.com)
   6 //  Ankit Jain (JAnkit@novell.com)
   7 //
   8 // (C) 2003 Latitude Geographics Group, All rights reserved
   9 // (C) 2005 Novell, Inc (http://www.novell.com)
  10 //
  11
  12
  13 using System;
  14 using System.Collections;
  15
  16 namespace Mono.ILASM {
  17
  18         public class GenericTypeInst : BaseGenericTypeRef {
  19
  20                 private BaseClassRef class_ref;
  21                 private PEAPI.GenericTypeInst p_gen_inst;
  22                 private bool is_valuetypeinst;
  23                 private GenericArguments gen_args;
  24                 private bool is_added; /* Added to PEFile (to TypeSpec table) ? */
  25                 /* Note: Using static hashtable here as GenericTypeInsts is not cached */
  26                 private static Hashtable s_method_table = new Hashtable ();
  27                 private static Hashtable s_field_table = new Hashtable ();
  28
  29                 public GenericTypeInst (BaseClassRef class_ref, GenericArguments gen_args, bool is_valuetypeinst)
  30                         : this (class_ref, gen_args, is_valuetypeinst, null, null)
  31                 {
  32                 }
  33
  34                 public GenericTypeInst (BaseClassRef class_ref, GenericArguments gen_args, bool is_valuetypeinst,
  35                                 string sig_mod, ArrayList conv_list)
  36                         : base ("", is_valuetypeinst, conv_list, sig_mod)
  37                 {
  38                         if (class_ref is GenericTypeInst)
  39                                 throw new ArgumentException (String.Format ("Cannot create nested GenericInst, '{0}' '{1}'", class_ref.FullName, gen_args.ToString ()));
  40
  41                         this.class_ref = class_ref;
  42                         this.gen_args = gen_args;
  43                         is_added = false;
  44                 }
  45
  46                 public override string FullName {
  47                         get { return class_ref.FullName + gen_args.ToString () + SigMod; }
  48                 }
  49
  50                 public override BaseClassRef Clone ()
  51                 {
  52                         //Clone'd instance shares the class_ref and gen_args,
  53                         //as its basically used to create modified types (arrays etc)
  54                         return new GenericTypeInst (class_ref, gen_args, is_valuetypeinst, sig_mod,
  55                                         (ArrayList) ConversionList.Clone () );
  56                 }
  57
  58                 public override void MakeValueClass ()
  59                 {
  60                         class_ref.MakeValueClass ();
  61                 }
  62
  63                 public override void ResolveNoTypeSpec (CodeGen code_gen)
  64                 {
  65                         if (is_resolved)
  66                                 return;
  67
  68                         class_ref.Resolve (code_gen);
  69                         p_gen_inst = (PEAPI.GenericTypeInst) class_ref.ResolveInstance (code_gen, gen_args);
  70
  71                         type = Modify (code_gen, p_gen_inst);
  72
  73                         is_resolved = true;
  74                 }
  75
  76                 public override void Resolve (CodeGen code_gen)
  77                 {
  78                         ResolveNoTypeSpec (code_gen);
  79                         if (is_added)
  80                                 return;
  81
  82                         code_gen.PEFile.AddGenericClass ((PEAPI.GenericTypeInst) p_gen_inst);
  83                         is_added = true;
  84                 }
  85
  86                 public override void Resolve (GenericParameters type_gen_params, GenericParameters method_gen_params)
  87                 {
  88                         gen_args.Resolve (type_gen_params, method_gen_params);
  89                 }
  90
  91                 protected override BaseMethodRef CreateMethodRef (BaseTypeRef ret_type,
  92                         PEAPI.CallConv call_conv, string name, BaseTypeRef[] param, int gen_param_count)
  93                 {
  94                         throw new Exception ("Should not be called");
  95                 }
  96
  97                 public override BaseMethodRef GetMethodRef (BaseTypeRef ret_type, PEAPI.CallConv call_conv,
  98                                 string meth_name, BaseTypeRef[] param, int gen_param_count)
  99                 {
 100                         /* Note: Using FullName here as we are caching in a static hashtable */
 101                         string key = FullName + MethodDef.CreateSignature (ret_type, meth_name, param, gen_param_count);
 102                         TypeSpecMethodRef mr = s_method_table [key] as TypeSpecMethodRef;
 103                         if (mr == null) {
 104                                 mr = new TypeSpecMethodRef (this, call_conv, ret_type, meth_name, param, gen_param_count);
 105                                 s_method_table [key] = mr;
 106                         }
 107
 108                         return mr;
 109                 }
 110
 111                 protected override IFieldRef CreateFieldRef (BaseTypeRef ret_type, string field_name)
 112                 {
 113                         /* Note: Using FullName here as we are caching in a static hashtable */
 114                         string key = FullName + ret_type.FullName + field_name;
 115
 116                         IFieldRef fr = (IFieldRef) s_field_table [key];
 117
 118                         if (fr == null) {
 119                                 fr = new TypeSpecFieldRef (this, ret_type, field_name);
 120                                 s_field_table [key] = fr;
 121                         }
 122
 123                         return fr;
 124                 }
 125         }
 126 }
 127