Пример #1
0
        private static Dictionary <MethodImplKey, int> CalculateMethodImpls(MetadataReader reader)
        {
            Dictionary <MethodImplKey, int> result = new Dictionary <MethodImplKey, int>();
            int n = reader.GetTableRowCount(TableIndex.MethodImpl);

            for (int row = 1; row <= n; row++)
            {
                MethodImplementation methodImpl = reader.GetMethodImplementation(MetadataTokens.MethodImplementationHandle(row));
                // Hold on to the implementing method def but use a simple
                // index for the implemented method ref token. (We do not map
                // member refs currently, and since we don't allow changes to
                // the set of methods a method def implements, the actual
                // tokens of the implemented methods are not needed.)
                int methodDefRow = MetadataTokens.GetRowNumber(methodImpl.MethodBody);
                int index        = 1;
                while (true)
                {
                    MethodImplKey key = new MethodImplKey(methodDefRow, index);
                    if (!result.ContainsKey(key))
                    {
                        result.Add(key, row);
                        break;
                    }
                    index++;
                }
            }
            return(result);
        }
Пример #2
0
        private void CreateExplicitInterfaceImplementations(TypeDefinitionMember member)
        {
            List <ITypeDefinitionMember> interfaceMembers = Util.FindRelatedInterfaceMembers(member);

            foreach (ITypeDefinitionMember interfaceMember in interfaceMembers)
            {
                IMethodDefinition methodDef = interfaceMember.ResolvedTypeDefinitionMember as IMethodDefinition;
                if (methodDef != null)
                {
                    List <IMethodImplementation> methodImpls = null;
                    methodImpls = GetExplicitImplementationOverrides(member, methodImpls);

                    if (methodImpls != null)
                    {
                        // Make sure implementedmethod is in the closure
                        TrimType trimType = (TrimType)_currentTrimAssembly.GetTypeElement(Util.GetTypeName(Util.ContainingTypeDefinition(interfaceMember)));
                        if (trimType != null)
                        {
                            TrimMember trimMember = trimType.GetMemberElementFromMember(interfaceMember);
                            if (trimMember != null)
                            {
                                MethodImplementation methodImpl = new MethodImplementation();
                                methodImpl.ImplementedMethod  = interfaceMember.ResolvedTypeDefinitionMember as IMethodReference;
                                methodImpl.ImplementingMethod = member as IMethodReference;

                                methodImpl.ContainingType = member.ContainingTypeDefinition;
                                methodImpls.Add(Rewrite(methodImpl));
                            }
                        }
                    }
                }
            }
        }
Пример #3
0
 public MethodImplEntry(PEFile module, MethodImplementationHandle handle)
 {
     this.metadataOffset = module.Reader.PEHeaders.MetadataStartOffset;
     this.module         = module;
     this.metadata       = module.Metadata;
     this.handle         = handle;
     this.methodImpl     = metadata.GetMethodImplementation(handle);
 }
Пример #4
0
        private void SaveFormValues()
        {
            ConfigurationManager config = ConfigurationManager.GetConfigurationManager("WSCF05");

            config.Write("ClientCode", rbClient.Checked.ToString());
            config.Write("ServerCode", rbServer.Checked.ToString());

            config.Write("Properties", cbProperties.Checked.ToString());
            config.Write("Serializable", cbFormatSoapActions.Checked.ToString());
            config.Write("Collections", cbCollections.Checked.ToString());
            config.Write("GenericList", cbGenericList.Checked.ToString());
            config.Write("DataBinding", cbDataBinding.Checked.ToString());
            config.Write("OrderIdentifiers", cbOrderIds.Checked.ToString());
            config.Write("AsyncMethods", cbAsync.Checked.ToString());
            config.Write("MultipleFiles", cbMultipleFiles.Checked.ToString());
            config.Write("AdjustCasing", cbAdjustCasing.Checked.ToString());
            config.Write("ConcurrencyMode", cbConcurrencyMode.Text);
            config.Write("InstanceContextMode", cbInstanceContextMode.Text);
            config.Write("UseSynchronizationContext", cbUseSynchronizationContext.Checked.ToString());
            config.Write("EnableWsdlEndpoint", cbEnableWsdlEndpoint.Checked.ToString());
            config.Write("GenerateSvcFile", cbGenerateSvcFile.Checked.ToString());
            config.Write("MethodImplementation", MethodImplementation.ToString());

            config.Write("DestinationFilename", tbDestinationFilename.Text);
            config.Write("DestinationNamespace", tbDestinationNamespace.Text);

            config.Write("Overwrite", cbOverwrite.Checked.ToString());

            // BDS: Modified the code to store the values pasted to the combo box.
            if (cbWsdlLocation.SelectedItem != null)
            {
                config.Write("WSDLLocation", wsdlFileCache[cbWsdlLocation.SelectedIndex].ToString());
            }
            else
            {
                config.Write("WSDLLocation", cbWsdlLocation.Text);
            }

            config.Write("RememberSettings", cbSettings.Checked.ToString());


            string wsdlUrlsString = "";

            // Add the current item.
            if (cbWsdlLocation.SelectedItem == null)
            {
                string fname = AddWsdlFileToCache(cbWsdlLocation.Text);
            }

            foreach (string path in wsdlFileCache)
            {
                wsdlUrlsString += path + ";";
            }

            config.Write("WsdlUrls", wsdlUrlsString);
            config.Persist();
        }
Пример #5
0
        public void MethodImplEntry()
        {
            var text = @"
public class A
{
    ~A() { }
}
";

            CompileAndVerify(text, assemblyValidator: (assembly) =>
            {
                var peFileReader = assembly.GetMetadataReader();

                // Find the handle and row for A.
                var pairA = peFileReader.TypeDefinitions.AsEnumerable().
                            Select(handle => new { handle = handle, row = peFileReader.GetTypeDefinition(handle) }).
                            Single(pair => peFileReader.GetString(pair.row.Name) == "A" &&
                                   string.IsNullOrEmpty(peFileReader.GetString(pair.row.Namespace)));
                TypeDefinitionHandle handleA = pairA.handle;
                TypeDefinition typeA         = pairA.row;

                // Find the handle for A's destructor.
                MethodDefinitionHandle handleDestructorA = typeA.GetMethods().AsEnumerable().
                                                           Single(handle => peFileReader.GetString(peFileReader.GetMethodDefinition(handle).Name) == WellKnownMemberNames.DestructorName);


                // Find the handle for System.Object.
                TypeReferenceHandle handleObject = peFileReader.TypeReferences.AsEnumerable().
                                                   Select(handle => new { handle = handle, row = peFileReader.GetTypeReference(handle) }).
                                                   Single(pair => peFileReader.GetString(pair.row.Name) == "Object" &&
                                                          peFileReader.GetString(pair.row.Namespace) == "System").handle;

                // Find the handle for System.Object's destructor.
                MemberReferenceHandle handleDestructorObject = peFileReader.MemberReferences.AsEnumerable().
                                                               Select(handle => new { handle = handle, row = peFileReader.GetMemberReference(handle) }).
                                                               Single(pair => pair.row.Parent == (EntityHandle)handleObject &&
                                                                      peFileReader.GetString(pair.row.Name) == WellKnownMemberNames.DestructorName).handle;


                // Find the MethodImpl row for A.
                MethodImplementation methodImpl = typeA.GetMethodImplementations().AsEnumerable().
                                                  Select(handle => peFileReader.GetMethodImplementation(handle)).
                                                  Single();

                // The Class column should point to A.
                Assert.Equal(handleA, methodImpl.Type);

                // The MethodDeclaration column should point to System.Object.Finalize.
                Assert.Equal((EntityHandle)handleDestructorObject, methodImpl.MethodDeclaration);

                // The MethodDeclarationColumn should point to A's destructor.
                Assert.Equal((EntityHandle)handleDestructorA, methodImpl.MethodBody);
            });
        }
Пример #6
0
        /// <summary>
        /// Executes the next <see cref="IDecorator.OnInvoke(Call)"/> and eventually the called method itself.
        /// </summary>
        public async Task Next()
        {
            var currentCallIndex = _callIndex;

            try
            {
                if (_decorators != null && _callIndex < _decorators.Length)
                {
                    await _decorators[_callIndex++].OnInvoke(this).ConfigureAwait(false);
                }
                else
                {
                    _proceedInfo.Invoke();

                    if (_invocation.ReturnValue is Task task && MethodImplementation.IsAsync())
                    {
                        if (!task.IsCompleted)
                        {
                            // Async methods are executed within interception.
                            // Non-async method returned task is treated as a result
                            // and is not executed within interception.
                            await task.ConfigureAwait(false);
                        }

                        if (task.IsFaulted && task.Exception != null)
                        {
                            task.Exception.Rethrow();
                        }

                        // Runtime might return Task<T> derived type here.
                        // Discussed in dotnet/runtime#26312 and microsoft/vs-streamjsonrpc#116.
                        if (task.GetType().GetTypeInfo().TryGetGenericTaskType(out var genericTaskType))
                        {
                            if (genericTaskType.IsTaskWithVoidTaskResult())
                            {
                                return;
                            }

                            var resultProperty = genericTaskType.GetDeclaredProperty("Result");
                            if (resultProperty == null)
                            {
                                throw new InvalidOperationException(
                                          $"Object of type '{genericTaskType}' was expected to contain a property 'Result'.");
                            }

                            ReturnValue = resultProperty.GetValue(task);
                        }
                    }
                    else
                    {
                        ReturnValue = _invocation.ReturnValue;
                    }
                }
Пример #7
0
 internal void WriteMethodImpl(MethodImplementation implementation)
 {
     if (implementation.UpdateRowOnRebuild)
     {
         object[] parts = new object[]
         {
             GetMemberIndex(implementation.Class),
             GetCodedIndex(tablesHeap.MethodDefOrRef, implementation.MethodBody),
             GetCodedIndex(tablesHeap.MethodDefOrRef, implementation.MethodDeclaration),
         };
         implementation.MetaDataRow = new MetaDataRow(parts);
     }
     writer.Write(implementation.MetaDataRow.GenerateBytes());
 }
Пример #8
0
        protected override MethodImplRecord[] ComputeVirtualMethodImplsForType()
        {
            ArrayBuilder <MethodImplRecord> records = new ArrayBuilder <MethodImplRecord>();

            MetadataReader metadataReader = _module.MetadataReader;

            foreach (var methodImplHandle in _typeDefinition.GetMethodImplementations())
            {
                MethodImplementation methodImpl = metadataReader.GetMethodImplementation(methodImplHandle);

                EntityHandle methodDeclCheckHandle = methodImpl.MethodDeclaration;
                HandleKind   methodDeclHandleKind  = methodDeclCheckHandle.Kind;

                // We want to check that the type is not an interface matches before actually getting the MethodDesc.
                // For MethodSpecifications we need to dereference that handle to the underlying member reference to
                // look at the owning type.
                if (methodDeclHandleKind == HandleKind.MethodSpecification)
                {
                    methodDeclCheckHandle = metadataReader.GetMethodSpecification((MethodSpecificationHandle)methodDeclCheckHandle).Method;
                    methodDeclHandleKind  = methodDeclCheckHandle.Kind;
                }

                MetadataType owningType = null;
                switch (methodDeclHandleKind)
                {
                case HandleKind.MethodDefinition:
                    owningType = ((MethodDesc)_module.GetObject(methodDeclCheckHandle)).OwningType as MetadataType;
                    break;

                case HandleKind.MemberReference:
                    EntityHandle owningTypeHandle = metadataReader.GetMemberReference((MemberReferenceHandle)methodDeclCheckHandle).Parent;
                    owningType = _module.GetObject(owningTypeHandle) as MetadataType;
                    break;

                default:
                    Debug.Fail("unexpected methodDeclHandleKind");
                    break;
                }

                if (!owningType.IsInterface)
                {
                    MethodImplRecord newRecord = new MethodImplRecord(
                        (MethodDesc)_module.GetObject(methodImpl.MethodDeclaration),
                        (MethodDesc)_module.GetObject(methodImpl.MethodBody));
                    records.Add(newRecord);
                }
            }

            return(records.ToArray());
        }
Пример #9
0
        private void AddImplementation(MethodImplementation implementation)
        {
            var table = (MethodImplementationTable)_tableStream.GetTable(MetadataTokenType.MethodImpl);

            // Create and add row.
            var encoder           = _tableStream.GetIndexEncoder(CodedIndex.MethodDefOrRef);
            var implementationRow = new MetadataRow <uint, uint, uint>
            {
                Column1 = GetNewToken(implementation.Class).Rid,
                Column2 = encoder.EncodeToken(GetMethodToken(implementation.MethodBody)),
                Column3 = encoder.EncodeToken(GetMethodToken(implementation.MethodDeclaration))
            };

            table.Add(implementationRow);
            _members.Add(implementation, implementationRow.MetadataToken);
        }
Пример #10
0
 /// <summary>
 /// Create the non-generic version of GetEnumerator and add it to the member list of iterator closure class. 
 /// </summary>
 private void CreateGetEnumeratorMethodNonGeneric(IteratorClosureInformation iteratorClosure) {
   // GetEnumerator non-generic version, which delegates to the generic version. 
   // Metadata
   MethodDefinition nongenericGetEnumerator = new MethodDefinition() {
     Attributes = new List<ICustomAttribute>(1),
     InternFactory = this.host.InternFactory,
     Name = this.host.NameTable.GetNameFor("System.Collections.IEnumerable.GetEnumerator")
   };
   nongenericGetEnumerator.Attributes.Add(
     new CustomAttribute() { Constructor = this.DebuggerHiddenCtor }
     );
   nongenericGetEnumerator.CallingConvention |= CallingConvention.HasThis;
   nongenericGetEnumerator.ContainingTypeDefinition = iteratorClosure.ClosureDefinition;
   nongenericGetEnumerator.Visibility = TypeMemberVisibility.Public;
   nongenericGetEnumerator.Type = iteratorClosure.NonGenericIEnumeratorInterface;
   nongenericGetEnumerator.IsVirtual = true;
   nongenericGetEnumerator.IsNewSlot = true;
   nongenericGetEnumerator.IsHiddenBySignature = true;
   nongenericGetEnumerator.IsSealed = true;
   iteratorClosure.NonGenericGetEnumerator = nongenericGetEnumerator;
   // Explicitly implements IEnumerable.GetEnumerator();
   IMethodReference nongenericGetEnumeratorOriginal = Dummy.MethodReference;
   foreach (var memref in iteratorClosure.NonGenericIEnumerableInterface.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("GetEnumerator"), false)) {
     IMethodReference mref = memref as IMethodReference;
     if (mref != null) { nongenericGetEnumeratorOriginal = mref; break; }
   }
   MethodImplementation nonGenericGetEnumeratorImp = new MethodImplementation() {
     ContainingType = iteratorClosure.ClosureDefinition,
     ImplementedMethod = nongenericGetEnumeratorOriginal,
     ImplementingMethod = nongenericGetEnumerator
   };
   iteratorClosure.ClosureDefinition.ExplicitImplementationOverrides.Add(nonGenericGetEnumeratorImp);
   // Body: call this.GetEnumerator (the generic version).
   BlockStatement block1 = new BlockStatement();
   block1.Statements.Add(new ReturnStatement() {
     Expression = new MethodCall() {
       IsStaticCall = false,
       MethodToCall = iteratorClosure.GenericGetEnumeratorReference,
       ThisArgument = new ThisReference(),
       Type = iteratorClosure.NonGenericIEnumeratorInterface
     }
   });
   SourceMethodBody body1 = new SourceMethodBody(this.host, this.sourceLocationProvider);
   body1.IsNormalized = true;
   body1.LocalsAreZeroed = true;
   body1.Block = block1;
   body1.MethodDefinition = nongenericGetEnumerator;
   nongenericGetEnumerator.Body = body1;
 }
Пример #11
0
        // Virtual function related functionality
        public override MethodImplRecord[] FindMethodsImplWithMatchingDeclName(string declName)
        {
            MetadataReader metadataReader = _module.MetadataReader;
            var            stringComparer = metadataReader.StringComparer;
            ArrayBuilder <MethodImplRecord> foundRecords = new ArrayBuilder <MethodImplRecord>();

            foreach (var methodImplHandle in _typeDefinition.GetMethodImplementations())
            {
                MethodImplementation methodImpl = metadataReader.GetMethodImplementation(methodImplHandle);

                EntityHandle methodDeclCheckHandle = methodImpl.MethodDeclaration;
                HandleKind   methodDeclHandleKind  = methodDeclCheckHandle.Kind;

                // We want to check that the method name matches before actually getting the MethodDesc. For MethodSpecifications
                // we need to dereference that handle to the underlying member reference to look at name matching.
                if (methodDeclHandleKind == HandleKind.MethodSpecification)
                {
                    methodDeclCheckHandle = metadataReader.GetMethodSpecification((MethodSpecificationHandle)methodDeclCheckHandle).Method;
                    methodDeclHandleKind  = methodDeclCheckHandle.Kind;
                }

                bool foundRecord = false;

                switch (methodDeclHandleKind)
                {
                case HandleKind.MethodDefinition:
                    if (stringComparer.Equals(metadataReader.GetMethodDefinition((MethodDefinitionHandle)methodDeclCheckHandle).Name, declName))
                    {
                        foundRecord = true;
                    }
                    break;

                case HandleKind.MemberReference:
                    if (stringComparer.Equals(metadataReader.GetMemberReference((MemberReferenceHandle)methodDeclCheckHandle).Name, declName))
                    {
                        foundRecord = true;
                    }
                    break;

                default:
                    Debug.Fail("unexpected methodDeclHandleKind");
                    break;
                }

                if (foundRecord)
                {
                    MethodImplRecord newRecord = new MethodImplRecord(
                        (MethodDesc)_module.GetObject(methodImpl.MethodDeclaration),
                        (MethodDesc)_module.GetObject(methodImpl.MethodBody));

                    foundRecords.Add(newRecord);
                }
            }

            if (foundRecords.Count != 0)
            {
                return(foundRecords.ToArray());
            }

            return(null);
        }
Пример #12
0
 internal static Tuple cil_method_implementation(MethodImplementation impl, Method method, Assembly assembly) =>
 new Tuple("cil_method_implementation", impl, method, assembly);
Пример #13
0
 /// <summary>
 /// Create the generic version of the GetEnumerator for the iterator closure class. 
 /// </summary>
 /// <param name="iteratorClosure"></param>
 private void CreateGetEnumeratorMethodGeneric(IteratorClosureInformation iteratorClosure) {
   // Metadata
   MethodDefinition genericGetEnumerator = new MethodDefinition() {
     Attributes = new List<ICustomAttribute>(1),
     InternFactory = this.host.InternFactory,
     Name = this.host.NameTable.GetNameFor("System.Collections.Generic.IEnumerable<" + iteratorClosure.ElementType.ToString()+">.GetEnumerator")
   };
   CustomAttribute debuggerHiddenAttribute = new CustomAttribute() { Constructor = this.DebuggerHiddenCtor };
   genericGetEnumerator.Attributes.Add(debuggerHiddenAttribute);
   genericGetEnumerator.CallingConvention |= CallingConvention.HasThis;
   genericGetEnumerator.ContainingTypeDefinition = iteratorClosure.ClosureDefinition;
   genericGetEnumerator.Visibility = TypeMemberVisibility.Public;
   genericGetEnumerator.Type = iteratorClosure.GenericIEnumeratorInterface;
   genericGetEnumerator.IsVirtual = true;
   genericGetEnumerator.IsNewSlot = true;
   genericGetEnumerator.IsHiddenBySignature = true;
   genericGetEnumerator.IsSealed = true;
   // Membership 
   iteratorClosure.GenericGetEnumerator = genericGetEnumerator;
   IMethodReference genericGetEnumeratorOriginal = Dummy.MethodReference;
   // Explicit implementation of IEnumerable<T>.GetEnumerator
   foreach (var memref in iteratorClosure.GenericIEnumerableInterface.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("GetEnumerator"), false)) {
     IMethodReference mref = memref as IMethodReference;
     if (mref != null) { genericGetEnumeratorOriginal = mref; break; }
   }
   var genericGetEnumeratorImp = new MethodImplementation() {
     ContainingType = iteratorClosure.ClosureDefinition,
     ImplementingMethod = genericGetEnumerator,
     ImplementedMethod = genericGetEnumeratorOriginal
   };
   iteratorClosure.ClosureDefinition.ExplicitImplementationOverrides.Add(genericGetEnumeratorImp);
   // Body
   var block = GetBodyOfGenericGetEnumerator(iteratorClosure);
   var body = new SourceMethodBody(this.host, this.sourceLocationProvider);
   body.LocalsAreZeroed = true;
   body.IsNormalized = true;
   body.Block = block;
   body.MethodDefinition = genericGetEnumerator;
   genericGetEnumerator.Body = body;
 }
Пример #14
0
    /// <summary>
    /// Create two properties: object Current and T Current as the closure class implements both the 
    /// generic and non-generic version of ienumerator. 
    /// 
    /// Current Implementation generates getters, but not the property.
    /// </summary>
    /// <param name="iteratorClosure">Information about the closure created when compiling the current iterator method</param>
    private void CreateIteratorClosureProperties(IteratorClosureInformation iteratorClosure) {
      // Non-generic version of the get_Current, which returns the generic version of get_Current. 
      MethodDefinition getterNonGenericCurrent = new MethodDefinition() {
        Attributes = new List<ICustomAttribute>(1),
        InternFactory = this.host.InternFactory,
        Name = this.host.NameTable.GetNameFor("System.Collections.IEnumerator.get_Current")
      };
      CustomAttribute debuggerHiddenAttribute = new CustomAttribute();
      debuggerHiddenAttribute.Constructor = this.DebuggerHiddenCtor;
      getterNonGenericCurrent.Attributes.Add(debuggerHiddenAttribute);
      getterNonGenericCurrent.CallingConvention |= CallingConvention.HasThis;
      getterNonGenericCurrent.Visibility |= TypeMemberVisibility.Public;
      getterNonGenericCurrent.ContainingTypeDefinition = iteratorClosure.ClosureDefinition;
      getterNonGenericCurrent.Type = this.host.PlatformType.SystemObject;
      getterNonGenericCurrent.IsSpecialName = true;
      getterNonGenericCurrent.IsVirtual = true;
      getterNonGenericCurrent.IsNewSlot = true;
      getterNonGenericCurrent.IsHiddenBySignature = true;
      getterNonGenericCurrent.IsSealed = true;
      iteratorClosure.NonGenericGetCurrent = getterNonGenericCurrent;
      IMethodReference originalMethod = Dummy.MethodReference;
      foreach (ITypeMemberReference tref in iteratorClosure.NonGenericIEnumeratorInterface.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("get_Current"), false)) {
        originalMethod = tref as IMethodReference; if (originalMethod != null) break;
      }
      // assert originalMethod != Dummy
      MethodImplementation getterImplementation = new MethodImplementation() {
        ContainingType = iteratorClosure.ClosureDefinition,
        ImplementingMethod = getterNonGenericCurrent,
        ImplementedMethod = originalMethod
      };
      iteratorClosure.ClosureDefinition.ExplicitImplementationOverrides.Add(getterImplementation);

      List<IStatement> statements = new List<IStatement>();
      IFieldReference currentField = iteratorClosure.CurrentFieldReference;
      BoundExpression thisDotCurr = new BoundExpression() {
        Definition = currentField,
        Instance = new ThisReference(),
        Locations = iteratorClosure.ClosureDefinition.Locations,
        Type = currentField.Type
      };
      IExpression returnExpression;
      if (!iteratorClosure.ElementType.IsValueType && TypeHelper.TypesAreAssignmentCompatible(iteratorClosure.ElementType.ResolvedType, this.host.PlatformType.SystemObject.ResolvedType)) {
        returnExpression = thisDotCurr;
      } else {
        Conversion convertion = new Conversion() {
          CheckNumericRange = false,
          Type = this.host.PlatformType.SystemObject,
          TypeAfterConversion = getterNonGenericCurrent.Type,
          ValueToConvert = thisDotCurr
        };
        returnExpression = convertion;
      }
      ReturnStatement returnCurrent = new ReturnStatement() {
        Expression = returnExpression,
        Locations = iteratorClosure.ClosureDefinition.Locations
      };
      statements.Add(returnCurrent);
      BlockStatement block = new BlockStatement() { Statements = statements };
      SourceMethodBody body = new SourceMethodBody(this.host, this.sourceLocationProvider);
      body.IsNormalized = true;
      body.LocalsAreZeroed = true;
      body.Block = block;
      body.MethodDefinition = getterNonGenericCurrent;
      getterNonGenericCurrent.Body = body;

      // Create generic version of get_Current, the body of which is simply returning this.current.
      MethodDefinition getterGenericCurrent = new MethodDefinition() {
        Attributes = new List<ICustomAttribute>(1),
        InternFactory = this.host.InternFactory,
        Name = this.host.NameTable.GetNameFor("System.Collections.Generic.IEnumerator<" + iteratorClosure.ElementType.ToString() +">.get_Current")
      };
      getterGenericCurrent.Attributes.Add(debuggerHiddenAttribute);

      getterGenericCurrent.CallingConvention |= CallingConvention.HasThis;
      getterGenericCurrent.Visibility |= TypeMemberVisibility.Public;
      getterGenericCurrent.ContainingTypeDefinition = iteratorClosure.ClosureDefinition;
      getterGenericCurrent.Type = iteratorClosure.ElementType;
      getterGenericCurrent.IsSpecialName = true;
      getterGenericCurrent.IsVirtual = true;
      getterGenericCurrent.IsNewSlot = true;
      getterGenericCurrent.IsHiddenBySignature = true;
      getterGenericCurrent.IsSealed = true;
      iteratorClosure.GenericGetCurrent = getterGenericCurrent;
      originalMethod = Dummy.MethodReference;
      foreach (ITypeMemberReference tref in iteratorClosure.GenericIEnumeratorInterface.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("get_Current"), false)) {
        originalMethod = tref as IMethodReference; if (originalMethod != null) break;
      }
      MethodImplementation getterImplementation2 = new MethodImplementation() {
        ContainingType = iteratorClosure.ClosureDefinition,
        ImplementingMethod = getterGenericCurrent,
        ImplementedMethod = originalMethod
      };
      iteratorClosure.ClosureDefinition.ExplicitImplementationOverrides.Add(getterImplementation2);

      statements = new List<IStatement>();
      currentField = iteratorClosure.CurrentFieldReference;
      BoundExpression thisDotCurrent = new BoundExpression() {
        Definition = currentField, Instance = new ThisReference(), Locations = iteratorClosure.ClosureDefinition.Locations, Type = currentField.Type
      };
      returnCurrent = new ReturnStatement() {
        Expression = thisDotCurrent,
        Locations = iteratorClosure.ClosureDefinition.Locations
      };
      statements.Add(returnCurrent);
      block = new BlockStatement() { Statements = statements };
      body = new SourceMethodBody(this.host, this.sourceLocationProvider);
      body.LocalsAreZeroed = true;
      body.Block = block;
      body.MethodDefinition = getterGenericCurrent;
      getterGenericCurrent.Body = body;
    }
Пример #15
0
        public ServerHandler(string url, string SessionID, IRegistryCore registry) :
            base("POST", url)
        {
            m_SessionID = SessionID;
            m_registry = registry;
            if (m_methods == null)
            {
                m_methods = new Dictionary<string, List<MethodImplementation>>();
                List<string> alreadyRunPlugins = new List<string>();
                foreach (ConnectorBase plugin in ConnectorRegistry.Connectors)
                {
                    if (alreadyRunPlugins.Contains(plugin.PluginName))
                        continue;
                    alreadyRunPlugins.Add(plugin.PluginName);
                    foreach (MethodInfo method in plugin.GetType().GetMethods())
                    {
                        CanBeReflected reflection = (CanBeReflected)Attribute.GetCustomAttribute(method, typeof(CanBeReflected));
                        if (reflection != null)
                        {
                            string methodName = reflection.RenamedMethod == "" ? method.Name : reflection.RenamedMethod;
                            List<MethodImplementation> methods = new List<MethodImplementation>();
                            MethodImplementation imp = new MethodImplementation() { Method = method, Reference = plugin, Attribute = reflection };
                            if (!m_methods.TryGetValue(methodName, out methods))
                                m_methods.Add(methodName, (methods = new List<MethodImplementation>()));

                            methods.Add(imp);
                        }
                    }
                }
            }
        }
Пример #16
0
        public ServerHandler(string url, string SessionID, IRegistryCore registry) :
            base("POST", url)
        {
            m_SessionID = SessionID;
            m_registry = registry;
            m_methods = new Dictionary<string, List<MethodImplementation>>();
            List<string> alreadyRunPlugins = new List<string>();
            foreach(IAuroraDataPlugin plugin in Aurora.DataManager.DataManager.GetPlugins())
            {
                if (alreadyRunPlugins.Contains(plugin.Name))
                    continue;
                alreadyRunPlugins.Add(plugin.Name);
                foreach (MethodInfo method in plugin.GetType().GetMethods())
                {
                    if (Attribute.GetCustomAttribute(method, typeof(CanBeReflected)) != null)
                    {
                        List<MethodImplementation> methods = new List<MethodImplementation>();
                        MethodImplementation imp = new MethodImplementation() { Method = method, Reference = plugin };
                        if (!m_methods.TryGetValue(method.Name, out methods))
                            m_methods.Add(method.Name, (methods = new List<MethodImplementation>()));

                        methods.Add(imp);
                    }
                }
            }
        }
Пример #17
0
 private bool GetMethodInfo(string method, int parameters, out MethodImplementation methodInfo)
 {
     List<MethodImplementation> methods = new List<MethodImplementation>();
     if (m_methods.TryGetValue(method, out methods))
     {
         if (methods.Count == 1)
         {
             methodInfo = methods[0];
             return true;
         }
         foreach (MethodImplementation m in methods)
         {
             if (m.Method.GetParameters().Length == parameters)
             {
                 methodInfo = m;
                 return true;
             }
         }
     }
     methodInfo = null;
     return false;
 }
Пример #18
0
 private void UpdateMethodImpl(Workspace workspace, MethodImplementation methodImpl)
 {
     methodImpl.MetaDataRow.Parts[0] = GetMemberIndex(workspace, methodImpl.Class);
     methodImpl.MetaDataRow.Parts[1] = GetMemberIndex(workspace, Constructor.OriginalAssembly.NETHeader.TablesHeap.MethodDefOrRef, methodImpl.MethodBody);
     methodImpl.MetaDataRow.Parts[1] = GetMemberIndex(workspace, Constructor.OriginalAssembly.NETHeader.TablesHeap.MethodDefOrRef, methodImpl.MethodDeclaration);
 }
Пример #19
0
    /// <summary>
    /// Create the MoveNext method. This method sets up metadata and calls TranslateIteratorMethodBodyToMoveNextBody
    /// to compile the body. 
    /// </summary>
    private void CreateMoveNextMethod(IteratorClosureInformation /*!*/ iteratorClosure, BlockStatement blockStatement) {
      // Method definition and metadata.
      MethodDefinition moveNext = new MethodDefinition() {
        InternFactory = this.host.InternFactory,
        Name = this.host.NameTable.GetNameFor("MoveNext")
      };
      moveNext.ContainingTypeDefinition = iteratorClosure.ClosureDefinition;
      moveNext.Visibility = TypeMemberVisibility.Private;
      moveNext.CallingConvention |= CallingConvention.HasThis;
      moveNext.Type = this.host.PlatformType.SystemBoolean;
      moveNext.InternFactory = this.host.InternFactory;
      moveNext.IsSealed = true;
      moveNext.IsVirtual = true;
      moveNext.IsHiddenBySignature = true;
      moveNext.IsNewSlot = true;
      iteratorClosure.MoveNext = moveNext;
      IMethodReference moveNextOriginal = Dummy.MethodReference;
      foreach (ITypeMemberReference tmref in iteratorClosure.NonGenericIEnumeratorInterface.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("MoveNext"), false)) {
        moveNextOriginal = tmref as IMethodReference;
        if (moveNextOriginal != null) break;
      }
      // Explicit method implementation
      MethodImplementation moveNextImp = new MethodImplementation() {
        ContainingType = iteratorClosure.ClosureDefinition,
        ImplementingMethod = moveNext,
        ImplementedMethod = moveNextOriginal
      };
      iteratorClosure.ClosureDefinition.ExplicitImplementationOverrides.Add(moveNextImp);

      SourceMethodBody body = new SourceMethodBody(this.host, this.sourceLocationProvider, null, this.iteratorLocalCount);
      IBlockStatement block = TranslateIteratorMethodBodyToMoveNextBody(iteratorClosure, blockStatement);
      moveNext.Body = body;
      body.IsNormalized = true;
      body.LocalsAreZeroed = true;
      body.Block = block;
      body.MethodDefinition = moveNext;
    }
Пример #20
0
 /// <summary>
 /// Create the Reset method. Like in CSC, this method contains nothing. 
 /// </summary>
 private void CreateResetMethod(IteratorClosureInformation iteratorClosure) {
   // System.Collections.IEnumerator.Reset: Simply throws an exception
   MethodDefinition reset = new MethodDefinition() {
     Attributes = new List<ICustomAttribute>(1),
     InternFactory = this.host.InternFactory,
     Name = this.host.NameTable.GetNameFor("Reset")
   };
   CustomAttribute debuggerHiddenAttribute = new CustomAttribute() { Constructor = this.DebuggerHiddenCtor };
   reset.Attributes.Add(debuggerHiddenAttribute);
   reset.CallingConvention |= CallingConvention.HasThis;
   reset.Visibility = TypeMemberVisibility.Private;
   reset.ContainingTypeDefinition = iteratorClosure.ClosureDefinition;
   reset.Type = this.host.PlatformType.SystemVoid;
   reset.IsVirtual = true;
   reset.IsNewSlot = true;
   reset.IsHiddenBySignature = true;
   reset.IsSealed = true;
   iteratorClosure.Reset = reset;
   // explicitly state that this reset method implements IEnumerator's reset method. 
   IMethodReference resetImplemented = Dummy.MethodReference;
   foreach (var memref in iteratorClosure.NonGenericIEnumeratorInterface.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("Reset"), false)) {
     IMethodReference mref = memref as IMethodReference;
     if (mref != null) {
       resetImplemented = mref;
       break;
     }
   }
   MethodImplementation resetImp = new MethodImplementation() {
     ContainingType = iteratorClosure.ClosureDefinition,
     ImplementedMethod = resetImplemented,
     ImplementingMethod = reset
   };
   iteratorClosure.ClosureDefinition.ExplicitImplementationOverrides.Add(resetImp);
   List<IStatement> statements = new List<IStatement>();
   ReturnStatement returnCurrent = new ReturnStatement() {
     Expression = null,
     Locations = iteratorClosure.ClosureDefinition.Locations
   };
   statements.Add(returnCurrent);
   BlockStatement block = new BlockStatement() { Statements = statements };
   SourceMethodBody body = new SourceMethodBody(this.host, this.sourceLocationProvider);
   body.LocalsAreZeroed = true;
   body.IsNormalized = true;
   body.Block = block;
   body.MethodDefinition = reset;
   reset.Body = body;
 }
Пример #21
0
 public static string ToString(this MetadataReader reader, MethodImplementation x) => $"{{MethodImpl[{RowId(x):X}]: {reader.ToString( x.MethodBody)} {reader.ToString( x.MethodDeclaration)}}}";
Пример #22
0
 internal static Tuple cil_handler(ExceptionRegion region, MethodImplementation method, int index, int kind,
                                   Instruction region_start,
                                   Instruction region_end,
                                   Instruction handler_start) =>
 new Tuple("cil_handler", region, method, index, kind, region_start, region_end, handler_start);
Пример #23
0
        private void LoadFormValues()
        {
            ConfigurationManager config = ConfigurationManager.GetConfigurationManager("WSCF05");
            string wsdlUrls             = config.Read("WsdlUrls");

            //if (wsdlUrls.Length > 0)
            //{
            cbWsdlLocation.Items.Clear();
            wsdlUrls = wsdlUrls.Trim(';');
            string[] urls = wsdlUrls.Split(';');

            // BDS: Changed this code to use new wsdl file cache.
            for (int urlIndex = 0; urlIndex < urls.Length; urlIndex++)
            {
                string fname = AddWsdlFileToCache(urls[urlIndex]);
            }

            if (cbWsdlLocation.Items.Count > 0)
            {
                cbWsdlLocation.SelectedIndex = 0;
            }

            if (wsdlLocation.Length > 0)
            {
                if (!wsdlFileCache.Contains(wsdlLocation))
                {
                    string fname = AddWsdlFileToCache(wsdlLocation);
                }
                else
                {
                    int wsdlIndex = wsdlFileCache.IndexOf(wsdlLocation);
                    cbWsdlLocation.SelectedIndex = wsdlIndex;
                }
            }
            //}

            if (config.ReadBoolean("RememberSettings"))
            {
                //In an MVP kind of approach, the config settings would be read into
                // an options class and that would be passed on to the view.
                cbSettings.Checked = config.ReadBoolean("RememberSettings");
                rbClient.Checked   = config.ReadBoolean("ClientCode");
                rbServer.Checked   = config.ReadBoolean("ServerCode");

                cbProperties.Checked                = config.ReadBoolean("Properties");
                cbFormatSoapActions.Checked         = config.ReadBoolean("Serializable");
                cbCollections.Checked               = config.ReadBoolean("Collections");
                cbGenericList.Checked               = config.ReadBoolean("GenericList");
                cbDataBinding.Checked               = config.ReadBoolean("DataBinding");
                cbOrderIds.Checked                  = config.ReadBoolean("OrderIdentifiers");
                cbAsync.Checked                     = config.ReadBoolean("AsyncMethods");
                cbMultipleFiles.Checked             = config.ReadBoolean("MultipleFiles");
                cbAdjustCasing.Checked              = config.ReadBoolean("AdjustCasing");
                cbConcurrencyMode.SelectedItem      = config.Read("ConcurrencyMode", "Single");
                cbInstanceContextMode.SelectedItem  = config.Read("InstanceContextMode", "PerCall");
                cbUseSynchronizationContext.Checked = config.ReadBoolean("UseSynchronizationContext");
                cbEnableWsdlEndpoint.Checked        = config.ReadBoolean("EnableWsdlEndpoint");
                cbGenerateSvcFile.Checked           = config.ReadBoolean("GenerateSvcFile");
                string methodImplementationValue          = config.Read("MethodImplementation", MethodImplementation.NotImplementedException.ToString());
                MethodImplementation methodImplementation = (MethodImplementation)Enum.Parse(typeof(MethodImplementation), methodImplementationValue);
                if (methodImplementation == MethodImplementation.NotImplementedException)
                {
                    rbNotImplementedException.Checked = true;
                }
                if (methodImplementation == MethodImplementation.PartialClassMethodCalls)
                {
                    rbPartialClassMethodCalls.Checked = true;
                }
                if (methodImplementation == MethodImplementation.AbstractMethods)
                {
                    rbAbstractMethods.Checked = true;
                }

                tbDestinationFilename.Text  = config.Read("DestinationFilename");
                tbDestinationNamespace.Text = config.Read("DestinationNamespace");

                cbOverwrite.Checked = config.ReadBoolean("Overwrite");
            }
        }
Пример #24
0
 internal static Tuple cil_instruction(Instruction instruction, int opcode, int index, MethodImplementation parent) =>
 new Tuple("cil_instruction", instruction, opcode, index, parent);
Пример #25
0
 private bool GetMethodInfo(string method, int parameters, out MethodImplementation methodInfo)
 {
     List<MethodImplementation> methods = new List<MethodImplementation>();
     if (m_methods.TryGetValue(method, out methods))
     {
         if (methods.Count == 1)
         {
             methodInfo = methods[0];
             return true;
         }
         foreach (MethodImplementation m in methods)
         {
             if (m.Method.GetParameters().Length == parameters)
             {
                 methodInfo = m;
                 return true;
             }
         }
     }
     MainConsole.Instance.Warn("COULD NOT FIND METHOD: " + method);
     methodInfo = null;
     return false;
 }
Пример #26
0
 internal static Tuple cil_local_variable(LocalVariable l, MethodImplementation m, int i, Type t) =>
 new Tuple("cil_local_variable", l, m, i, t);
Пример #27
0
 internal static Tuple cil_method_stack_size(MethodImplementation method, int stackSize) =>
 new Tuple("cil_method_stack_size", method, stackSize);
Пример #28
0
 /// <summary>
 /// DisposeMethod method. Currently the method body does nothing. 
 /// </summary>
 private void CreateDisposeMethod(IteratorClosureInformation iteratorClosure) {
   MethodDefinition disposeMethod = new MethodDefinition() {
     Attributes = new List<ICustomAttribute>(1),
     InternFactory = this.host.InternFactory,
     Name = this.host.NameTable.GetNameFor("Dispose")
   };
   disposeMethod.Attributes.Add(new CustomAttribute() { Constructor = this.debuggerHiddenCtor });
   disposeMethod.CallingConvention |= CallingConvention.HasThis;
   disposeMethod.Visibility = TypeMemberVisibility.Public;
   disposeMethod.ContainingTypeDefinition = iteratorClosure.ClosureDefinition;
   disposeMethod.Type = this.host.PlatformType.SystemVoid;
   disposeMethod.IsVirtual = true;
   disposeMethod.IsNewSlot = true;
   disposeMethod.IsHiddenBySignature = true;
   disposeMethod.IsSealed = true;
   // Add disposeMethod to parent's member list. 
   iteratorClosure.DisposeMethod = disposeMethod;
   // Explicitly implements IDisposable's dispose. 
   IMethodReference disposeImplemented = Dummy.MethodReference;
   foreach (var memref in iteratorClosure.DisposableInterface.ResolvedType.GetMembersNamed(this.host.NameTable.GetNameFor("Dispose"), false)) {
     IMethodReference mref = memref as IMethodReference;
     if (mref != null) {
       disposeImplemented = mref;
       break;
     }
   }
   MethodImplementation disposeImp = new MethodImplementation() {
     ContainingType = iteratorClosure.ClosureDefinition,
     ImplementedMethod = disposeImplemented,
     ImplementingMethod = disposeMethod
   };
   iteratorClosure.ClosureDefinition.ExplicitImplementationOverrides.Add(disposeImp);
   // Body is a sole return. 
   BlockStatement block = new BlockStatement();
   block.Statements.Add(new ReturnStatement() {
     Expression = null,
     Locations = iteratorClosure.ClosureDefinition.Locations
   });
   SourceMethodBody body = new SourceMethodBody(this.host, this.sourceLocationProvider);
   body.LocalsAreZeroed = true;
   body.IsNormalized = true;
   body.Block = block;
   body.MethodDefinition = disposeMethod;
   disposeMethod.Body = body;
 }