public static unsafe TypeDefRow ResolveTypeRef (AssemblyMetadata assembly, TypeRefRow row, out AssemblyMetadata destAssembly) { uint token; return ResolveTypeRef (assembly, row, out destAssembly, out token); }
public unsafe static CString8 *GetString (AssemblyMetadata assembly, uint str) { int length = 0; CString8 *buf; int index = 0; Diagnostics.Assert (str < assembly.StringsHeap.Length, "Runtime.ReadString(): parameter `str' is out of range"); Diagnostics.Assert (assembly != null, "Runtime.ReadString(): parameter `assembly' is null"); length = GetStringLength (assembly, str); buf = CString8.Create (length); for (int x = (int) str; index < length; ++x) { buf->SetChar (index, assembly.StringsHeap [x]); ++index; } return buf; }
public static unsafe TypeRefRow GetTypeRef (AssemblyMetadata assembly, string ns, string name, out uint token) { CString8 *cns, cname; cns = CString8.Copy (ns); cname = CString8.Copy (name); try { return GetTypeRef (assembly, cns, cname, out token); } finally { MemoryManager.Free (cns); MemoryManager.Free (cname); } }
public static unsafe AssemblyMetadata ResolveAssemblyRef (AssemblyMetadata assembly, AssemblyRefRow row) { // TODO: check more than just the name here Diagnostics.Assert (assembly != null, "Runtime.ResolveAssemblyRef(): parameter `assembly' is null"); Diagnostics.Assert (row != null, "Runtime.ResolveAssemblyRef(): parameter `row' is null"); CString8 *name = GetString (assembly, row.Name); AssemblyMetadata result = null; for (int x = 0; x < Root.Assemblies.Length; ++x) { AssemblyMetadata assembly2 = Root.Assemblies [x]; CString8 *name2; if (assembly2.Assembly.Length == 0) continue; // unnamed assembly name2 = GetString (assembly2, assembly2.Assembly [0].Name); if (name->Compare (name2) == 0) result = assembly2; MemoryManager.Free (name2); if (result != null) break; } MemoryManager.Free (name); return result; }
protected Signature (AssemblyMetadata assembly): base (assembly) { }
static bool IsValidAssemblyMetadata (AssemblyMetadata asm) { for (int x = 0; x < Root.Assemblies.Length; ++x) { if (Root.Assemblies [x] == asm) return true; } return false; }
public unsafe static void DumpTypeDef (AssemblyMetadata assembly, TypeDefRow row, int index) { Debug.COM1.Write (" "); Debug.COM1.Write ("TypeDefRow#"); Debug.COM1.Write (index); Debug.COM1.Write (" "); Debug.COM1.Write ((int)row.Flags, true); Debug.COM1.Write (" "); Debug.COM1.Write ((int)row.Name, true); Debug.COM1.Write (" "); Debug.COM1.Write ((int)row.Namespace, true); Debug.COM1.Write (" "); Debug.COM1.Write ((int)row.Extends, true); Debug.COM1.Write (" "); Debug.COM1.Write ((int)row.FieldList, true); Debug.COM1.Write (" "); Debug.COM1.Write ((int)row.MethodList, true); Debug.COM1.Write (" "); PrintTypeName (assembly, row); Debug.COM1.WriteLine (); }
public unsafe static void PrintTypeName (AssemblyMetadata assembly, TypeRefRow type) { CString8 *name, ns; name = GetString (assembly, type.Name); ns = GetString (assembly, type.Namespace); Debug.COM1.Write (ns); Debug.COM1.Write ("."); Debug.COM1.Write (name); MemoryManager.Free (name); MemoryManager.Free (ns); }
public static TypeDefRow GetType (AssemblyMetadata assembly, TokenType type, uint rid) { AssemblyMetadata dest; return GetType (assembly, type, rid, out dest); }
public static TypeDefRow GetType (AssemblyMetadata assembly, MetadataToken token) { AssemblyMetadata dest; return GetType (assembly, token, out dest); }
public static TypeDefRow GetType (AssemblyMetadata assembly, MetadataToken token, out AssemblyMetadata dest) { return GetType (assembly, token.Type, token.RID, out dest); }
public static unsafe ModuleRow GetModule (AssemblyMetadata assembly, CString8 *name) { Diagnostics.Assert (assembly == null, "Runtime.GetModule(): parameter `assembly' is null"); Diagnostics.Assert (name == null, "Runtime.GetModule(): parameter `name' is null"); for (int x = 0; x < assembly.Module.Length; ++x) { ModuleRow row = assembly.Module [x]; int len = GetStringLength (assembly, row.Name); if (name->Compare (0, assembly.StringsHeap, (int) row.Name, len) == 0) return row; } return null; }
public static unsafe ModuleRow ResolveModuleRef (AssemblyMetadata assembly, ModuleRefRow row, out AssemblyMetadata destAssembly) { CString8 *moduleName; ModuleRow result = null; Diagnostics.Assert (assembly != null, "Runtime.ResolveModuleRef(): parameter `assembly' is null"); Diagnostics.Assert (row != null, "Runtime.ResolveModuleRef(): parameter `row' is null"); moduleName = GetString (assembly, row.Name); destAssembly = null; for (int x = 0; x < Root.Assemblies.Length; ++x) { AssemblyMetadata assembly2 = Root.Assemblies [x]; for (int y = 0; y < assembly2.Module.Length; ++y) { ModuleRow mod = assembly2.Module [y]; int len = GetStringLength (assembly2, mod.Name); if (moduleName->Compare (0, assembly2.StringsHeap, (int) mod.Name, len) == 0) { result = mod; destAssembly = assembly2; break; } } } return result; }
public static ModuleRow ResolveModuleRef (AssemblyMetadata assembly, ModuleRefRow row) { AssemblyMetadata assem2; Diagnostics.Assert (assembly != null, "Runtime.ResolveModuleRef(): parameter `assembly' is null"); Diagnostics.Assert (row != null, "Runtime.ResolveModuleRef(): parameter `row' is null"); return ResolveModuleRef (assembly, row, out assem2); }
public static int GetStringLength (AssemblyMetadata assembly, uint str) { int len = 0; Diagnostics.Assert (assembly != null, "Runtime.GetStringLength(): parameter `assembly' is null"); Diagnostics.Assert (str < assembly.StringsHeap.Length, "Runtime.GetStringLength(): invalid StringsHeap token"); for (int z = (int) str; z < assembly.StringsHeap.Length; ++z) { if (assembly.StringsHeap [z] == (byte) '\0') break; ++len; } return len; }
public static unsafe TypeRefRow GetTypeRef (AssemblyMetadata assembly, CString8 *ns, CString8 *name, out uint token) { TypeRefRow result = null; token = 0; for (int x = 0; x < assembly.TypeRef.Length; ++x) { int nameLength = 0; int nsLength = 0; TypeRefRow inspect = assembly.TypeRef [x]; nameLength = GetStringLength (assembly, inspect.Name); nsLength = GetStringLength (assembly, inspect.Namespace); if (name->Compare (0, assembly.StringsHeap, (int) inspect.Name, nameLength) != 0) continue; if (ns->Compare (0, assembly.StringsHeap, (int) inspect.Namespace, nsLength) != 0) continue; result = inspect; token = (uint)TokenType.TypeRef | (uint)x+1U; break; } return result; }
public static unsafe bool IsTypeSystemObject (AssemblyMetadata assembly, TokenType type, uint rid) { CString8 *systemNS = CString8.Copy ("System"); CString8 *objectName = CString8.Copy ("Object"); int nameLen, nsLen; bool result = false; Diagnostics.Assert (type == TokenType.TypeRef || type == TokenType.TypeDef, "Runtime.IsTypeSystemObject(): invalid metadata token, must be of type `TypeDef' or `TypeRef' only"); if (type == TokenType.TypeRef) { TypeRefRow row; // Handle this specially in case mscorlib is not included // (otherwise we will definitely get null from GetType()) Diagnostics.Assert (rid < assembly.TypeRef.Length, "Runtime.IsTypeSystemObject(): invalid metadata token, too large for TypeRef table!"); row = assembly.TypeRef [rid - 1]; nsLen = GetStringLength (assembly, row.Namespace); nameLen = GetStringLength (assembly, row.Name); if (systemNS->Compare (0, assembly.StringsHeap, (int) row.Namespace, nsLen) == 0 && objectName->Compare (0, assembly.StringsHeap, (int) row.Name, nameLen) == 0) result = true; } else if (type == TokenType.TypeDef) { TypeDefRow row; row = GetType (assembly, type, rid); nsLen = GetStringLength (assembly, row.Namespace); nameLen = GetStringLength (assembly, row.Name); if (systemNS->Compare (0, assembly.StringsHeap, (int) row.Namespace, nsLen) == 0 && objectName->Compare (0, assembly.StringsHeap, (int) row.Name, nameLen) == 0) result = true; } MemoryManager.Free (systemNS); MemoryManager.Free (objectName); return result; }
public static TypeDefRow GetType (AssemblyMetadata assembly, TokenType type, uint rid, out AssemblyMetadata destAssembly) { uint token; return GetType (assembly, type, rid, out destAssembly, out token); }
public static TypeDefRow GetType (AssemblyMetadata assembly, TokenType type, uint rid, out AssemblyMetadata destAssembly, out uint typeDefToken) { if (type != TokenType.TypeRef && type != TokenType.TypeDef) { Debug.COM1.Write ("Token type: "); Debug.COM1.WriteLine (MetadataToken.GetTokenTypeString (type)); throw new System.Exception ("token type must be either TypeRef or TypeDef"); } Diagnostics.Assert (type == TokenType.TypeRef || type == TokenType.TypeDef, "Runtime.GetType(): token type must be either TypeRef or TypeDef"); if (type == TokenType.TypeDef) { Diagnostics.Assert (rid < assembly.TypeDef.Length, "Runtime.GetType(): token out of range for TypeDef table"); destAssembly = assembly; typeDefToken = rid; return assembly.TypeDef [rid - 1]; } else { TypeRefRow row = assembly.TypeRef [rid - 1]; return ResolveTypeRef (assembly, row, out destAssembly, out typeDefToken); } }
public static unsafe TypeDefRow GetType (CString8 *ns, CString8 *name, out AssemblyMetadata assembly, out uint token) { token = 0; assembly = null; Diagnostics.Assert (ns != null, "Runtime.GetType(): parameter `ns' is null"); Diagnostics.Assert (name != null, "Runtime.GetType(): parameter `name' is null"); for (int x = 0; x < Root.Assemblies.Length; ++x) { TypeDefRow row = GetType (Root.Assemblies [x], ns, name, out token); if (row != null) { assembly = Root.Assemblies [x]; return row; } } return null; }
static bool HasValidMetadataToken (AssemblyMetadata assembly, uint token) { TokenType type; uint rid; MetadataToken.Decode (token, out type, out rid); if (type != TokenType.TypeDef && type != TokenType.TypeRef) return false; if (type == TokenType.TypeDef && rid-1 >= assembly.TypeDef.Length) return false; else if (type == TokenType.TypeRef && rid-1 >= assembly.TypeRef.Length) return false; return true; }
public static unsafe TypeDefRow GetType (CString8 *ns, CString8 *name, out AssemblyMetadata assembly) { uint token; return GetType (ns, name, out assembly, out token); }
public static TypeDefRow ResolveTypeRef (AssemblyMetadata assembly, TypeRefRow row) { AssemblyMetadata dest; return ResolveTypeRef (assembly, row, out dest); }
public static unsafe TypeDefRow GetType (AssemblyMetadata assembly, CString8 *ns, CString8 *name) { uint token; return GetType (assembly, name, ns, out token); }
public static unsafe TypeDefRow ResolveTypeRef (AssemblyMetadata assembly, TypeRefRow row, out AssemblyMetadata destAssembly, out uint typeDefToken) { CString8 *typeName = GetString (assembly, row.Name); CString8 *typeNamespace = GetString (assembly, row.Namespace); TokenType resScopeType; uint resScopeRID; TypeDefRow result = null; Diagnostics.Assert (assembly != null, "Runtime.ResolveTypeDef(): parameter `assembly' is null"); Diagnostics.Assert (row != null, "Runtime.ResolveTypeDef(): parameter `row' is null"); MetadataToken.Decode (row.ResolutionScope, out resScopeType, out resScopeRID); Diagnostics.Assert (resScopeType == TokenType.Assembly || resScopeType == TokenType.Module || resScopeType == TokenType.AssemblyRef || resScopeType == TokenType.ModuleRef, "Runtime.ResolveTypeRef(): resolution scope token is of an invalid type"); destAssembly = null; typeDefToken = 0; if (resScopeType == TokenType.Assembly || resScopeType == TokenType.Module || resScopeType == TokenType.ModuleRef) { Diagnostics.Assert (resScopeRID == 0, "Runtime.ResolveTypeRef(): resolution scope of Assembly must be zero!"); destAssembly = assembly; return GetType (assembly, typeName, typeNamespace); } else if (resScopeType == TokenType.AssemblyRef) { Diagnostics.Assert (resScopeRID < assembly.AssemblyRef.Length, "Runtime.ResolveTypeRef(): AssemblyRef metadata token out of range"); AssemblyMetadata assembly2 = ResolveAssemblyRef (assembly, assembly.AssemblyRef [resScopeRID]); destAssembly = assembly2; return GetType (assembly2, typeName, typeNamespace); } MemoryManager.Free (typeName); MemoryManager.Free (typeNamespace); return result; }
public static unsafe TypeRefRow GetTypeRef (CString8 *ns, CString8 *name, out AssemblyMetadata assembly, out uint token) { assembly = null; token = 0; for (int x = 0; x < Root.Assemblies.Length; ++x) { TypeRefRow result = GetTypeRef (Root.Assemblies [x], ns, name, out token); if (result != null) { assembly = Root.Assemblies [x]; return result; } } return null; }
public FieldSignature (AssemblyMetadata assembly, FieldRow fieldRow): base (assembly) { this.Field = fieldRow; int pos = (int)fieldRow.Signature - 1; byte [] blob = assembly.BlobHeap; int cmodCount = 0; int savedPos = 0; int cmodIndex = 0; // The first byte must be FIELD (0x6) Diagnostics.Assert (blob [pos++] == 0x6, "FieldSignature.ctor(): blob signature is not FIELD (0x6)"); //if (blob [pos] != 0x6) { // throw new Exception ("Invalid signature type for field"); // explode //} // First determine the amount of cmods we have savedPos = pos; while (true) { ElementType type = (ElementType) DecompressValue (blob, ref pos); if (type == ElementType.CModReqD || type == ElementType.CModOpt) ++cmodCount; else break; } this.CustomModifiers = new SigCustomModifier [cmodCount]; pos = savedPos; while (true) { ElementType type = (ElementType) DecompressValue (blob, ref pos); if (type == ElementType.CModReqD || type == ElementType.CModOpt) { CustomModifiers [cmodIndex++] = new SigCustomModifier (type, DecompressValue (blob, ref pos)); } else { // now for the "Type" switch (type) { case ElementType.Class: this.Type = new SigClassType (type, DecompressValue (blob, ref pos)); break; case ElementType.ValueType: this.Type = new SigClassType (type, DecompressValue (blob, ref pos)); break; case ElementType.Boolean: case ElementType.Char: case ElementType.I1: case ElementType.U1: case ElementType.I2: case ElementType.U2: case ElementType.I4: case ElementType.U4: case ElementType.I8: case ElementType.U8: case ElementType.R4: case ElementType.R8: case ElementType.I: case ElementType.U: case ElementType.Object: case ElementType.String: this.Type = new SigType (type); break; default: //throw new NotSupportedException (); // explode break; } // hereby ends this thousand-year journey break; } } ++pos; }
public static unsafe bool IsBaseClassOf (AssemblyMetadata typeAsm, uint type, AssemblyMetadata baseAsm, uint baseType) { TokenType typeTokType, baseTokType, interimTokType; uint typeRID, baseRID, interimRID; TypeDefRow typeDef, baseDef, interimDef; AssemblyMetadata interimAssembly; TypeDefRow lastInterimDef = null; if (typeAsm == baseAsm && type == baseType) return true; MetadataToken.Decode (type, out typeTokType, out typeRID); MetadataToken.Decode (baseType, out baseTokType, out baseRID); if (IsTypeSystemObject (baseAsm, baseTokType, baseRID)) return true; // Do not assume that 'baseDef' is more than null! typeDef = GetType (typeAsm, typeTokType, typeRID); baseDef = GetType (baseAsm, baseTokType, baseRID); interimDef = typeDef; interimAssembly = typeAsm; MetadataToken.Decode (typeDef.Extends, out interimTokType, out interimRID); while (true) { // If we've hit Object then the two types are unrelated if (IsTypeSystemObject (interimAssembly, interimTokType, interimRID)) return false; lastInterimDef = interimDef; interimDef = GetType (interimAssembly, interimTokType, interimRID, out interimAssembly); // If baseDef is null, it's usually because of a TypeRef which pointed to an assembly that was not // included when AOTing, the primary example of this is mscorlib. To handle this, we make sure // that the involved tokens are TypeRefs, and if the interimRID == baseRID then we have reached // the base type we want. if (baseDef == null && interimDef == null && interimTokType == TokenType.TypeRef && baseTokType == TokenType.TypeRef && interimAssembly == baseAsm && baseRID == interimRID) return true; Diagnostics.Assert (interimDef != null, "Runtime.IsBaseClassOf(): Failed to find TypeDef for the base class of a type"); Diagnostics.Assert (lastInterimDef != interimDef, "Runtime.IsBaseClassOf(): ERROR: TypeDef's base class is itself!!!"); if (interimDef == baseDef) return true; // Reiterate MetadataToken.Decode (interimDef.Extends, out interimTokType, out interimRID); } }