mcs/tools/ictool/peer.cs

   1 //
   2 // file:        peer.cs
   3 // author:      Dan Lewis (dihlewis@yahoo.co.uk)
   4 //              (C) 2002
   5 //
   6
   7 using System;
   8 using System.Reflection;
   9 using System.Collections;
  10
  11 class Peer {
  12         public Peer (Type clr_type, string name, bool is_opaque) {
  13                 this.clr_type = clr_type;
  14                 this.name = name;
  15                 this.is_opaque = is_opaque;
  16
  17                 this.nearest_base = null;       // resolve later
  18                 this.underlying = null;
  19                 this.enum_constants = null;
  20                 this.fields = new PeerFieldCollection ();
  21
  22                 this.is_enum = CLRIsEnum (clr_type);
  23                 this.is_value_type = CLRIsValueType (clr_type);
  24         }
  25
  26         public string Name {
  27                 get { return name; }
  28         }
  29
  30         public Type CLRType {
  31                 get { return clr_type; }
  32         }
  33
  34         public bool IsOpaque {
  35                 get { return is_opaque; }
  36         }
  37
  38         public bool IsValueType {
  39                 get { return is_value_type; }
  40         }
  41
  42         public bool IsEnum {
  43                 get { return is_enum; }
  44         }
  45
  46         public Peer NearestBase {
  47                 get { return nearest_base; }
  48                 set { nearest_base = value; }
  49         }
  50
  51         public Peer UnderlyingPeer {
  52                 get { return underlying; }
  53                 set { underlying = value; }
  54         }
  55
  56         public IDictionary EnumConstants {
  57                 get { return enum_constants; }
  58                 set { enum_constants = value; }
  59         }
  60
  61         public PeerFieldCollection Fields {
  62                 get { return fields; }
  63         }
  64
  65         public string GetTypedef (int refs) {
  66                 if (refs == 0)
  67                         return String.Format ("{0} ", name);
  68
  69                 return String.Format ("{0} {1}", name, new string ('*', refs));
  70         }
  71
  72         // internal
  73
  74         internal static bool CLRIsValueType (Type clr_type) {
  75                 return clr_type.IsValueType;
  76                 /*
  77                 if (clr_type.BaseType == null)
  78                         return false;
  79
  80                 return
  81                         clr_type.BaseType.FullName == "System.ValueType" ||
  82                         clr_type.BaseType.FullName == "System.Enum";
  83                 */
  84         }
  85
  86         internal static bool CLRIsEnum (Type clr_type) {
  87                 return clr_type.IsEnum;
  88                 /*
  89                 if (clr_type.BaseType == null)
  90                         return false;
  91
  92                 return clr_type.BaseType.FullName == "System.Enum";
  93                 */
  94         }
  95
  96         internal static Type CLRUnderlyingType (Type clr_type) {
  97                 return Enum.GetUnderlyingType (clr_type);
  98                 /*
  99                 Type ebase = type.BaseType;
 100
 101                 return (Type)ebase.InvokeMember ("GetUnderlyingType",
 102                         BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.Static,
 103                         null, null,
 104                         new object[] { type }
 105                 );
 106                 */
 107         }
 108
 109         // private
 110
 111         private Type clr_type;
 112         private bool is_opaque;
 113         private bool is_value_type;
 114         private bool is_enum;
 115
 116         private string name;
 117         private Peer nearest_base;
 118         private Peer underlying;
 119         private IDictionary enum_constants;
 120         private PeerFieldCollection fields;
 121 }
 122
 123 class PeerField {
 124         public PeerField (Peer peer, string name) {
 125                 this.peer = peer;
 126                 this.name = name;
 127         }
 128
 129         public Peer Peer {
 130                 get { return peer; }
 131         }
 132
 133         public string Name {
 134                 get { return name; }
 135         }
 136
 137         private Peer peer;
 138         private string name;
 139 }
 140
 141 class PeerFieldCollection : CollectionBase {
 142         public void Add (PeerField f) {
 143                 List.Add (f);
 144         }
 145
 146         public PeerField this[int i] {
 147                 get { return (PeerField)List[i]; }
 148         }
 149 }
 150
 151 class PeerMap {
 152         public PeerMap () {
 153                 peers = new Hashtable ();
 154         }
 155
 156         public void Add (Peer peer) {
 157                 Add (peer.CLRType, peer);
 158         }
 159
 160         public void Add (Type clr_type, Peer peer) {
 161                 peers.Add (clr_type, peer);
 162         }
 163
 164         public ICollection Peers {
 165                 get { return peers.Values; }
 166         }
 167
 168         public Peer this[Type clr_type] {
 169                 get {
 170                         if (peers.Contains (clr_type))
 171                                 return (Peer)peers[clr_type];
 172
 173                         return null;
 174                 }
 175         }
 176
 177         public Peer GetPeer (Type clr_type) {
 178                 Peer peer;
 179
 180                 if (Peer.CLRIsValueType (clr_type)) {
 181                         peer = this[clr_type];
 182                         if (peer != null)
 183                                 return peer;
 184
 185                         if (Peer.CLRIsEnum (clr_type)) {
 186                                 peer = this[Peer.CLRUnderlyingType (clr_type)];
 187                                 if (peer != null)
 188                                 return peer;
 189
 190                                 throw new ArgumentException ("Could not find peer or underlying peer for enum " + clr_type);
 191                         }
 192                         else
 193                                 throw new ArgumentException ("Could not find peer for value type " + clr_type);
 194                 }
 195                 else {
 196                         Type type = clr_type;
 197                         while (type != null) {
 198                                 peer = this[type];
 199                                 if (peer != null)
 200                                         return peer;
 201
 202                                 type = type.BaseType;
 203                         }
 204
 205                         throw new ArgumentException ("Could not find peer for class " + clr_type);
 206                 }
 207         }
 208
 209         public void ResolvePeers () {
 210                 BindingFlags binding =
 211                         BindingFlags.DeclaredOnly |
 212                         BindingFlags.Instance |
 213                         BindingFlags.NonPublic |
 214                         BindingFlags.Public;
 215
 216                 // base type
 217
 218                 foreach (Peer peer in Peers) {
 219                         if (peer.IsOpaque || peer.IsValueType || peer.CLRType.BaseType == null)
 220                                 continue;
 221
 222                         peer.NearestBase = GetPeer (peer.CLRType.BaseType);
 223                         if (peer.NearestBase == null) {
 224                                 Console.Error.WriteLine ("Error: cannot find an internal base type for {0}.", peer.Name);
 225                                 Environment.Exit (-1);
 226                         }
 227                 }
 228
 229                 // fields
 230
 231                 foreach (Peer peer in Peers) {
 232                         if (peer.IsOpaque || peer.IsEnum)
 233                                 continue;
 234
 235                         Type clr_base = null;
 236                         if (peer.NearestBase != null)
 237                                 clr_base = peer.NearestBase.CLRType;
 238
 239                         Stack declared = new Stack ();
 240                         Type type = peer.CLRType;
 241
 242                         while (type != clr_base) {
 243                                 declared.Push (type);
 244                                 type = type.BaseType;
 245                         }
 246
 247                         // build declared field list
 248
 249                         while (declared.Count > 0) {
 250                                 type = (Type)declared.Pop ();
 251                                 foreach (FieldInfo info in type.GetFields (binding)) {
 252                                         PeerField field = new PeerField (
 253                                                 GetPeer (info.FieldType),
 254                                                 info.Name
 255                                         );
 256
 257                                         peer.Fields.Add (field);
 258                                 }
 259                         }
 260                 }
 261
 262                 // enums
 263
 264                 foreach (Peer peer in Peers) {
 265                         if (peer.IsOpaque || !peer.IsEnum)
 266                                 continue;
 267
 268                         Type clr_type = peer.CLRType;
 269
 270                         // constants
 271
 272                         Hashtable constants = new Hashtable ();
 273                         foreach (string name in Enum.GetNames (clr_type))
 274                                 constants.Add (name, (int)Enum.Parse (clr_type, name));
 275
 276                         peer.UnderlyingPeer = GetPeer (Enum.GetUnderlyingType (clr_type));
 277                         peer.EnumConstants = constants;
 278                 }
 279         }
 280
 281         // private
 282
 283         private Hashtable peers;
 284 }