Beispiel #1
0
        /// <summary>
        /// Returns an assembly name string
        /// </summary>
        /// <param name="name">Simple assembly name</param>
        /// <param name="version">Version or <c>null</c></param>
        /// <param name="culture">Culture or <c>null</c></param>
        /// <param name="publicKey">Public key / public key token or <c>null</c></param>
        /// <param name="attributes">Assembly attributes</param>
        /// <returns>An assembly name string</returns>
        internal static string GetAssemblyNameString(UTF8String name, Version version, UTF8String culture, PublicKeyBase publicKey, AssemblyAttributes attributes)
        {
            var sb = new StringBuilder();

            foreach (var c in UTF8String.ToSystemStringOrEmpty(name))
            {
                if (c == ',' || c == '=')
                {
                    sb.Append('\\');
                }
                sb.Append(c);
            }

            if (version is not null)
            {
                sb.Append(", Version=");
                sb.Append(CreateVersionWithNoUndefinedValues(version).ToString());
            }

            if (culture is not null)
            {
                sb.Append(", Culture=");
                sb.Append(UTF8String.IsNullOrEmpty(culture) ? "neutral" : culture.String);
            }

            sb.Append(", ");
            sb.Append(publicKey is null || publicKey is PublicKeyToken ? "PublicKeyToken=" : "PublicKey=");
            sb.Append(publicKey is null ? "null" : publicKey.ToString());

            if ((attributes & AssemblyAttributes.Retargetable) != 0)
            {
                sb.Append(", Retargetable=Yes");
            }

            if ((attributes & AssemblyAttributes.ContentType_Mask) == AssemblyAttributes.ContentType_WindowsRuntime)
            {
                sb.Append(", ContentType=WindowsRuntime");
            }

            return(sb.ToString());
        }
Beispiel #2
0
        /// <summary>
        /// Reads the new (.NET Framework 2.0+) DeclSecurity blob format
        /// </summary>
        /// <returns></returns>
        IList <SecurityAttribute> ReadBinaryFormat()
        {
            int numAttrs = (int)reader.ReadCompressedUInt32();
            var list     = new List <SecurityAttribute>(numAttrs);

            for (int i = 0; i < numAttrs; i++)
            {
                var name = ReadUTF8String();
                // Use CA search rules. Some tools don't write the fully qualified name.
                var attrRef = TypeNameParser.ParseReflection(module, UTF8String.ToSystemStringOrEmpty(name), new CAAssemblyRefFinder(module), gpContext);
                /*int blobLength = (int)*/ reader.ReadCompressedUInt32();
                int numNamedArgs = (int)reader.ReadCompressedUInt32();
                var namedArgs    = CustomAttributeReader.ReadNamedArguments(module, ref reader, numNamedArgs, gpContext);
                if (namedArgs is null)
                {
                    throw new ApplicationException("Could not read named arguments");
                }
                list.Add(new SecurityAttribute(attrRef, namedArgs));
            }

            return(list);
        }
Beispiel #3
0
 static string GetCanonicalLocale(UTF8String locale) => GetCanonicalLocale(UTF8String.ToSystemStringOrEmpty(locale));
        MarshalType Read()
        {
            MarshalType returnValue;

            try {
                var        nativeType = (NativeType)reader.ReadByte();
                NativeType nt;
                int        size;
                switch (nativeType)
                {
                case NativeType.FixedSysString:
                    size        = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
                    returnValue = new FixedSysStringMarshalType(size);
                    break;

                case NativeType.SafeArray:
                    var vt      = CanRead() ? (VariantType)reader.ReadCompressedUInt32() : VariantType.NotInitialized;
                    var udtName = CanRead() ? ReadUTF8String() : null;
                    var udtRef  = udtName is null ? null : TypeNameParser.ParseReflection(module, UTF8String.ToSystemStringOrEmpty(udtName), null, gpContext);
                    returnValue = new SafeArrayMarshalType(vt, udtRef);
                    break;

                case NativeType.FixedArray:
                    size        = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
                    nt          = CanRead() ? (NativeType)reader.ReadCompressedUInt32() : NativeType.NotInitialized;
                    returnValue = new FixedArrayMarshalType(size, nt);
                    break;

                case NativeType.Array:
                    nt = CanRead() ? (NativeType)reader.ReadCompressedUInt32() : NativeType.NotInitialized;
                    int paramNum = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
                    size = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
                    int flags = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
                    returnValue = new ArrayMarshalType(nt, paramNum, size, flags);
                    break;

                case NativeType.CustomMarshaler:
                    var guid              = ReadUTF8String();
                    var nativeTypeName    = ReadUTF8String();
                    var custMarshalerName = ReadUTF8String();
                    var cmRef             = custMarshalerName.DataLength == 0 ? null : TypeNameParser.ParseReflection(module, UTF8String.ToSystemStringOrEmpty(custMarshalerName), new CAAssemblyRefFinder(module), gpContext);
                    var cookie            = ReadUTF8String();
                    returnValue = new CustomMarshalType(guid, nativeTypeName, cmRef, cookie);
                    break;

                case NativeType.IUnknown:
                case NativeType.IDispatch:
                case NativeType.IntF:
                    int iidParamIndex = CanRead() ? (int)reader.ReadCompressedUInt32() : -1;
                    return(new InterfaceMarshalType(nativeType, iidParamIndex));

                default:
                    returnValue = new MarshalType(nativeType);
                    break;
                }
            }
            catch {
                returnValue = new RawMarshalType(reader.ToArray());
            }

            return(returnValue);
        }