Inheritance: ExpressionBase, IMetadataNamedArgument
示例#1
0
    SecurityCustomAttribute/*?*/ ReadSecurityAttribute(SecurityAttribute securityAttribute) {
      string/*?*/ typeNameStr = this.GetSerializedString();
      if (typeNameStr == null)
        return null;
      ITypeReference/*?*/ moduleTypeReference = this.PEFileToObjectModel.GetSerializedTypeNameAsTypeReference(typeNameStr);
      if (moduleTypeReference == null)
        return null;
      IMethodReference ctorReference = Dummy.MethodReference;
      ITypeDefinition attributeType = moduleTypeReference.ResolvedType;
      if (!(attributeType is Dummy)) {
        foreach (ITypeDefinitionMember member in attributeType.GetMembersNamed(this.PEFileToObjectModel.NameTable.Ctor, false)) {
          IMethodDefinition/*?*/ method = member as IMethodDefinition;
          if (method == null) continue;
          if (!IteratorHelper.EnumerableHasLength(method.Parameters, 1)) continue;
          //TODO: check that parameter has the right type
          ctorReference = method;
          break;
        }
      } else {
        int ctorKey = this.PEFileToObjectModel.NameTable.Ctor.UniqueKey;
        foreach (ITypeMemberReference mref in this.PEFileToObjectModel.GetMemberReferences()) {
          IMethodReference/*?*/ methRef = mref as IMethodReference;
          if (methRef == null) continue;
          if (methRef.ContainingType.InternedKey != moduleTypeReference.InternedKey) continue;
          if (methRef.Name.UniqueKey != ctorKey) continue;
          if (!IteratorHelper.EnumerableHasLength(methRef.Parameters, 1)) continue;
          //TODO: check that parameter has the right type
          ctorReference = methRef;
          break;
        }
      }
      if (ctorReference is Dummy) {
        ctorReference = new MethodReference(this.PEFileToObjectModel.ModuleReader.metadataReaderHost, moduleTypeReference,
          CallingConvention.Default|CallingConvention.HasThis, this.PEFileToObjectModel.PlatformType.SystemVoid,
          this.PEFileToObjectModel.NameTable.Ctor, 0, this.PEFileToObjectModel.PlatformType.SystemSecurityPermissionsSecurityAction);
      }

      this.SignatureMemoryReader.ReadCompressedUInt32(); //  BlobSize...
      int numOfNamedArgs = this.SignatureMemoryReader.ReadCompressedUInt32();
      FieldOrPropertyNamedArgumentExpression[]/*?*/ namedArgumentArray = null;
      if (numOfNamedArgs > 0) {
        namedArgumentArray = new FieldOrPropertyNamedArgumentExpression[numOfNamedArgs];
        for (int i = 0; i < numOfNamedArgs; ++i) {
          bool isField = this.SignatureMemoryReader.ReadByte() == SerializationType.Field;
          ITypeReference/*?*/ memberType = this.GetFieldOrPropType();
          if (memberType == null)
            return null;
          string/*?*/ memberStr = this.GetSerializedString();
          if (memberStr == null)
            return null;
          IName memberName = this.PEFileToObjectModel.NameTable.GetNameFor(memberStr);
          ExpressionBase/*?*/ value = this.ReadSerializedValue(memberType);
          if (value == null)
            return null;
          namedArgumentArray[i] = new FieldOrPropertyNamedArgumentExpression(memberName, moduleTypeReference, isField, memberType, value);
        }
      }
      return new SecurityCustomAttribute(securityAttribute, ctorReference, namedArgumentArray);
    }
示例#2
0
 //^ [NotDelayed]
 internal CustomAttributeDecoder(
   PEFileToObjectModel peFileToObjectModel,
   MemoryReader signatureMemoryReader,
   uint customAttributeRowId,
   IModuleMethodReference attributeConstructor
 )
   : base(peFileToObjectModel, signatureMemoryReader) {
   //^ this.SignatureMemoryReader = signatureMemoryReader; //TODO: Spec# bug. This assignment should not be necessary.
   this.CustomAttribute = Dummy.CustomAttribute;
   //^ base;
   ushort prolog = this.SignatureMemoryReader.ReadUInt16();
   if (prolog != SerializationType.CustomAttributeStart) {
     return;
   }
   List<ExpressionBase> exprList = new List<ExpressionBase>();
   IModuleParameterTypeInformation[] modParams = attributeConstructor.RequiredModuleParameterInfos.RawArray;
   int len = modParams.Length;
   for (int i = 0; i < len; ++i) {
     IModuleTypeReference/*?*/ moduleTypeRef = modParams[i].ModuleTypeReference;
     if (moduleTypeRef == null) {
       //  Error...
       return;
     }
     ExpressionBase/*?*/ argument = this.ReadSerializedValue(moduleTypeRef);
     if (argument == null) {
       //  Error...
       this.decodeFailed = true;
       return;
     }
     exprList.Add(argument);
   }
   ushort numOfNamedArgs = this.SignatureMemoryReader.ReadUInt16();
   FieldOrPropertyNamedArgumentExpression[]/*?*/ namedArgumentArray = null;
   if (numOfNamedArgs > 0) {
     namedArgumentArray = new FieldOrPropertyNamedArgumentExpression[numOfNamedArgs];
     for (ushort i = 0; i < numOfNamedArgs; ++i) {
       bool isField = this.SignatureMemoryReader.ReadByte() == SerializationType.Field;
       IModuleTypeReference/*?*/ memberType = this.GetFieldOrPropType();
       if (memberType == null) {
         //  Error...
         return;
       }
       string/*?*/ memberStr = this.GetSerializedString();
       if (memberStr == null)
         return;
       IName memberName = this.PEFileToObjectModel.NameTable.GetNameFor(memberStr);
       ExpressionBase/*?*/ value = this.ReadSerializedValue(memberType);
       if (value == null) {
         //  Error...
         return;
       }
       IModuleTypeReference/*?*/ moduleTypeRef = attributeConstructor.OwningTypeReference;
       if (moduleTypeRef == null) {
         //  Error...
         return;
       }
       FieldOrPropertyNamedArgumentExpression namedArg = new FieldOrPropertyNamedArgumentExpression(memberName, moduleTypeRef, isField, memberType, value);
       namedArgumentArray[i] = namedArg;
     }
   }
   EnumerableArrayWrapper<ExpressionBase, IMetadataExpression> arguments = TypeCache.EmptyExpressionList;
   if (exprList.Count > 0)
     arguments = new EnumerableArrayWrapper<ExpressionBase, IMetadataExpression>(exprList.ToArray(), Dummy.Expression);
   EnumerableArrayWrapper<FieldOrPropertyNamedArgumentExpression, IMetadataNamedArgument> namedArguments = TypeCache.EmptyNamedArgumentList;
   if (namedArgumentArray != null)
     namedArguments = new EnumerableArrayWrapper<FieldOrPropertyNamedArgumentExpression, IMetadataNamedArgument>(namedArgumentArray, Dummy.NamedArgument);
   this.CustomAttribute = new CustomAttribute(this.PEFileToObjectModel, customAttributeRowId, attributeConstructor, arguments, namedArguments);
 }
示例#3
0
 internal CustomAttributeDecoder(PEFileToObjectModel peFileToObjectModel, MemoryReader signatureMemoryReader, uint customAttributeRowId,
   IMethodReference attributeConstructor)
   : base(peFileToObjectModel, signatureMemoryReader) {
   this.CustomAttribute = Dummy.CustomAttribute;
   ushort prolog = this.SignatureMemoryReader.ReadUInt16();
   if (prolog != SerializationType.CustomAttributeStart) return;
   int len = attributeConstructor.ParameterCount;
   IMetadataExpression[]/*?*/ exprList = len == 0 ? null : new IMetadataExpression[len];
   int i = 0;
   foreach (var parameter in attributeConstructor.Parameters) {
     var parameterType = parameter.Type;
     if (parameterType is Dummy) {
       //  Error...
       return;
     }
     ExpressionBase/*?*/ argument = this.ReadSerializedValue(parameterType);
     if (argument == null) {
       //  Error...
       this.decodeFailed = true;
       return;
     }
     exprList[i++] = argument;
   }
   IMetadataNamedArgument[]/*?*/ namedArgumentArray = null;
   if (2 <= (int)this.SignatureMemoryReader.RemainingBytes) {
     ushort numOfNamedArgs = this.SignatureMemoryReader.ReadUInt16();
     if (numOfNamedArgs > 0) {
       namedArgumentArray = new IMetadataNamedArgument[numOfNamedArgs];
       for (i = 0; i < numOfNamedArgs; ++i) {
         if (0 >= (int)this.SignatureMemoryReader.RemainingBytes) break;
         bool isField = this.SignatureMemoryReader.ReadByte() == SerializationType.Field;
         ITypeReference/*?*/ memberType = this.GetFieldOrPropType();
         if (memberType == null) {
           //  Error...
           return;
         }
         string/*?*/ memberStr = this.GetSerializedString();
         if (memberStr == null)
           return;
         IName memberName = this.PEFileToObjectModel.NameTable.GetNameFor(memberStr);
         ExpressionBase/*?*/ value = this.ReadSerializedValue(memberType);
         if (value == null) {
           //  Error...
           return;
         }
         ITypeReference/*?*/ moduleTypeRef = attributeConstructor.ContainingType;
         if (moduleTypeRef == null) {
           //  Error...
           return;
         }
         FieldOrPropertyNamedArgumentExpression namedArg = new FieldOrPropertyNamedArgumentExpression(memberName, moduleTypeRef, isField, memberType, value);
         namedArgumentArray[i] = namedArg;
       }
     }
   }
   this.CustomAttribute = peFileToObjectModel.ModuleReader.metadataReaderHost.Rewrite(peFileToObjectModel.Module,
     new CustomAttribute(peFileToObjectModel, customAttributeRowId, attributeConstructor, exprList, namedArgumentArray));
 }
 /// <summary>
 /// Provides the host with an opportunity to substitute a custom attribute with another during metadata reading.
 /// This avoids the cost of rewriting the entire unit in order to make such changes.
 /// </summary>
 /// <param name="referringUnit">The unit that contains the custom attribute.</param>
 /// <param name="customAttribute">The custom attribute to rewrite (fix up).</param>
 /// <returns>
 /// Usually the value in customAttribute, but occassionally another custom attribute.
 /// </returns>
 public override ICustomAttribute Rewrite(IUnit referringUnit, ICustomAttribute customAttribute) {
   CustomAttribute customAttr = customAttribute as CustomAttribute;
   if (customAttr == null) return customAttribute;
   var referringModule = referringUnit as IModule;
   if (referringModule == null || referringModule.ContainingAssembly == null || !(referringModule.ContainingAssembly.ContainsForeignTypes)) return customAttribute;
   if (!TypeHelper.TypesAreEquivalent(customAttribute.Type, this.PlatformType.SystemAttributeUsageAttribute)) return customAttribute;
   //The custom attribute constructor has been redirected from Windows.Foundation.AttributeUsageAttribute, which has a different
   //set of flags from System.AttributeUsageAttribute for its first and only constructor parameter and also does not have an AllowMultiple property. 
   var argArray = customAttr.Arguments;
   if (argArray == null || argArray.Length != 1) return customAttribute;
   var argConst = argArray[0] as ConstantExpression;
   if (argConst == null || !(argConst.value is int)) return customAttribute;
   int clrEnumValue = 0;
   switch ((int)argConst.Value) {
     case 0x00000001: clrEnumValue = 0x00001000; break;
     case 0x00000002: clrEnumValue = 0x00000010; break;
     case 0x00000004: clrEnumValue = 0x00000200; break;
     case 0x00000008: clrEnumValue = 0x00000100; break;
     case 0x00000010: clrEnumValue = 0x00000400; break;
     case 0x00000020: clrEnumValue = 0x00000000; break;
     case 0x00000040: clrEnumValue = 0x00000040; break;
     case 0x00000080: clrEnumValue = 0x00000800; break;
     case 0x00000100: clrEnumValue = 0x00000080; break;
     case 0x00000200: clrEnumValue = 0x00000004; break;
     case 0x00000400: clrEnumValue = 0x00000008; break;
     case 0x00000800: clrEnumValue = 0x00000000; break;
     case -1: clrEnumValue = 0x00007FFF; break;
   }
   argConst.value = clrEnumValue;
   if (this.FellowCustomAttributeIncludeAllowMultiple(customAttr)) {
     if (customAttr.NamedArguments != null) return customAttribute;
     var trueVal = new ConstantExpression(this.PlatformType.SystemBoolean, true);
     var namedArgArray = new IMetadataNamedArgument[1];
     namedArgArray[0] = new FieldOrPropertyNamedArgumentExpression(this.AllowMultiple, Dummy.Type, false, this.PlatformType.SystemBoolean, trueVal);
     customAttr.NamedArguments = namedArgArray;
   }
   return customAttribute;
 }