Example #1
0
 public void ReadMarshalInformation(NuGenIMetaDataImport2 import, Dictionary <uint, NuGenTokenBase> allTokens, int parameterCount)
 {
     if ((AttributeFlags & CorParamAttr.pdHasFieldMarshal) == CorParamAttr.pdHasFieldMarshal)
     {
         MarshalAsTypeString = string.Format("marshal({0})", NuGenHelperFunctions.ReadMarshalDescriptor(import, allTokens, Token, parameterCount));
     }
 }
Example #2
0
        private void EnumConstraints(NuGenIMetaDataImport2 import)
        {
            IntPtr enumHandle = IntPtr.Zero;

            uint[] tokens = new uint[NuGenProject.DefaultArrayCount];
            uint   count  = 0;

            import.EnumGenericParamConstraints(ref enumHandle, Token, tokens, Convert.ToUInt32(tokens.Length), out count);

            if (count > 0)
            {
                Constraints = new List <uint>();
            }

            while (count > 0)
            {
                for (uint tokensIndex = 0; tokensIndex < count; tokensIndex++)
                {
                    uint token = tokens[tokensIndex];
                    uint tokenOfParent;
                    uint constraintType;

                    import.GetGenericParamConstraintProps(token, out tokenOfParent, out constraintType);

                    Constraints.Add(constraintType);
                }

                import.EnumGenericParamConstraints(ref enumHandle, Token, tokens, Convert.ToUInt32(tokens.Length), out count);
            }

            import.CloseEnum(enumHandle);
        }
Example #3
0
 public NuGenCustomAttribute(NuGenIMetaDataImport2 import, uint token, NuGenTokenBase owner, uint type, IntPtr blob, uint blobLength)
 {
     Token      = token;
     Owner      = owner;
     Type       = type;
     Blob       = blob;
     BlobLength = blobLength;
 }
		public NuGenCustomAttribute(NuGenIMetaDataImport2 import, uint token, NuGenTokenBase owner, uint type, IntPtr blob, uint blobLength)
		{
			Token = token;
			Owner = owner;
			Type = type;
			Blob = blob;
			BlobLength = blobLength;
		}
		public NuGenTypeReference(NuGenIMetaDataImport2 import, NuGenAssembly assembly, string name, uint token, uint resolutionScope)
		{
			Assembly = assembly;
			Name = name;
			Token = token;
			ResolutionScope = resolutionScope;
			NuGenHelperFunctions.GetMemberReferences(Assembly, Token);
		}
 public NuGenTypeReference(NuGenIMetaDataImport2 import, NuGenAssembly assembly, string name, uint token, uint resolutionScope)
 {
     Assembly        = assembly;
     Name            = name;
     Token           = token;
     ResolutionScope = resolutionScope;
     NuGenHelperFunctions.GetMemberReferences(Assembly, Token);
 }
Example #7
0
        public NuGenGenericParameter(NuGenIMetaDataImport2 import, uint token, string name, uint sequence, uint attributes, NuGenTokenBase owner, uint kind)
        {
            Token      = token;
            Name       = name;
            Sequence   = sequence;
            Attributes = (CorGenericParamAttr)attributes;
            Owner      = owner;
            Kind       = kind;

            EnumConstraints(import);
        }
Example #8
0
 public NuGenParameter(NuGenIMetaDataImport2 import, Dictionary <uint, NuGenTokenBase> allTokens, uint token, NuGenMethodDefinition method, uint ordinalIndex, string name, uint attributeFlags, uint elementType, IntPtr defaultValue, uint defaultValueLength)
 {
     Token              = token;
     Method             = method;
     OrdinalIndex       = ordinalIndex;
     Name               = name;
     AttributeFlags     = (CorParamAttr)attributeFlags;
     ElementType        = (CorElementType)elementType;
     DefaultValue       = defaultValue;
     DefaultValueLength = defaultValueLength;
     ReadDefaultValue();
 }
 public NuGenFieldDefinition(NuGenIMetaDataImport2 import, NuGenTypeDefinition typeDefinition, string name, uint token, IntPtr signatureBlob, uint signatureBlobLength, uint flags, uint defaultValueType, IntPtr defaultValue, uint defaultValueLength)
 {
     BaseTypeDefinition = typeDefinition;
     Name                = name;
     Token               = token;
     SignatureBlob       = signatureBlob;
     SignatureBlobLength = signatureBlobLength;
     Flags               = (CorFieldAttr)flags;
     DefaultValueType    = (CorElementType)defaultValueType;
     DefaultValue        = defaultValue;
     DefaultValueLength  = defaultValueLength;
 }
Example #10
0
        public void EnumerateTypeDefinitions(NuGenIMetaDataImport2 import, ModuleWrapper debuggedModule)
        {
            DebuggedModule = debuggedModule;
            IntPtr enumHandle = IntPtr.Zero;

            uint[] typeDefs = new uint[NuGenProject.DefaultArrayCount];
            uint   count    = 0;

            import.EnumTypeDefs(ref enumHandle, typeDefs, Convert.ToUInt32(typeDefs.Length), out count);

            while (count > 0)
            {
                for (uint typeDefsIndex = 0; typeDefsIndex < count; typeDefsIndex++)
                {
                    uint token = typeDefs[typeDefsIndex];
                    uint typeNameLength;
                    uint typeDefFlags;
                    uint baseTypeToken;

                    import.GetTypeDefProps(token, NuGenProject.DefaultCharArray,
                                           Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out typeNameLength, out typeDefFlags, out baseTypeToken);

                    if (typeNameLength > NuGenProject.DefaultCharArray.Length)
                    {
                        NuGenProject.DefaultCharArray = new char[typeNameLength];

                        import.GetTypeDefProps(token, NuGenProject.DefaultCharArray,
                                               Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out typeNameLength, out typeDefFlags, out baseTypeToken);
                    }

                    NuGenTypeDefinition typeDefinition = new NuGenTypeDefinition(import, this, NuGenHelperFunctions.GetString(NuGenProject.DefaultCharArray, 0, typeNameLength), token, (CorTypeAttr)typeDefFlags, baseTypeToken);
                    TypeDefinitions[token]    = typeDefinition;
                    Assembly.AllTokens[token] = typeDefinition;
                }

                import.EnumTypeDefs(ref enumHandle, typeDefs, Convert.ToUInt32(typeDefs.Length), out count);
            }

            import.CloseEnum(enumHandle);

            foreach (NuGenTypeDefinition typeDefinition in TypeDefinitions.Values)
            {
                if (typeDefinition.IsNestedType)
                {
                    typeDefinition.FindEnclosingType(import);
                }
            }

            DebuggedModule = null;
        }
Example #11
0
        public NuGenModuleScope(NuGenIMetaDataImport2 import, NuGenAssembly assembly)
        {
            Assembly = assembly;
            uint moduleNameLength;

            import.GetScopeProps(NuGenProject.DefaultCharArray, Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out moduleNameLength, ref mvid);

            if (moduleNameLength > NuGenProject.DefaultCharArray.Length)
            {
                NuGenProject.DefaultCharArray = new char[moduleNameLength];

                import.GetScopeProps(NuGenProject.DefaultCharArray, Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out moduleNameLength, ref mvid);
            }

            Name = NuGenHelperFunctions.GetString(NuGenProject.DefaultCharArray, 0, moduleNameLength);

            uint token;

            import.GetModuleFromScope(out token);
            Token = token;
            Assembly.AllTokens[Token] = this;
        }
Example #12
0
        public NuGenProperty(NuGenIMetaDataImport2 import, uint token, NuGenTypeDefinition baseTypeDefinition, string name, uint flags, IntPtr signature, uint signatureLength, uint elementType, IntPtr defaultValue, uint defaultValueLength, uint setterMethodToken, uint getterMethodToken, uint[] otherMethods, uint otherMethodsCount)
        {
            Token = token;
            BaseTypeDefinition = baseTypeDefinition;
            Name               = name;
            Flags              = (CorPropertyAttr)flags;
            Signature          = signature;
            SignatureLength    = signatureLength;
            ElementType        = (CorElementType)elementType;
            DefaultValue       = defaultValue;
            DefaultValueLength = defaultValueLength;

            if (DefaultValueLength > 0)
            {
                throw new NotImplementedException("Default value is given for the property.");
            }

            SetterMethodToken = setterMethodToken;
            GetterMethodToken = getterMethodToken;
            OtherMethods      = otherMethods;
            OtherMethodsCount = otherMethodsCount;
        }
		private void EnumParameters(NuGenIMetaDataImport2 import)
		{
			NuGenAssembly assembly = BaseTypeDefinition.ModuleScope.Assembly;
			IntPtr enumHandle = IntPtr.Zero;
			uint[] parameterTokens = new uint[NuGenProject.DefaultArrayCount];
			uint count = 0;
			import.EnumParams(ref enumHandle, Token, parameterTokens, Convert.ToUInt32(parameterTokens.Length), out count);

			if (count > 0)
			{
				Parameters = new List<NuGenParameter>();
			}

			while (count > 0)
			{
				for (uint parameterTokensIndex = 0; parameterTokensIndex < count; parameterTokensIndex++)
				{
					uint methodToken;
					uint parameterToken = parameterTokens[parameterTokensIndex];
					uint ordinalIndex;
					uint nameLength;
					uint attributeFlags;
					uint elementType;
					IntPtr defaultValue;
					uint defaultValueLength;

					import.GetParamProps(parameterToken, out methodToken, out ordinalIndex, NuGenProject.DefaultCharArray, Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out nameLength, out attributeFlags, out elementType, out defaultValue, out defaultValueLength);

					if (nameLength > NuGenProject.DefaultCharArray.Length)
					{
						NuGenProject.DefaultCharArray = new char[nameLength];

						import.GetParamProps(parameterToken, out methodToken, out ordinalIndex, NuGenProject.DefaultCharArray, Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out nameLength, out attributeFlags, out elementType, out defaultValue, out defaultValueLength);
					}

					NuGenParameter parameter = new NuGenParameter(import, assembly.AllTokens, parameterToken, this, ordinalIndex, NuGenHelperFunctions.GetString(NuGenProject.DefaultCharArray, 0, nameLength), attributeFlags, elementType, defaultValue, defaultValueLength);
					Parameters.Add(parameter);
					assembly.AllTokens[Token] = parameter;
				}

				import.EnumParams(ref enumHandle, Token, parameterTokens, Convert.ToUInt32(parameterTokens.Length), out count);
			}

			import.CloseEnum(enumHandle);

			if (Parameters != null)
			{
				Parameters.Sort();

				foreach (NuGenParameter parameter in Parameters)
				{
					parameter.ReadMarshalInformation(import, assembly.AllTokens, Parameters.Count);
				}
			}
		}
Example #14
0
 public NuGenInterfaceImplementation(NuGenIMetaDataImport2 import, uint token, NuGenTypeDefinition typeDefinition, uint interfaceToken)
 {
     Token          = token;
     TypeDefinition = typeDefinition;
     InterfaceToken = interfaceToken;
 }
		public NuGenFieldDefinition(NuGenIMetaDataImport2 import, NuGenTypeDefinition typeDefinition, string name, uint token, IntPtr signatureBlob, uint signatureBlobLength, uint flags, uint defaultValueType, IntPtr defaultValue, uint defaultValueLength)
		{
			BaseTypeDefinition = typeDefinition;
			Name = name;
			Token = token;
			SignatureBlob = signatureBlob;
			SignatureBlobLength = signatureBlobLength;
			Flags = (CorFieldAttr)flags;
			DefaultValueType = (CorElementType)defaultValueType;
			DefaultValue = defaultValue;
			DefaultValueLength = defaultValueLength;
		}
		public NuGenInterfaceImplementation(NuGenIMetaDataImport2 import, uint token, NuGenTypeDefinition typeDefinition, uint interfaceToken)
		{
			Token = token;
			TypeDefinition = typeDefinition;
			InterfaceToken = interfaceToken;
		}
Example #17
0
		public void ReadMarshalInformation(NuGenIMetaDataImport2 import, Dictionary<uint, NuGenTokenBase> allTokens, int parameterCount)
		{
			if ((AttributeFlags & CorParamAttr.pdHasFieldMarshal) == CorParamAttr.pdHasFieldMarshal)
			{
				MarshalAsTypeString = string.Format("marshal({0})", NuGenHelperFunctions.ReadMarshalDescriptor(import, allTokens, Token, parameterCount));
			}
		}
Example #18
0
		public NuGenParameter(NuGenIMetaDataImport2 import, Dictionary<uint, NuGenTokenBase> allTokens, uint token, NuGenMethodDefinition method, uint ordinalIndex, string name, uint attributeFlags, uint elementType, IntPtr defaultValue, uint defaultValueLength)
		{
			Token = token;
			Method = method;
			OrdinalIndex = ordinalIndex;
			Name = name;
			AttributeFlags = (CorParamAttr)attributeFlags;
			ElementType = (CorElementType)elementType;
			DefaultValue = defaultValue;
			DefaultValueLength = defaultValueLength;
			ReadDefaultValue();
		}
		private void EnumConstraints(NuGenIMetaDataImport2 import)
		{
			IntPtr enumHandle = IntPtr.Zero;
			uint[] tokens = new uint[NuGenProject.DefaultArrayCount];
			uint count = 0;
			import.EnumGenericParamConstraints(ref enumHandle, Token, tokens, Convert.ToUInt32(tokens.Length), out count);

			if (count > 0)
			{
				Constraints = new List<uint>();
			}

			while (count > 0)
			{
				for (uint tokensIndex = 0; tokensIndex < count; tokensIndex++)
				{
					uint token = tokens[tokensIndex];
					uint tokenOfParent;
					uint constraintType;

					import.GetGenericParamConstraintProps(token, out tokenOfParent, out constraintType);

					Constraints.Add(constraintType);
				}

				import.EnumGenericParamConstraints(ref enumHandle, Token, tokens, Convert.ToUInt32(tokens.Length), out count);
			}

			import.CloseEnum(enumHandle);
		}
Example #20
0
		public NuGenProperty(NuGenIMetaDataImport2 import, uint token, NuGenTypeDefinition baseTypeDefinition, string name, uint flags, IntPtr signature, uint signatureLength, uint elementType, IntPtr defaultValue, uint defaultValueLength, uint setterMethodToken, uint getterMethodToken, uint[] otherMethods, uint otherMethodsCount)
		{
			Token = token;
			BaseTypeDefinition = baseTypeDefinition;
			Name = name;
			Flags = (CorPropertyAttr)flags;
			Signature = signature;
			SignatureLength = signatureLength;
			ElementType = (CorElementType)elementType;
			DefaultValue = defaultValue;
			DefaultValueLength = defaultValueLength;

			if (DefaultValueLength > 0)
			{
				throw new NotImplementedException("Default value is given for the property.");
			}

			SetterMethodToken = setterMethodToken;
			GetterMethodToken = getterMethodToken;
			OtherMethods = otherMethods;
			OtherMethodsCount = otherMethodsCount;
		}
		public void EnumerateTypeDefinitions(NuGenIMetaDataImport2 import, ModuleWrapper debuggedModule)
		{
			DebuggedModule = debuggedModule;
			IntPtr enumHandle = IntPtr.Zero;
			uint[] typeDefs = new uint[NuGenProject.DefaultArrayCount];
			uint count = 0;
			import.EnumTypeDefs(ref enumHandle, typeDefs, Convert.ToUInt32(typeDefs.Length), out count);

			while (count > 0)
			{
				for (uint typeDefsIndex = 0; typeDefsIndex < count; typeDefsIndex++)
				{
					uint token = typeDefs[typeDefsIndex];
					uint typeNameLength;
					uint typeDefFlags;
					uint baseTypeToken;

					import.GetTypeDefProps(token, NuGenProject.DefaultCharArray,
Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out typeNameLength, out typeDefFlags, out baseTypeToken);

					if (typeNameLength > NuGenProject.DefaultCharArray.Length)
					{
						NuGenProject.DefaultCharArray = new char[typeNameLength];

						import.GetTypeDefProps(token, NuGenProject.DefaultCharArray,
Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out typeNameLength, out typeDefFlags, out baseTypeToken);
					}

					NuGenTypeDefinition typeDefinition = new NuGenTypeDefinition(import, this, NuGenHelperFunctions.GetString(NuGenProject.DefaultCharArray, 0, typeNameLength), token, (CorTypeAttr)typeDefFlags, baseTypeToken);
					TypeDefinitions[token] = typeDefinition;
					Assembly.AllTokens[token] = typeDefinition;
				}

				import.EnumTypeDefs(ref enumHandle, typeDefs, Convert.ToUInt32(typeDefs.Length), out count);
			}

			import.CloseEnum(enumHandle);

			foreach (NuGenTypeDefinition typeDefinition in TypeDefinitions.Values)
			{
				if (typeDefinition.IsNestedType)
				{
					typeDefinition.FindEnclosingType(import);
				}
			}

			DebuggedModule = null;
		}
Example #22
0
		public void LoadAssemblyFromMetadataInterfaces(NuGenIMetaDataDispenserEx dispenser, NuGenIMetaDataAssemblyImport assemblyImport, NuGenIMetaDataImport2 import, ModuleWrapper debuggedModule)
		{
			Dispenser = dispenser;
			AssemblyImport = assemblyImport;
			Import = import;

			uint bufferCount;
			Import.GetVersionString(NuGenProject.DefaultCharArray, Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out bufferCount);

			if (bufferCount > NuGenProject.DefaultCharArray.Length)
			{
				NuGenProject.DefaultCharArray = new char[bufferCount];
				Import.GetVersionString(NuGenProject.DefaultCharArray, bufferCount, out bufferCount);
			}

			FrameworkVersion = NuGenHelperFunctions.GetString(NuGenProject.DefaultCharArray, 0, bufferCount);
			ProcessWrapper debuggedProcess = debuggedModule.GetProcess();
			Process process = Process.GetProcessById(Convert.ToInt32(debuggedProcess.GetID()));
			FullPath = process.MainModule.FileName;
			FileName = Name;

			LoadAssemblyFromMetadataInterfaces(debuggedModule);
		}
		public NuGenMethodDefinition(NuGenIMetaDataImport2 import, NuGenTypeDefinition typeDefinition, string name, uint token, uint flags, IntPtr signaturePointer, uint signatureLength, uint rva, uint implementationFlags)
		{
			BaseTypeDefinition = typeDefinition;
			Name = name;
			Token = token;
			Flags = (CorMethodAttr)flags;
			SignaturePointer = signaturePointer;
			SignatureLength = signatureLength;
			Rva = rva;
			ImplementationFlags = (CorMethodImpl)implementationFlags;

			NuGenAssembly assembly = BaseTypeDefinition.ModuleScope.Assembly;

			NuGenHelperFunctions.GetMemberReferences(assembly, token);
			EnumParameters(import);
			GenericParameters = NuGenHelperFunctions.EnumGenericParameters(import, assembly, this);
			MethodSpecs = NuGenHelperFunctions.EnumMethodSpecs(import, assembly, this);
			
			if (assembly.ModuleScope.DebuggedModule != null)
			{
				FunctionWrapper debuggedFunction = assembly.ModuleScope.DebuggedModule.GetFunction(Token);

				try
				{
					LocalVarSigToken = debuggedFunction.GetLocalVarSigToken();

					if (LocalVarSigToken == DefaultSignatureValue)
					{
						LocalVarSigToken = 0;
					}

					MethodAddress = debuggedFunction.GetAddress();
				}
				catch (COMException comException)
				{
					//0x8013130a exception means that the method is native.
					if ((uint)comException.ErrorCode == 0x8013130a)
					{
						LocalVarSigToken = 0;
					}
				}
			}
		}
		public NuGenModuleScope(NuGenIMetaDataImport2 import, NuGenAssembly assembly)
		{
			Assembly = assembly;
			uint moduleNameLength;
			import.GetScopeProps(NuGenProject.DefaultCharArray, Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out moduleNameLength, ref mvid);

			if (moduleNameLength > NuGenProject.DefaultCharArray.Length)
			{
				NuGenProject.DefaultCharArray = new char[moduleNameLength];

				import.GetScopeProps(NuGenProject.DefaultCharArray, Convert.ToUInt32(NuGenProject.DefaultCharArray.Length), out moduleNameLength, ref mvid);
			}

			Name = NuGenHelperFunctions.GetString(NuGenProject.DefaultCharArray, 0, moduleNameLength);

			uint token;
			import.GetModuleFromScope(out token);
			Token = token;
			Assembly.AllTokens[Token] = this;
		}
		public NuGenGenericParameter(NuGenIMetaDataImport2 import, uint token, string name, uint sequence, uint attributes, NuGenTokenBase owner, uint kind)
		{
			Token = token;
			Name = name;
			Sequence = sequence;
			Attributes = (CorGenericParamAttr)attributes;
			Owner = owner;
			Kind = kind;

			EnumConstraints(import);
		}