public UnresolvedSecurityDeclarationBlob(int securityAction, byte[] blob)
        {
            BlobReader reader = new BlobReader(blob, null);

            this.securityAction = new SimpleConstantValue(securityActionTypeReference, securityAction);
            this.blob           = blob;
            if (reader.ReadByte() == '.')
            {
                // binary attribute
                uint attributeCount = reader.ReadCompressedUInt32();
                for (uint i = 0; i < attributeCount; i++)
                {
                    unresolvedAttributes.Add(new UnresolvedSecurityAttribute(this, (int)i));
                }
            }
            else
            {
                // for backward compatibility with .NET 1.0: XML-encoded attribute
                var attr = new DefaultUnresolvedAttribute(permissionSetAttributeTypeReference);
                attr.ConstructorParameterTypes.Add(securityActionTypeReference);
                attr.PositionalArguments.Add(this.securityAction);
                string xml = System.Text.Encoding.Unicode.GetString(blob);
                attr.AddNamedPropertyArgument("XML", new SimpleConstantValue(KnownTypeReference.String, xml));
                unresolvedAttributes.Add(attr);
            }
        }
Example #2
0
            public DefaultResolvedAttribute(DefaultUnresolvedAttribute unresolved, ITypeResolveContext context)
            {
                this.unresolved = unresolved;
                this.context    = context;

                this.attributeType       = unresolved.AttributeType.Resolve(context);
                this.positionalArguments = unresolved.PositionalArguments.Resolve(context);
            }
Example #3
0
        bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
        {
            DefaultUnresolvedAttribute o = other as DefaultUnresolvedAttribute;

            return(o != null && attributeType == o.attributeType &&
                   constructorParameterTypes == o.constructorParameterTypes && positionalArguments == o.positionalArguments &&
                   ListEquals(namedArguments ?? EmptyList <KeyValuePair <IMemberReference, IConstantValue> > .Instance,
                              o.namedArguments ?? EmptyList <KeyValuePair <IMemberReference, IConstantValue> > .Instance));
        }
Example #4
0
        /// <summary>
        /// Adds a type forwarder.
        /// This adds both an assembly attribute and an internal forwarder entry, which will be used
        /// by the resolved assembly to provide the forwarded types.
        /// </summary>
        /// <param name="typeName">The name of the type.</param>
        /// <param name="referencedType">The reference used to look up the type in the target assembly.</param>
        public void AddTypeForwarder(TopLevelTypeName typeName, ITypeReference referencedType)
        {
            if (referencedType == null)
            {
                throw new ArgumentNullException("referencedType");
            }
            FreezableHelper.ThrowIfFrozen(this);
            var attribute = new DefaultUnresolvedAttribute(typeForwardedToAttributeTypeRef, new[] { KnownTypeReference.Type });

            attribute.PositionalArguments.Add(new TypeOfConstantValue(referencedType));
            assemblyAttributes.Add(attribute);

            typeForwarders[typeName] = referencedType;
        }
		public UnresolvedSecurityDeclarationBlob(int securityAction, byte[] blob)
		{
			BlobReader reader = new BlobReader(blob, null);
			this.securityAction = new SimpleConstantValue(securityActionTypeReference, securityAction);
			this.blob = blob;
			if (reader.ReadByte() == '.') {
				// binary attribute
				uint attributeCount = reader.ReadCompressedUInt32();
				for (uint i = 0; i < attributeCount; i++) {
					unresolvedAttributes.Add(new UnresolvedSecurityAttribute(this, (int)i));
				}
			} else {
				// for backward compatibility with .NET 1.0: XML-encoded attribute
				var attr = new DefaultUnresolvedAttribute(permissionSetAttributeTypeReference);
				attr.ConstructorParameterTypes.Add(securityActionTypeReference);
				attr.PositionalArguments.Add(this.securityAction);
				string xml = System.Text.Encoding.Unicode.GetString(blob);
				attr.AddNamedPropertyArgument("XML", new SimpleConstantValue(KnownTypeReference.String, xml));
				unresolvedAttributes.Add(attr);
			}
		}
		/// <summary>
		/// Adds a type forwarder.
		/// This adds both an assembly attribute and an internal forwarder entry, which will be used
		/// by the resolved assembly to provide the forwarded types.
		/// </summary>
		/// <param name="typeName">The name of the type.</param>
		/// <param name="referencedType">The reference used to look up the type in the target assembly.</param>
		public void AddTypeForwarder(FullNameAndTypeParameterCount typeName, ITypeReference referencedType)
		{
			if (referencedType == null)
				throw new ArgumentNullException("referencedType");
			FreezableHelper.ThrowIfFrozen(this);
			var attribute = new DefaultUnresolvedAttribute(typeForwardedToAttributeTypeRef, new[] { KnownTypeReference.Type });
			attribute.PositionalArguments.Add(new TypeOfConstantValue(referencedType));
			assemblyAttributes.Add(attribute);
			
			typeForwarders[typeName] = referencedType;
		}
			public DefaultResolvedAttribute(DefaultUnresolvedAttribute unresolved, ITypeResolveContext context)
			{
				this.unresolved = unresolved;
				this.context = context;
				
				this.attributeType = unresolved.AttributeType.Resolve(context);
				this.positionalArguments = unresolved.PositionalArguments.Resolve(context);
			}
Example #8
0
        IUnresolvedAttribute ConvertMarshalInfo(FieldMarshal marshalInfo)
        {
            DefaultUnresolvedAttribute attr = new DefaultUnresolvedAttribute(marshalAsAttributeTypeRef, new[] { unmanagedTypeTypeRef });
            attr.PositionalArguments.Add(CreateSimpleConstantValue(unmanagedTypeTypeRef, (int)marshalInfo.UnmanagedType));

            if (marshalInfo.UnmanagedType ==UnmanagedType.ByValArray) {
                attr.AddNamedFieldArgument("SizeConst", CreateSimpleConstantValue(KnownTypeReference.Int32, (int)marshalInfo.SizeConst));
                if (marshalInfo.ArraySubType.HasValue)
                    attr.AddNamedFieldArgument("ArraySubType", CreateSimpleConstantValue(unmanagedTypeTypeRef, (int)marshalInfo.ArraySubType.Value));
            }

            if (marshalInfo.UnmanagedType ==UnmanagedType.SafeArray) {
                attr.AddNamedFieldArgument("SafeArraySubType", CreateSimpleConstantValue(typeof(VarEnum).ToTypeReference(), (int)marshalInfo.SafeArraySubType));
            }

            if (marshalInfo.UnmanagedType == UnmanagedType.LPArray) {
                if (marshalInfo.ArraySubType != null)
                    attr.AddNamedFieldArgument("ArraySubType", CreateSimpleConstantValue(unmanagedTypeTypeRef, (int)marshalInfo.ArraySubType));
                if (marshalInfo.SizeConst >= 0)
                    attr.AddNamedFieldArgument("SizeConst", CreateSimpleConstantValue(KnownTypeReference.Int32, (int)marshalInfo.SizeConst));
                if (marshalInfo.SizeParamIndex >= 0)
                    attr.AddNamedFieldArgument("SizeParamIndex", CreateSimpleConstantValue(KnownTypeReference.Int16, (short)marshalInfo.SizeParamIndex));
            }

            if (marshalInfo.UnmanagedType == UnmanagedType.CustomMarshaler) {
                attr.AddNamedFieldArgument("MarshalType", CreateSimpleConstantValue(KnownTypeReference.String, marshalInfo.MarshalTypeRef.FullName));
                if (!string.IsNullOrEmpty(marshalInfo.MarshalCookie))
                    attr.AddNamedFieldArgument("MarshalCookie", CreateSimpleConstantValue(KnownTypeReference.String, marshalInfo.MarshalCookie));
            }

            if (marshalInfo.UnmanagedType == UnmanagedType.ByValTStr) {
                attr.AddNamedFieldArgument("SizeConst", CreateSimpleConstantValue(KnownTypeReference.Int32, (int)marshalInfo.SizeConst));
            }

            return InterningProvider.Intern(attr);
        }
Example #9
0
        void AddAttributes(FieldInfo fieldDefinition, IUnresolvedEntity targetEntity)
        {
            // FieldOffsetAttribute
            int fOffset;
            if (fieldDefinition.__TryGetFieldOffset(out fOffset)) {
                var fieldOffset = new DefaultUnresolvedAttribute(fieldOffsetAttributeTypeRef, new[] { KnownTypeReference.Int32 });
                fieldOffset.PositionalArguments.Add(CreateSimpleConstantValue(KnownTypeReference.Int32, fOffset));
                targetEntity.Attributes.Add(interningProvider.Intern(fieldOffset));
            }

            // NonSerializedAttribute
            if (fieldDefinition.IsNotSerialized) {
                targetEntity.Attributes.Add(nonSerializedAttribute);
            }
            FieldMarshal marshal;
            if (fieldDefinition.__TryGetFieldMarshal (out marshal))
                targetEntity.Attributes.Add(ConvertMarshalInfo(marshal));

            AddCustomAttributes(fieldDefinition.CustomAttributes, targetEntity.Attributes);
        }
Example #10
0
        void AddAttributes(IKVM.Reflection.Type typeDefinition, IUnresolvedTypeDefinition targetEntity)
        {
            // SerializableAttribute
            if (typeDefinition.IsSerializable)
                targetEntity.Attributes.Add(serializableAttribute);

            // ComImportAttribute
            if (typeDefinition.IsImport)
                targetEntity.Attributes.Add(comImportAttribute);

            #region StructLayoutAttribute
            LayoutKind layoutKind = LayoutKind.Auto;
            switch (typeDefinition.Attributes & TypeAttributes.LayoutMask) {
                case TypeAttributes.SequentialLayout:
                layoutKind = LayoutKind.Sequential;
                break;
                case TypeAttributes.ExplicitLayout:
                layoutKind = LayoutKind.Explicit;
                break;
            }
            CharSet charSet = CharSet.None;
            switch (typeDefinition.Attributes & TypeAttributes.StringFormatMask) {
                case TypeAttributes.AnsiClass:
                charSet = CharSet.Ansi;
                break;
                case TypeAttributes.AutoClass:
                charSet = CharSet.Auto;
                break;
                case TypeAttributes.UnicodeClass:
                charSet = CharSet.Unicode;
                break;
            }

            int packingSize;
            int typeSize;
            if (typeDefinition.__GetLayout (out packingSize, out typeSize)) {
                LayoutKind defaultLayoutKind = (typeDefinition.IsValueType && !typeDefinition.IsEnum) ? LayoutKind.Sequential: LayoutKind.Auto;
                if (layoutKind != defaultLayoutKind || charSet != CharSet.Ansi || packingSize > 0 || typeSize > 0) {
                    var structLayout = new DefaultUnresolvedAttribute(structLayoutAttributeTypeRef, new[] { layoutKindTypeRef });
                    structLayout.PositionalArguments.Add(CreateSimpleConstantValue(layoutKindTypeRef, (int)layoutKind));
                    if (charSet != CharSet.Ansi) {
                        structLayout.AddNamedFieldArgument("CharSet", CreateSimpleConstantValue(charSetTypeRef, (int)charSet));
                    }
                    if (packingSize > 0) {
                        structLayout.AddNamedFieldArgument("Pack", CreateSimpleConstantValue(KnownTypeReference.Int32, packingSize));
                    }
                    if (typeSize > 0) {
                        structLayout.AddNamedFieldArgument("Size", CreateSimpleConstantValue(KnownTypeReference.Int32, typeSize));
                    }
                    targetEntity.Attributes.Add(interningProvider.Intern(structLayout));
                }
            }
            #endregion

            AddCustomAttributes(typeDefinition.CustomAttributes, targetEntity.Attributes);

            if (typeDefinition.Attributes.HasFlag (TypeAttributes.HasSecurity)) {
                AddSecurityAttributes(CustomAttributeData.__GetDeclarativeSecurity(typeDefinition), targetEntity.Attributes);
            }
        }
Example #11
0
        void AddAttributes(ConstructorInfo methodDefinition, IList<IUnresolvedAttribute> attributes, IList<IUnresolvedAttribute> returnTypeAttributes)
        {
            var implAttributes = methodDefinition.MethodImplementationFlags;

            #region PreserveSigAttribute
            if (implAttributes == MethodImplAttributes.PreserveSig) {
                attributes.Add(preserveSigAttribute);
                implAttributes = 0;
            }
            #endregion

            #region MethodImplAttribute
            if (implAttributes != MethodImplAttributes.IL) {
                var methodImpl = new DefaultUnresolvedAttribute(methodImplAttributeTypeRef, new[] { methodImplOptionsTypeRef });
                methodImpl.PositionalArguments.Add(CreateSimpleConstantValue(methodImplOptionsTypeRef, (int)implAttributes));
                attributes.Add(interningProvider.Intern(methodImpl));
            }
            #endregion

            AddCustomAttributes(methodDefinition.CustomAttributes, attributes);

            if (methodDefinition.Attributes.HasFlag (MethodAttributes.HasSecurity)) {
                AddSecurityAttributes(CustomAttributeData.__GetDeclarativeSecurity (methodDefinition), attributes);
            }
        }
Example #12
0
        void AddAttributes(MethodInfo methodDefinition, IList<IUnresolvedAttribute> attributes, ICollection<IUnresolvedAttribute> returnTypeAttributes)
        {
            var implAttributes = methodDefinition.MethodImplementationFlags;

            #region DllImportAttribute
            if (methodDefinition.Attributes.HasFlag (MethodAttributes.PinvokeImpl)) {

                ImplMapFlags flags;
                string importName;
                string importScope;
                if (methodDefinition.__TryGetImplMap(out flags, out importName, out importScope)) {
                    var dllImport = new DefaultUnresolvedAttribute(dllImportAttributeTypeRef, new[] { KnownTypeReference.String });
                    dllImport.PositionalArguments.Add(CreateSimpleConstantValue(KnownTypeReference.String, importScope));

                    if (flags.HasFlag (ImplMapFlags.BestFitOff))
                        dllImport.AddNamedFieldArgument("BestFitMapping", falseValue);
                    if (flags.HasFlag (ImplMapFlags.BestFitOn))
                        dllImport.AddNamedFieldArgument("BestFitMapping", trueValue);

                    CallingConvention callingConvention;
                    switch (flags & ImplMapFlags.CallConvMask) {
                        case (ImplMapFlags)0:
                            Debug.WriteLine ("P/Invoke calling convention not set on:" + methodDefinition.Name);
                            callingConvention = CallingConvention.StdCall;
                            break;
                        case ImplMapFlags.CallConvCdecl:
                            callingConvention = CallingConvention.Cdecl;
                            break;
                        case ImplMapFlags.CallConvFastcall:
                            callingConvention = CallingConvention.FastCall;
                            break;
                        case ImplMapFlags.CallConvStdcall:
                            callingConvention = CallingConvention.StdCall;
                            break;
                        case ImplMapFlags.CallConvThiscall:
                            callingConvention = CallingConvention.ThisCall;
                            break;
                        case ImplMapFlags.CallConvWinapi:
                            callingConvention = CallingConvention.Winapi;
                            break;
                        default:
                            throw new NotSupportedException("unknown calling convention");
                    }
                    if (!flags.HasFlag (ImplMapFlags.CallConvWinapi))
                        dllImport.AddNamedFieldArgument("CallingConvention", CreateSimpleConstantValue(callingConventionTypeRef, (int)callingConvention));

                    CharSet charSet = CharSet.None;
                    switch (flags & ImplMapFlags.CharSetMask) {
                        case ImplMapFlags.CharSetAnsi:
                            charSet = CharSet.Ansi;
                            break;
                        case ImplMapFlags.CharSetAuto:
                            charSet = CharSet.Auto;
                            break;
                        case ImplMapFlags.CharSetUnicode:
                            charSet = CharSet.Unicode;
                            break;
                    }
                    if (charSet != CharSet.None)
                        dllImport.AddNamedFieldArgument("CharSet", CreateSimpleConstantValue(charSetTypeRef, (int)charSet));

                    if (!string.IsNullOrEmpty(importName) && importName != methodDefinition.Name)
                        dllImport.AddNamedFieldArgument("EntryPoint", CreateSimpleConstantValue(KnownTypeReference.String, importName));

                    if (flags.HasFlag (ImplMapFlags.NoMangle))
                        dllImport.AddNamedFieldArgument("ExactSpelling", trueValue);

                    if ((implAttributes & MethodImplAttributes.PreserveSig) == MethodImplAttributes.PreserveSig)
                        implAttributes &= ~MethodImplAttributes.PreserveSig;
                    else
                        dllImport.AddNamedFieldArgument("PreserveSig", falseValue);

                    if (flags.HasFlag (ImplMapFlags.SupportsLastError))
                        dllImport.AddNamedFieldArgument("SetLastError", trueValue);

                    if (flags.HasFlag (ImplMapFlags.CharMapErrorOff))
                        dllImport.AddNamedFieldArgument("ThrowOnUnmappableChar", falseValue);
                    if (flags.HasFlag (ImplMapFlags.CharMapErrorOn))
                        dllImport.AddNamedFieldArgument("ThrowOnUnmappableChar", trueValue);

                    attributes.Add(interningProvider.Intern(dllImport));
                }
            }
            #endregion

            #region PreserveSigAttribute
            if (implAttributes == MethodImplAttributes.PreserveSig) {
                attributes.Add(preserveSigAttribute);
                implAttributes = (MethodImplAttributes)0;
            }
            #endregion

            #region MethodImplAttribute
            if (implAttributes != MethodImplAttributes.IL) {
                var methodImpl = new DefaultUnresolvedAttribute(methodImplAttributeTypeRef, new[] { methodImplOptionsTypeRef });
                methodImpl.PositionalArguments.Add(CreateSimpleConstantValue(methodImplOptionsTypeRef, (int)implAttributes));
                attributes.Add(interningProvider.Intern(methodImpl));
            }
            #endregion

            var customAttributes = methodDefinition.CustomAttributes;
            AddCustomAttributes (customAttributes, attributes);

            if (methodDefinition.Attributes.HasFlag (MethodAttributes.HasSecurity)) {
                AddSecurityAttributes(CustomAttributeData.__GetDeclarativeSecurity (methodDefinition), attributes);
            }

            FieldMarshal marshalInfo;
            if (methodDefinition.ReturnParameter.__TryGetFieldMarshal (out marshalInfo)) {
                returnTypeAttributes.Add(ConvertMarshalInfo(marshalInfo));
            }
            // TODO: Not needed in ikvm - maybe a work around for a cecil bug ?
            //			AddCustomAttributes(methodDefinition.ReturnType.CustomAttributes, returnTypeAttributes);
        }
Example #13
0
        void AddAttributes(Assembly assembly, IList<IUnresolvedAttribute> outputList)
        {
            AddCustomAttributes(assembly.CustomAttributes, outputList);
            AddSecurityAttributes(CustomAttributeData.__GetDeclarativeSecurity (assembly), outputList);

            // AssemblyVersionAttribute
            if (assembly.GetName ().Version != null) {
                var assemblyVersion = new DefaultUnresolvedAttribute(assemblyVersionAttributeTypeRef, new[] { KnownTypeReference.String });
                assemblyVersion.PositionalArguments.Add(CreateSimpleConstantValue(KnownTypeReference.String, assembly.GetName ().Version.ToString()));
                outputList.Add(interningProvider.Intern(assemblyVersion));
            }
        }
Example #14
0
			public override void VisitDocument(AXmlDocument document)
			{
				currentDocument = document;
				AXmlElement rootElement = currentDocument.Children.OfType<AXmlElement>().FirstOrDefault();
				if (rootElement != null) {
					string className = rootElement.GetAttributeValue(XamlConst.XamlNamespace, "Class");
					string modifier = rootElement.GetAttributeValue(XamlConst.XamlNamespace, "ClassModifier");
					if (className != null) {
						TypeDefinition = new DefaultUnresolvedTypeDefinition(className) {
							Kind = TypeKind.Class,
							UnresolvedFile = file,
							Accessibility = Accessibility.Public,
							Region = new DomRegion(file.FileName, textDocument.GetLocation(rootElement.StartOffset), textDocument.GetLocation(rootElement.EndOffset))
						};
						TypeDefinition.Members.Add(
							new DefaultUnresolvedMethod(TypeDefinition, "InitializeComponent") {
								Accessibility = Accessibility.Public,
								ReturnType = KnownTypeReference.Void
							});
						TypeDefinition.Members.Add(
							new DefaultUnresolvedField(TypeDefinition, "_contentLoaded") {
								Accessibility = Accessibility.Private,
								ReturnType = KnownTypeReference.Boolean
							});
						
						var connectMember =
							new DefaultUnresolvedMethod(TypeDefinition, "Connect") {
							Accessibility = Accessibility.Private,
							ReturnType = KnownTypeReference.Void
						};
						connectMember.Parameters.Add(new DefaultUnresolvedParameter(KnownTypeReference.Int32, "connectionId"));
						connectMember.Parameters.Add(new DefaultUnresolvedParameter(KnownTypeReference.Object, "target"));
						TypeDefinition.Members.Add(connectMember);
						connectMember.ExplicitInterfaceImplementations.Add(
							new DefaultMemberReference(SymbolKind.Method, new GetClassTypeReference(new FullTypeName(typeof(System.Windows.Markup.IComponentConnector).FullName)), "Connect"));
						
						var browsableAttribute = new DefaultUnresolvedAttribute(new GetClassTypeReference(new FullTypeName(typeof(System.ComponentModel.EditorBrowsableAttribute).FullName)));
						
						browsableAttribute.PositionalArguments.Add(
							new SimpleConstantValue(
								new GetClassTypeReference(new FullTypeName(typeof(System.ComponentModel.EditorBrowsableAttribute).FullName)), System.ComponentModel.EditorBrowsableState.Never
							));
						
						connectMember.Attributes.Add(browsableAttribute);
						TypeDefinition.BaseTypes.Add(CreateTypeReference(rootElement.Namespace, rootElement.LocalName));
						TypeDefinition.BaseTypes.Add(new GetClassTypeReference(new FullTypeName(typeof(System.Windows.Markup.IComponentConnector).FullName)));
						if (modifier != null)
							TypeDefinition.Accessibility = ParseAccessibility(modifier);
					}
				}
				base.VisitDocument(document);
			}