/*-------------------- Constructors ---------------------------------*/ internal FieldMarshal(MetaDataElement field, NativeType nType) { Contract.Requires(field != null); this.field = field; this.nt = nType; tabIx = MDTable.FieldMarshal; }
/*-------------------- Constructors ---------------------------------*/ internal FieldMarshal(MetaDataElement field, NativeType nType) { Contract.Requires(field != null); this.field = field; this.nt = nType; tabIx = MDTable.FieldMarshal; }
internal GenericParam(PEReader buff) : base(VAR) { Contract.Requires(buff != null); index = buff.ReadUInt16(); flags = buff.ReadUInt16(); parentIx = buff.GetCodedIndex(CIx.TypeOrMethodDef); name = buff.GetString(); if (extraField) { kind = buff.ReadUInt16(); } tabIx = MDTable.GenericParam; // resolve generic param immediately for signature resolution parent = buff.GetCodedElement(CIx.TypeOrMethodDef, parentIx); if (parent != null) { if (parent is MethodDef) { typeIndex = MVAR; ((MethodDef)parent).AddGenericParam(this); } else { ((ClassDef)parent).AddGenericParam(this); } } }
/*-------------------- Constructors ---------------------------------*/ internal DeclSecurity(MetaDataElement paren, SecurityAction act, byte[] perSet) { Contract.Requires(perSet != null); parent = paren; action = act; permissionSet = perSet; tabIx = MDTable.DeclSecurity; }
/*-------------------- Constructors ---------------------------------*/ internal ExternClass(TypeAttr attr, string ns, string name, MetaDataElement paren) { flags = (uint)attr; NameSpace = ns; this.Name = name; implementation = paren; tabIx = MDTable.ExportedType; }
/*-------------------- Constructors ---------------------------------*/ internal ExternClass(TypeAttr attr, string ns, string name, MetaDataElement paren) { flags = (uint)attr; NameSpace = ns; this.Name = name; implementation = paren; tabIx = MDTable.ExportedType; }
internal override void Resolve(PEReader buff) { implementation = buff.GetCodedElement(CIx.Implementation, implIx); while (implementation is ExternClass) { implementation = ((ExternClass)implementation).implementation; } ((ModuleFile)implementation).fileModule.AddExternClass(this); }
internal void CheckParent(MethodDef paren, PEReader buff) { Contract.Requires(buff != null); if (paren == buff.GetCodedElement(CIx.TypeOrMethodDef, parentIx)) { parent = paren; paren.InsertGenericParam(this); } }
internal void ConditionalAddTypeSpec(MetaDataElement elem) { ArrayList table = GetTable(MDTable.TypeSpec); if (!table.Contains(elem)) { elem.Row = (uint)table.Count + 1; table.Add(elem); } }
/*-------------------- Constructors ---------------------------------*/ internal CustomAttribute(MetaDataElement paren, Method constrType, Constant[] val) { Contract.Requires(constrType != null); parent = paren; type = constrType; argVals = val; changed = true; tabIx = MDTable.CustomAttribute; }
/*-------------------- Constructors ---------------------------------*/ internal CustomAttribute(MetaDataElement paren, Method constrType, Constant[] val) { Contract.Requires(constrType != null); parent = paren; type = constrType; argVals = val; changed = true; tabIx = MDTable.CustomAttribute; }
private static Type SubstituteType(Type origType, MetaDataElement paren, Type[] genTypes) { Contract.Requires(origType != null); Contract.Requires(paren != null); Contract.Requires(genTypes != null); if ((origType is GenericParam) && (((GenericParam)origType).GetParent() == paren)) { return(genTypes[((GenericParam)origType).Index]); } return(origType); }
internal override Member ResolveParent(PEReader buff) { if (parent != null) { return(this); } buff.currentMethodScope = this; MetaDataElement paren = buff.GetCodedElement(CIx.MemberRefParent, parentIx); buff.currentMethodScope = null; if (paren is MethodDef) { parent = null; varArgParent = (MethodDef)paren; //this.sig = buff.ReadMethSig(this,name,sigIx); ((MethodDef)paren).AddVarArgSig(this); return(this); } else if (paren is ClassSpec) { ((ClassSpec)paren).AddMethod(this); return(this); } else if (paren is PrimitiveType) { paren = MSCorLib.mscorlib.GetDefaultClass(); } else if (paren is ClassDef) { this.sig = buff.ReadMethSig(this, name, sigIx); return(((ClassDef)paren).GetMethod(this.sig)); } else if (paren is TypeSpec) { paren = new ConstructedTypeSpec((TypeSpec)paren); //Console.WriteLine("Got TypeSpec as parent of Member"); //return this; //throw new Exception("Got TypeSpec as parent of Member"); //((TypeSpec)paren).AddMethod(buff,this); } if (paren is ReferenceScope) { parent = ((ReferenceScope)paren).GetDefaultClass(); } parent = (Class)paren; //if ((MethodRef)parent.GetMethodDesc(name) != null) throw new PEFileException("Existing method!!"); //sig = buff.ReadMethSig(this,name,sigIx); //MethodRef existing = (MethodRef)parent.GetMethod(sig); //if (existing != null) // return existing; parent.AddToMethodList(this); return(this); }
internal static DeclSecurity FindSecurity(PEReader buff, MetaDataElement paren, uint codedParIx) { buff.SetElementPosition(MDTable.DeclSecurity, 0); for (int i = 0; i < buff.GetTableSize(MDTable.DeclSecurity); i++) { uint act = buff.ReadUInt16(); if (buff.GetCodedIndex(CIx.HasDeclSecurity) == codedParIx) return new DeclSecurity(paren, (SecurityAction)act, buff.GetBlob()); uint junk = buff.GetBlobIx(); } return null; }
internal sealed override void BuildTables(MetaDataOut md) { md.AddToTable(MDTable.ExportedType, this); nameSpaceIx = md.AddToStringsHeap(NameSpace); nameIx = md.AddToStringsHeap(Name); if (implementation is ModuleRef) { ModuleFile mFile = ((ModuleRef)implementation).modFile; mFile.BuildMDTables(md); implementation = mFile; } }
internal override void Resolve(PEReader buff) { field = buff.GetCodedElement(CIx.HasFieldMarshal, parentIx); nt = buff.GetBlobNativeType(ntIx); if (field is FieldDef) { ((FieldDef)field).SetMarshalType(nt); } else { ((Param)field).SetMarshalType(nt); } }
private static Type[] ReplaceGenPars([CanBeNull] Type[] typeList, MetaDataElement paren, Type[] genTypes) { if (typeList == null) { return(null); } Type[] newList = new Type[typeList.Length]; for (int i = 0; i < typeList.Length; i++) { newList[i] = SubstituteType(typeList[i], paren, genTypes); } return(newList); }
internal GenericParam(string name, MetaDataElement parent, int index) : base(VAR) { Contract.Requires(name != null); Contract.Requires(parent != null); this.name = name; this.parent = parent; this.index = (ushort)index; if (parent is Method) { typeIndex = MVAR; } tabIx = MDTable.GenericParam; }
internal void AddToTable(MDTable tableIx, MetaDataElement elem) { // Console.WriteLine("Adding element to table " + (uint)tableIx); ArrayList table = GetTable(tableIx); if (table.Contains(elem)) { Console.Out.WriteLine("ERROR - element already in table " + tableIx); return; } elem.Row = (uint)table.Count + 1; table.Add(elem); }
internal void WriteCodedIndex(CIx code, MetaDataElement elem, PEWriter output) { uint ix = 0; if (elem != null) { ix = (elem.Row << CIxShiftMap[(uint)code]) | elem.GetCodedIx(code); // Console.WriteLine("coded index = " + ix + " row = " + elem.Row); //} else { // Console.WriteLine("elem for coded index is null"); } if (lgeCIx[(uint)code]) { output.Write(ix); } else { output.Write((ushort)ix); } }
internal virtual void ResolveParent(PEReader buff, bool isExtern) { CIx cIx = CIx.ResolutionScope; if (isExtern) { cIx = CIx.Implementation; } if (scope != null) { return; } MetaDataElement parentScope = buff.GetCodedElement(cIx, resScopeIx); if (parentScope is Module) { // special code for glitch in Everett ilasm ClassDef newDef = new ClassDef((PEFile)parentScope, 0, NameSpace, Name); ((Module)parentScope).AddToClassList(newDef); buff.InsertInTable(MDTable.TypeRef, Row, newDef); } else { scope = (ReferenceScope)buff.GetCodedElement(cIx, resScopeIx); ClassRef existing = (ClassRef)scope.GetExistingClass(NameSpace, Name); if (existing == null) { scope.AddToClassList(this); } else { if (isExtern) { buff.InsertInTable(MDTable.ExportedType, Row, existing); } else { buff.InsertInTable(MDTable.TypeRef, Row, existing); } } } }
internal override Member ResolveParent(PEReader buff) { if (parent != null) { return(this); } MetaDataElement paren = buff.GetCodedElement(CIx.MemberRefParent, parentIx); //Console.WriteLine("parentIx = " + parentIx); //Console.WriteLine("paren = " + paren); if (paren is ClassDef) { return(((ClassDef)paren).GetField(this.name)); } //if (paren is ClassSpec) // paren = ((ClassSpec)paren).GetParent(); if (paren is ReferenceScope) { parent = ((ReferenceScope)paren).GetDefaultClass(); } if (paren is TypeSpec) { parent = new ConstructedTypeSpec((TypeSpec)paren); } else { parent = (Class)paren; } if (parent != null) { Field existing = (Field)((Class)parent).GetFieldDesc(name); if (existing != null) { return(existing); } } parent.AddToFieldList(this); return(this); }
internal void SetClassParam(Class paren, int ix) { typeIndex = VAR; parent = paren; index = (ushort)ix; }
internal override void Resolve(PEReader buff) { field = buff.GetCodedElement(CIx.HasFieldMarshal, parentIx); nt = buff.GetBlobNativeType(ntIx); if (field is FieldDef) { ((FieldDef)field).SetMarshalType(nt); } else { ((Param)field).SetMarshalType(nt); } }
internal void WriteCodedIndex(CIx code, MetaDataElement elem, PEWriter output) { uint ix = 0; if (elem != null) { ix = (elem.Row << CIxShiftMap[(uint)code]) | elem.GetCodedIx(code); // Console.WriteLine("coded index = " + ix + " row = " + elem.Row); //} else { // Console.WriteLine("elem for coded index is null"); } if (lgeCIx[(uint)code]) output.Write(ix); else output.Write((ushort)ix); }
internal void ConditionalAddTypeSpec(MetaDataElement elem) { ArrayList table = GetTable(MDTable.TypeSpec); if (!table.Contains(elem)) { elem.Row = (uint)table.Count + 1; table.Add(elem); } }
internal CustomAttribute(MetaDataElement paren, Method constrType, byte[] val)
internal void ResolveType(MetaData md) { exceptType = ((Type)exceptType).GetTypeSpec(md); }
internal void DescriptorError(MetaDataElement elem) { Contract.Requires(elem != null); throw new DescriptorException(elem.NameString()); }
internal override void Resolve(PEReader buff) { parent = buff.GetCodedElement(CIx.HasDeclSecurity, parentIx); if (parent != null) { if (parent is ClassDef) ((ClassDef)parent).AddSecurity(this); if (parent is Assembly) ((Assembly)parent).AddSecurity(this); if (parent is MethodDef) ((MethodDef)parent).AddSecurity(this); } }
internal void SetMethParam(Method paren, int ix) { typeIndex = MVAR; parent = paren; index = (ushort)ix; }
/*-------------------- Constructors ---------------------------------*/ internal ConstantElem(MetaDataElement parent, Constant val) { Contract.Requires(val != null); this.parent = parent; cValue = val; tabIx = MDTable.Constant; }
internal void SetClassParam(Class paren, int ix) { typeIndex = VAR; parent = paren; index = (ushort)ix; }
internal void CheckParent(MethodDef paren, PEReader buff) { Contract.Requires(buff != null); if (paren == buff.GetCodedElement(CIx.TypeOrMethodDef, parentIx)) { parent = paren; paren.InsertGenericParam(this); } }
internal GenericParam(PEReader buff) : base(VAR) { Contract.Requires(buff != null); index = buff.ReadUInt16(); flags = buff.ReadUInt16(); parentIx = buff.GetCodedIndex(CIx.TypeOrMethodDef); name = buff.GetString(); if (extraField) kind = buff.ReadUInt16(); tabIx = MDTable.GenericParam; // resolve generic param immediately for signature resolution parent = buff.GetCodedElement(CIx.TypeOrMethodDef, parentIx); if (parent != null) { if (parent is MethodDef) { typeIndex = MVAR; ((MethodDef)parent).AddGenericParam(this); } else { ((ClassDef)parent).AddGenericParam(this); } } }
private static Type[] ReplaceGenPars([CanBeNull] Type[] typeList, MetaDataElement paren, Type[] genTypes) { if (typeList == null) return null; Type[] newList = new Type[typeList.Length]; for (int i = 0; i < typeList.Length; i++) { newList[i] = SubstituteType(typeList[i], paren, genTypes); } return newList; }
public string GetMetaDataLanguage() => MetaDataElement.GetAttribute("data-meta-language");
internal GenericParam(string name, MetaDataElement parent, int index) : base(VAR) { Contract.Requires(name != null); Contract.Requires(parent != null); this.name = name; this.parent = parent; this.index = (ushort)index; if (parent is Method) typeIndex = MVAR; tabIx = MDTable.GenericParam; }
internal override void Resolve(PEReader buff) { implementation = buff.GetCodedElement(CIx.Implementation, implIx); while (implementation is ExternClass) implementation = ((ExternClass)implementation).implementation; ((ModuleFile)implementation).fileModule.AddExternClass(this); }
internal TypeInstr(int inst, Type aType, MetaData md) : base(inst) { theType = aType.GetTypeSpec(md); size += 4; }
internal void SetEntryPoint(MetaDataElement ep) { entryPoint = ep; }
internal void ClassToken(MetaDataElement cToken) { Contract.Requires(cToken != null); classToken = cToken; }
internal override sealed void BuildTables(MetaDataOut md) { md.AddToTable(MDTable.ExportedType, this); nameSpaceIx = md.AddToStringsHeap(NameSpace); nameIx = md.AddToStringsHeap(Name); if (implementation is ModuleRef) { ModuleFile mFile = ((ModuleRef)implementation).modFile; mFile.BuildMDTables(md); implementation = mFile; } }
internal void AddToTable(MDTable tableIx, MetaDataElement elem) { // Console.WriteLine("Adding element to table " + (uint)tableIx); ArrayList table = GetTable(tableIx); if (table.Contains(elem)) { Console.Out.WriteLine("ERROR - element already in table " + tableIx); return; } elem.Row = (uint)table.Count + 1; table.Add(elem); }
internal void WriteCodedIndex(CIx code, MetaDataElement elem) { Contract.Requires(elem != null); metaData.WriteCodedIndex(code, elem, this); }
internal void SetEntryPoint(MetaDataElement ep) { entryPoint = ep; }
internal void ClassToken(MetaDataElement cToken) { Contract.Requires(cToken != null); classToken = cToken; }
internal void SetMethParam(Method paren, int ix) { typeIndex = MVAR; parent = paren; index = (ushort)ix; }
internal void InsertInTable(MDTable tabIx, uint ix, MetaDataElement elem) { Contract.Requires(elem != null); tables[(int)tabIx][ix - 1] = elem; }
internal void WriteCodedIndex(CIx code, MetaDataElement elem) { Contract.Requires(elem != null); metaData.WriteCodedIndex(code, elem, this); }
private void RenderInfoGroupElement(ComponentController paComponentController, String paInfoLabel, MetaDataElement paMetaDataElement) { if ((paMetaDataElement != null) && (paMetaDataElement.ValueCount > 0)) { paComponentController.AddAttribute(HtmlAttribute.Class, ctCLSInfoRow); paComponentController.RenderBeginTag(HtmlTag.Div); paComponentController.AddAttribute(HtmlAttribute.Class, ctCLSInfoLabel); paComponentController.RenderBeginTag(HtmlTag.Div); paComponentController.Write(paInfoLabel); paComponentController.RenderEndTag(); paComponentController.AddAttribute(HtmlAttribute.Class, clCLSInfoData); paComponentController.RenderBeginTag(HtmlTag.Div); for (int lcCount = 0; lcCount < paMetaDataElement.ValueCount; lcCount++) { paComponentController.RenderBeginTag(HtmlTag.Span); paComponentController.Write(paMetaDataElement[lcCount].Replace(".", " ")); paComponentController.RenderEndTag(); } paComponentController.RenderEndTag(); paComponentController.RenderEndTag(); } }
internal CustomAttribute(MetaDataElement paren, Method constrType, byte[] val)
public Catch(Type except, CILLabel handlerStart, CILLabel handlerEnd) : base(handlerStart, handlerEnd) { exceptType = except; }
private static Type SubstituteType(Type origType, MetaDataElement paren, Type[] genTypes) { Contract.Requires(origType != null); Contract.Requires(paren != null); Contract.Requires(genTypes != null); if ((origType is GenericParam) && (((GenericParam)origType).GetParent() == paren)) return genTypes[((GenericParam)origType).Index]; return origType; }
internal override void Resolve(PEReader buff) { parent = buff.GetCodedElement(CIx.HasConstant, parentIx); if (parent != null) { if (parent is Param) ((Param)parent).AddDefaultValue(cValue); else if (parent is FieldDef) ((FieldDef)parent).AddValue(cValue); else ((Property)parent).AddInitValue(cValue); } }