Beispiel #1
0
        private bool GetAccessor(MethodSemanticsAttributes methodSemanticsAttribute, out MethodHandle methodHandle)
        {
            bool inherited = !_reflectedType.Equals(_contextTypeInfo);

            foreach (MethodSemanticsHandle methodSemanticsHandle in _property.MethodSemantics)
            {
                MethodSemantics methodSemantics = methodSemanticsHandle.GetMethodSemantics(_reader);
                if (methodSemantics.Attributes == methodSemanticsAttribute)
                {
                    methodHandle = methodSemantics.Method;

                    if (inherited)
                    {
                        MethodAttributes flags = methodHandle.GetMethod(_reader).Flags;
                        if ((flags & MethodAttributes.MemberAccessMask) == MethodAttributes.Private)
                        {
                            continue;
                        }
                    }

                    return(true);
                }
            }
            methodHandle = default(MethodHandle);
            return(false);
        }
        protected sealed override MethodInfo GetEventMethod(EventMethodSemantics whichMethod)
        {
            NativeFormatMethodSemanticsAttributes localMethodSemantics;

            switch (whichMethod)
            {
            case EventMethodSemantics.Add:
                localMethodSemantics = NativeFormatMethodSemanticsAttributes.AddOn;
                break;

            case EventMethodSemantics.Fire:
                localMethodSemantics = NativeFormatMethodSemanticsAttributes.Fire;
                break;

            case EventMethodSemantics.Remove:
                localMethodSemantics = NativeFormatMethodSemanticsAttributes.RemoveOn;
                break;

            default:
                return(null);
            }

            foreach (MethodSemanticsHandle methodSemanticsHandle in _event.MethodSemantics)
            {
                MethodSemantics methodSemantics = methodSemanticsHandle.GetMethodSemantics(_reader);
                if (methodSemantics.Attributes == localMethodSemantics)
                {
                    return(RuntimeNamedMethodInfo <NativeFormatMethodCommon> .GetRuntimeNamedMethodInfo(new NativeFormatMethodCommon(methodSemantics.Method, _definingTypeInfo, ContextTypeInfo), ReflectedTypeInfo));
                }
            }

            return(null);
        }
        public void AddSemanticsAgainShouldThrow()
        {
            var semantics = new MethodSemantics(_getMethod, MethodSemanticsAttributes.Getter);

            _property.Semantics.Add(semantics);

            Assert.Throws <ArgumentException>(() => _property.Semantics.Add(semantics));
        }
        public void AddExistingSemanticsToAnotherOwnerShouldThrow()
        {
            var semantics = new MethodSemantics(_getMethod, MethodSemanticsAttributes.Getter);

            _property.Semantics.Add(semantics);

            Assert.Throws <ArgumentException>(() => _property2.Semantics.Add(semantics));
        }
        public void AddSemanticsShouldSetSemanticsPropertyOfMethod()
        {
            var semantics = new MethodSemantics(_getMethod, MethodSemanticsAttributes.Getter);

            _property.Semantics.Add(semantics);

            Assert.Same(semantics, _getMethod.Semantics);
        }
        public void RemoveSemanticsShouldUnsetSemanticsPropertyOfMethod()
        {
            var semantics = new MethodSemantics(_getMethod, MethodSemanticsAttributes.Getter);

            _property.Semantics.Add(semantics);
            _property.Semantics.Remove(semantics);

            Assert.Null(_getMethod.Semantics);
        }
 public override string GetDisplayName(MethodSemantics semantic)
 {
     var sb = new StringBuilder("Enhanced property");
     if (semantic == MethodSemantics.Setter) {
         sb.Append(" setter");
     }
     sb.Append(" with equality check");
     return sb.ToString();
 }
        public void ClearMultipleSemanticsShouldUnsetAllSemanticsProperties()
        {
            var semantics1 = new MethodSemantics(_getMethod, MethodSemanticsAttributes.Getter);
            var semantics2 = new MethodSemantics(_setMethod, MethodSemanticsAttributes.Getter);

            _property.Semantics.Add(semantics1);
            _property.Semantics.Add(semantics2);

            _property.Semantics.Clear();

            Assert.Null(_getMethod.Semantics);
            Assert.Null(_setMethod.Semantics);
        }
        private void AddMethodSemantics(MetadataToken ownerToken, MethodSemantics semantics)
        {
            var table   = Metadata.TablesStream.GetSortedTable <MethodSemantics, MethodSemanticsRow>(TableIndex.MethodSemantics);
            var encoder = Metadata.TablesStream.GetIndexEncoder(CodedIndex.HasSemantics);

            var row = new MethodSemanticsRow(
                semantics.Attributes,
                GetMethodDefinitionToken(semantics.Method).Rid,
                encoder.EncodeToken(ownerToken)
                );

            table.Add(semantics, row);
        }
Beispiel #10
0
 internal void AddMethod(MethodSemantics meth)
 {
     if (tide == methods.Length)
     {
         MethodSemantics[] mTmp = methods;
         methods = new MethodSemantics[tide * 2];
         for (int i = 0; i < tide; i++)
         {
             methods[i] = mTmp[i];
         }
     }
     methods[tide++] = meth;
 }
Beispiel #11
0
 internal void WriteMethodSemantics(MethodSemantics semantics)
 {
     if (semantics.UpdateRowOnRebuild)
     {
         object[] parts = new object[]
         {
             (ushort)semantics.Attributes,
             GetMemberIndex(semantics.Method),
             GetCodedIndex(tablesHeap.HasSemantics, semantics.Association),
         };
         semantics.MetaDataRow = new MetaDataRow(parts);
     }
     writer.Write(semantics.MetaDataRow.GenerateBytes());
 }
Beispiel #12
0
 private bool GetAccessor(MethodSemanticsAttributes methodSemanticsAttribute, out MethodHandle methodHandle)
 {
     foreach (MethodSemanticsHandle methodSemanticsHandle in _property.MethodSemantics)
     {
         MethodSemantics methodSemantics = methodSemanticsHandle.GetMethodSemantics(_reader);
         if (methodSemantics.Attributes == methodSemanticsAttribute)
         {
             methodHandle = methodSemantics.Method;
             return(true);
         }
     }
     methodHandle = default(MethodHandle);
     return(false);
 }
Beispiel #13
0
        private void AddSemantics(MethodSemantics semantics)
        {
            var table = (MethodSemanticsTable)_tableStream.GetTable(MetadataTokenType.MethodSemantics);

            // Create and add row.
            var semanticsRow = new MetadataRow <MethodSemanticsAttributes, uint, uint>
            {
                Column1 = semantics.Attributes,
                Column2 = GetNewToken(semantics.Method).Rid,
                Column3 = _tableStream.GetIndexEncoder(CodedIndex.HasSemantics)
                          .EncodeToken(GetNewToken(semantics.Association))
            };

            table.Add(semanticsRow);
            _members.Add(semantics, semanticsRow.MetadataToken);
        }
Beispiel #14
0
 internal void CalcElemSize()
 {
     elemSize[(int)MDTable.Assembly]             = Assembly.Size(this);
     elemSize[(int)MDTable.AssemblyOS]           = 12;
     elemSize[(int)MDTable.AssemblyProcessor]    = 4;
     elemSize[(int)MDTable.AssemblyRefOS]        = 12 + TableIndexSize(MDTable.AssemblyRef);
     elemSize[(int)MDTable.AssemblyRefProcessor] = 4 + TableIndexSize(MDTable.AssemblyRef);
     elemSize[(int)MDTable.Module]                 = Module.Size(this);
     elemSize[(int)MDTable.TypeRef]                = ClassRef.Size(this);
     elemSize[(int)MDTable.TypeDef]                = ClassDef.Size(this);
     elemSize[(int)MDTable.Field]                  = FieldDef.Size(this);
     elemSize[(int)MDTable.Method]                 = MethodDef.Size(this);
     elemSize[(int)MDTable.Param]                  = Param.Size(this);
     elemSize[(int)MDTable.InterfaceImpl]          = InterfaceImpl.Size(this);
     elemSize[(int)MDTable.MemberRef]              = FieldRef.Size(this);
     elemSize[(int)MDTable.Constant]               = ConstantElem.Size(this);
     elemSize[(int)MDTable.CustomAttribute]        = CustomAttribute.Size(this);
     elemSize[(int)MDTable.FieldMarshal]           = FieldMarshal.Size(this);
     elemSize[(int)MDTable.DeclSecurity]           = DeclSecurity.Size(this);
     elemSize[(int)MDTable.ClassLayout]            = ClassLayout.Size(this);
     elemSize[(int)MDTable.FieldLayout]            = FieldLayout.Size(this);
     elemSize[(int)MDTable.StandAloneSig]          = Signature.Size(this);
     elemSize[(int)MDTable.EventMap]               = MapElem.Size(this, MDTable.EventMap);
     elemSize[(int)MDTable.Event]                  = Event.Size(this);
     elemSize[(int)MDTable.PropertyMap]            = MapElem.Size(this, MDTable.PropertyMap);
     elemSize[(int)MDTable.Property]               = Property.Size(this);
     elemSize[(int)MDTable.MethodSemantics]        = MethodSemantics.Size(this);
     elemSize[(int)MDTable.MethodImpl]             = MethodImpl.Size(this);
     elemSize[(int)MDTable.ModuleRef]              = ModuleRef.Size(this);
     elemSize[(int)MDTable.TypeSpec]               = TypeSpec.Size(this);
     elemSize[(int)MDTable.ImplMap]                = ImplMap.Size(this);
     elemSize[(int)MDTable.FieldRVA]               = FieldRVA.Size(this);
     elemSize[(int)MDTable.Assembly]               = Assembly.Size(this);
     elemSize[(int)MDTable.AssemblyRef]            = AssemblyRef.Size(this);
     elemSize[(int)MDTable.File]                   = FileRef.Size(this);
     elemSize[(int)MDTable.ExportedType]           = ExternClass.Size(this);
     elemSize[(int)MDTable.ManifestResource]       = ManifestResource.Size(this);
     elemSize[(int)MDTable.NestedClass]            = MapElem.Size(this, MDTable.NestedClass);
     elemSize[(int)MDTable.GenericParam]           = GenericParam.Size(this);
     elemSize[(int)MDTable.GenericParamConstraint] = GenericParamConstraint.Size(this);
     elemSize[(int)MDTable.MethodSpec]             = MethodSpec.Size(this);
 }
Beispiel #15
0
        protected sealed override RuntimeNamedMethodInfo GetPropertyMethod(PropertyMethodSemantics whichMethod)
        {
            NativeFormatMethodSemanticsAttributes localMethodSemantics;

            switch (whichMethod)
            {
            case PropertyMethodSemantics.Getter:
                localMethodSemantics = NativeFormatMethodSemanticsAttributes.Getter;
                break;

            case PropertyMethodSemantics.Setter:
                localMethodSemantics = NativeFormatMethodSemanticsAttributes.Setter;
                break;

            default:
                return(null);
            }

            bool inherited = !_reflectedType.Equals(ContextTypeInfo);

            foreach (MethodSemanticsHandle methodSemanticsHandle in _property.MethodSemantics)
            {
                MethodSemantics methodSemantics = methodSemanticsHandle.GetMethodSemantics(_reader);
                if (methodSemantics.Attributes == localMethodSemantics)
                {
                    MethodHandle methodHandle = methodSemantics.Method;

                    if (inherited)
                    {
                        MethodAttributes flags = methodHandle.GetMethod(_reader).Flags;
                        if ((flags & MethodAttributes.MemberAccessMask) == MethodAttributes.Private)
                        {
                            continue;
                        }
                    }

                    return(RuntimeNamedMethodInfo <NativeFormatMethodCommon> .GetRuntimeNamedMethodInfo(new NativeFormatMethodCommon(methodHandle, _definingTypeInfo, ContextTypeInfo), _reflectedType));
                }
            }

            return(null);
        }
 public override MethodBodyTransformationOptions GetOptions(MetadataDeclaration originalTargetElement, MethodSemantics semantic)
 {
     return(MethodBodyTransformationOptions.None);
 }
 public override string GetDisplayName(MethodSemantics semantic)
 {
     return("Logging Transformation");
 }
Beispiel #18
0
 public override string GetDisplayName(MethodSemantics semantic)
 {
     return("FastTrace");
 }
 public override string GetDisplayName(MethodSemantics semantic)
 {
     return("Implement ICloneable");
 }
 public override string GetDisplayName( MethodSemantics semantic )
 {
     return "Implement ICloneable";
 }
 public override string GetDisplayName(MethodSemantics semantic)
 {
     return "Logging Transformation";
 }
 public override string GetDisplayName( MethodSemantics semantic )
 {
     return "Implement Validation";
 }
 public override string GetDisplayName(MethodSemantics semantic)
 {
     var sb = new StringBuilder("Invokes PropertyChanged event");
     return sb.ToString();
 }
 public override string GetDisplayName(MethodSemantics semantic)
 {
     return("Add actor support to state machine.");
 }
Beispiel #25
0
 internal void AddMethod(MethodSemantics meth)
 {
     if (tide == methods.Length)
     {
         MethodSemantics[] mTmp = methods;
         methods = new MethodSemantics[tide * 2];
         for (int i = 0; i < tide; i++)
         {
             methods[i] = mTmp[i];
         }
     }
     methods[tide++] = meth;
 }
Beispiel #26
0
 internal static void Read(PEReader buff, TableRow[] methSems)
 {
     Contract.Requires(buff != null);
     for (int i = 0; i < methSems.Length; i++)
         methSems[i] = new MethodSemantics(buff);
 }
Beispiel #27
0
 public override string GetDisplayName(MethodSemantics semantic)
 {
     return("Implement Validation");
 }
 public override string GetDisplayName(MethodSemantics semantic)
 {
     return "FastTrace";
 }
Beispiel #29
0
        public Tabels(PEFile p)
        {
            //Init
            this.r = p.MetadataReader;

            //Read all of the tabels
            ModuleTabel           = new List <Module>();
            TypeRefTabel          = new List <TypeRef>();
            TypeDefTabel          = new List <TypeDef>();
            FieldTabel            = new List <Field>();
            MethodTabel           = new List <Method>();
            ParmTabel             = new List <Param>();
            InterfaceImplTable    = new List <InterfaceImpl>();
            MemberRefTabelRow     = new List <MemberRef>();
            ConstantTabel         = new List <Constant>();
            CustomAttributeTabel  = new List <CustomAttribute>();
            FieldMarshalTabel     = new List <FieldMarshal>();
            DeclSecurityTabel     = new List <DeclSecurity>();
            ClassLayoutTabel      = new List <ClassLayout>();
            FieldLayoutTabel      = new List <FieldLayout>();
            StandAloneSigTabel    = new List <StandAloneSig>();
            EventMapTabel         = new List <EventMap>();
            EventTabel            = new List <Event>();
            PropertyMapTabel      = new List <PropertyMap>();
            PropertyTabel         = new List <PropertyTabel>();
            MethodSemanticsTabel  = new List <MethodSemantics>();
            MethodImplTabel       = new List <MethodImpl>();
            ModuleRefTabel        = new List <ModuleRef>();
            TypeSpecTabel         = new List <TypeSpec>();
            ImplMapTabel          = new List <ImplMap>();
            FieldRVATabel         = new List <FieldRVA>();
            AssemblyTabel         = new List <Assembly>();
            AssemblyRefTabel      = new List <AssemblyRef>();
            FileTable             = new List <File>();
            ExportedTypeTable     = new List <ExportedType>();
            ManifestResourceTable = new List <ManifestResource>();
            NestedClassTable      = new List <NestedClass>();
            GenericParamTable     = new List <GenericParam>();
            MethodSpecTable       = new List <MethodSpec>();

            int a = 0;

            //Read module Tabel (if any)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Module) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Module();
                    m.Read(r);
                    ModuleTabel.Add(m);
                }
                a++;
            }
            //Read TypeRef Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeRef) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new TypeRef();
                    m.Read(r);
                    TypeRefTabel.Add(m);
                }
                a++;
            }
            //Read TypeDef Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeDef) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new TypeDef();
                    m.Read(r);
                    TypeDefTabel.Add(m);
                }
                a++;
            }
            //Read Field Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Field) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Field();
                    m.Read(r);
                    FieldTabel.Add(m);
                }
                a++;
            }
            //Read Method tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Method) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Method();
                    m.Read(r);
                    MethodTabel.Add(m);
                }
                a++;
            }
            //Read Parm Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Param) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Param();
                    m.Read(r);
                    ParmTabel.Add(m);
                }
                a++;
            }
            //Read interfaceimpl Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.InterfaceImpl) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new InterfaceImpl();
                    m.Read(r);
                    InterfaceImplTable.Add(m);
                }
                a++;
            }
            //Read MemberRef tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MemberRef) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new MemberRef();
                    m.Read(r);
                    MemberRefTabelRow.Add(m);
                }
                a++;
            }
            //Read Constant tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Constant) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Constant();
                    m.Read(r);
                    ConstantTabel.Add(m);
                }
                a++;
            }
            //Read CustomAttribute tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.CustomAttribute) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new CustomAttribute();
                    m.Read(r);
                    CustomAttributeTabel.Add(m);
                }
                a++;
            }
            //Read FieldMarshal tabel (Please test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldMarshal) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new FieldMarshal();
                    m.Read(r);
                    FieldMarshalTabel.Add(m);
                }
                a++;
            }
            //Read DeclSecurity tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.DeclSecurity) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new DeclSecurity();
                    m.Read(r);
                    DeclSecurityTabel.Add(m);
                }
                a++;
            }
            //Read ClassLayout tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ClassLayout) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new ClassLayout();
                    m.Read(r);
                    ClassLayoutTabel.Add(m);
                }
                a++;
            }
            //Read FieldLayout tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldLayout) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new FieldLayout();
                    m.Read(r);
                    FieldLayoutTabel.Add(m);
                }
                a++;
            }
            //Read StandAloneSig tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.StandAloneSig) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new StandAloneSig();
                    m.Read(r);
                    StandAloneSigTabel.Add(m);
                }
                a++;
            }
            //Read EventMap tabel (please test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.EventMap) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new EventMap();
                    m.Read(r);
                    EventMapTabel.Add(m);
                }
                a++;
            }
            //Read event tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Event) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Event();
                    m.Read(r);
                    EventTabel.Add(m);
                }
                a++;
            }
            //Read Property Map tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.PropertyMap) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new PropertyMap();
                    m.Read(r);
                    PropertyMapTabel.Add(m);
                }
                a++;
            }
            //Read Property tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Property) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new PropertyTabel();
                    m.Read(r);
                    PropertyTabel.Add(m);
                }
                a++;
            }
            //Read MethodSemantics  tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodSemantics) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new MethodSemantics();
                    m.Read(r);
                    MethodSemanticsTabel.Add(m);
                }
                a++;
            }
            //Read MethodImpl tabel (Please test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodImpl) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new MethodImpl();
                    m.Read(r);
                    MethodImplTabel.Add(m);
                }
                a++;
            }
            //Read ModuleRef tabel (pls test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ModuleRef) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new ModuleRef();
                    m.Read(r);
                    ModuleRefTabel.Add(m);
                }
                a++;
            }
            //Read TypeSpec tabel (pls test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.TypeSpec) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new TypeSpec();
                    m.Read(r);
                    TypeSpecTabel.Add(m);
                }
                a++;
            }
            //Read ImplMap tabel (pls test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ImplMap) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new ImplMap();
                    m.Read(r);
                    ImplMapTabel.Add(m);
                }
                a++;
            }
            //Read FieldRVA  tabel (pls test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.FieldRVA) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new FieldRVA();
                    m.Read(r);
                    FieldRVATabel.Add(m);
                }
                a++;
            }
            //Read Assembly tabel (pls test)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.Assembly) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new Assembly();
                    m.Read(r);
                    AssemblyTabel.Add(m);
                }
                a++;
            }

            //Read ignored tabels (These never should be present!)
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyProcessor) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var proc = r.ReadUInt32();
                }
                a++;
            }
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyOS) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    r.BaseStream.Position += 11; //Test please
                }
                a++;
            }
            //Read AssemblyRef Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRef) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new AssemblyRef();
                    m.Read(r);
                    AssemblyRefTabel.Add(m);
                }
                a++;
            }
            //Read AssemblyRefProcessor Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRefProcessor) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    r.BaseStream.Position += 8; //Test please
                }
                a++;
            }
            //Read AssemblyRefOS Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.AssemblyRefOS) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    r.BaseStream.Position += 16; //Test please
                }
                a++;
            }
            //Read File Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.File) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new File();
                    m.Read(r);
                    FileTable.Add(m);
                }
                a++;
            }
            //Read ExportedType Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ExportedType) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new ExportedType();
                    m.Read(r);
                    ExportedTypeTable.Add(m);
                }
                a++;
            }
            //Read ManifestResource Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.ManifestResource) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new ManifestResource();
                    m.Read(r);
                    ManifestResourceTable.Add(m);
                }
                a++;
            }
            //Read NestedClass Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.NestedClass) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new NestedClass();
                    m.Read(r);
                    NestedClassTable.Add(m);
                }
                a++;
            }
            //Read GenericParam Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.GenericParam) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new GenericParam();
                    m.Read(r);
                    GenericParamTable.Add(m);
                }
                a++;
            }
            //Read MethodSpec Tabel
            if ((p.ClrMetaDataStreamHeader.TablesFlags & MetadataTableFlags.MethodSpec) != 0)
            {
                for (int i = 0; i < p.ClrMetaDataStreamHeader.TableSizes[a]; i++)
                {
                    var m = new MethodSpec();
                    m.Read(r);
                    MethodSpecTable.Add(m);
                }
                a++;
            }
        }
 public override MethodBodyTransformationOptions GetOptions(MetadataDeclaration originalTargetElement, MethodSemantics semantic)
 {
     return MethodBodyTransformationOptions.None;
 }
Beispiel #31
0
 private void UpdateMethodSemantics(Workspace workspace, MethodSemantics semantics)
 {
     semantics.MetaDataRow.Parts[1] = GetMemberIndex(workspace, semantics.Method);
     semantics.MetaDataRow.Parts[2] = GetMemberIndex(workspace, Constructor.OriginalAssembly.NETHeader.TablesHeap.HasSemantics, semantics.Association);
 }