/// <summary>
/// Parses method annotations to fill up information
/// </summary>
/// <param name="readerState">Class reader state</param>
internal void Parse(ClassReaderState readerState)
{
Signature = (GetAttribute(PredefinedAttributeNames.Signature)?.ParsedAttribute as SignatureAttribute)?.Value;
{
var attribute = GetAttribute(PredefinedAttributeNames.Code);
if (attribute?.ParsedAttribute is CodeAttribute codeAttribute)
{
InstructionListConverter.ParseCodeAttribute(this, readerState, codeAttribute);
}
}
{
var attribute = GetAttribute(PredefinedAttributeNames.RuntimeInvisibleAnnotations);
if (attribute != null)
{
InvisibleAnnotations = (attribute.ParsedAttribute as RuntimeInvisibleAnnotationsAttribute)?.Annotations;
}
}
{
var attribute = GetAttribute(PredefinedAttributeNames.RuntimeVisibleAnnotations);
if (attribute != null)
{
VisibleAnnotations = (attribute.ParsedAttribute as RuntimeVisibleAnnotationsAttribute)?.Annotations;
}
}
{
var attribute = GetAttribute(PredefinedAttributeNames.Exceptions);
if (attribute != null)
{
Throws = (attribute.ParsedAttribute as ExceptionsAttribute)?.ExceptionTable;
}
}
AnnotationDefaultValue =
(GetAttribute(PredefinedAttributeNames.AnnotationDefault)?.ParsedAttribute as AnnotationDefaultAttribute)?.Value;
IsDeprecated = GetAttribute(PredefinedAttributeNames.Deprecated)?.ParsedAttribute != null;
}
internal void Read(Stream stream, ClassReaderState classReaderState)
{
var pathSize = stream.ReadByteFully();
Path.Capacity = pathSize;
for (var i = 0; i < pathSize; i++)
{
Path.Add(new PathPart
{
TypePathKind = (TypePathKind)stream.ReadByteFully(),
TypeArgumentIndex = stream.ReadByteFully()
});
}
}
internal static TypeAnnotationNode Parse(Stream stream, ClassReaderState readerState, AttributeScope scope)
{
var typeAnnotation = new TypeAnnotationNode
{
TargetType = (TargetType)stream.ReadByteFully()
};
typeAnnotation.Target = typeAnnotation.TargetType switch
{
TargetType.GenericClassOrInterfaceDeclaration when scope == AttributeScope.Class => (TypeAnnotationTarget) new TypeParameterTarget(),
TargetType.GenericMethodOrConstructorDeclaration when scope == AttributeScope.Method => new TypeParameterTarget(),
TargetType.ExtendsOrImplements when scope == AttributeScope.Class => new SupertypeTarget(),
TargetType.TypeInBoundInGenericClassOrInterface when scope == AttributeScope.Class => new TypeParameterBoundTarget(),
TargetType.TypeInBoundInGenericMethodOrConstructor when scope == AttributeScope.Method => new TypeParameterBoundTarget(),
TargetType.FieldDeclaration when scope == AttributeScope.Field => new EmptyTarget(),
TargetType.ReturnTypeOrNewObject when scope == AttributeScope.Method => new EmptyTarget(),
TargetType.ReceiverTypeOfMethodOrConstructor when scope == AttributeScope.Method => new EmptyTarget(),
TargetType.TypeInFormalParameterOfMethodOrConstructorOrLambda when scope == AttributeScope.Method => new FormalParameterTarget(),
TargetType.ThrowsClause when scope == AttributeScope.Method => new ThrowsTarget(),
TargetType.LocalVariableDeclaration when scope == AttributeScope.Code => new LocalvarTarget(),
TargetType.ResourceVariableDeclaration when scope == AttributeScope.Code => new LocalvarTarget(),
TargetType.ExceptionParameterDeclaration when scope == AttributeScope.Code => new CatchTarget(),
TargetType.InstanceOfExpression when scope == AttributeScope.Code => new OffsetTarget(),
TargetType.NewExpression when scope == AttributeScope.Code => new OffsetTarget(),
TargetType.MethodReferenceExpressionNew when scope == AttributeScope.Code => new OffsetTarget(),
TargetType.MethodReferenceExpressionIdentifier when scope == AttributeScope.Code => new OffsetTarget(),
TargetType.CastExpression when scope == AttributeScope.Code => new TypeArgumentTarget(),
TargetType.ArgumentForGenericConstructorInvocation when scope == AttributeScope.Code => new TypeArgumentTarget(),
TargetType.ArgumentForGenericMethodInvocation when scope == AttributeScope.Code => new TypeArgumentTarget(),
TargetType.ArgumentForGenericMethodReferenceExpressionNew when scope == AttributeScope.Code => new TypeArgumentTarget(),
TargetType.ArgumentForGenericMethodReferenceExpressionIdentifier when scope == AttributeScope.Code => new TypeArgumentTarget(),
_ => throw new ArgumentOutOfRangeException(nameof(TargetType))
};
typeAnnotation.Target.Read(stream, readerState);
typeAnnotation.TypePath = new TypePath();
typeAnnotation.TypePath.Read(stream, readerState);
var elementValuePairsCount = Binary.BigEndian.ReadUInt16(stream);
typeAnnotation.ElementValuePairs.Capacity = elementValuePairsCount;
for (var i = 0; i < elementValuePairsCount; i++)
{
typeAnnotation.ElementValuePairs.Add(new ElementValuePair
{
ElementName = readerState.ConstantPool
.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(stream)).String,
Value = ElementValue.Parse(stream, readerState)
});
}
return(typeAnnotation);
}
internal override void Read(Stream stream, ClassReaderState readerState)
{
var tableSize = Binary.BigEndian.ReadUInt16(stream);
Table.Capacity = tableSize;
for (var i = 0; i < tableSize; i++)
{
Table.Add(new TableEntry
{
StartPc = Binary.BigEndian.ReadUInt16(stream),
Length = Binary.BigEndian.ReadUInt16(stream),
Index = Binary.BigEndian.ReadUInt16(stream)
});
}
}
internal static AnnotationNode Parse(Stream stream, ClassReaderState readerState)
{
var annotation = new AnnotationNode
{
Type = TypeDescriptor.Parse(readerState.ConstantPool
.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(stream)).String)
};
var elementValuePairsCount = Binary.BigEndian.ReadUInt16(stream);
annotation.ElementValuePairs.Capacity = elementValuePairsCount;
for (var i = 0; i < elementValuePairsCount; i++)
{
annotation.ElementValuePairs.Add(new ElementValuePair
{
ElementName = readerState.ConstantPool
.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(stream)).String,
Value = ElementValue.Parse(stream, readerState)
});
}
return(annotation);
}
internal void Parse(ClassReaderState readerState)
{
SourceFile = (GetAttribute(PredefinedAttributeNames.SourceFile)?.ParsedAttribute as SourceFileAttribute)?.Value;
SourceDebugExtension = (GetAttribute(PredefinedAttributeNames.SourceDebugExtension)?.ParsedAttribute as SourceFileAttribute)?.Value;
Signature = (GetAttribute(PredefinedAttributeNames.Signature)?.ParsedAttribute as SignatureAttribute)?.Value;
{
var attribute = GetAttribute(PredefinedAttributeNames.RuntimeInvisibleAnnotations);
if (attribute != null)
{
InvisibleAnnotations = (attribute.ParsedAttribute as RuntimeInvisibleAnnotationsAttribute)?.Annotations;
}
}
{
var attribute = GetAttribute(PredefinedAttributeNames.RuntimeVisibleAnnotations);
if (attribute != null)
{
VisibleAnnotations = (attribute.ParsedAttribute as RuntimeVisibleAnnotationsAttribute)?.Annotations;
}
}
IsDeprecated = GetAttribute(PredefinedAttributeNames.Deprecated)?.ParsedAttribute != null;
EnclosingMethod = GetAttribute(PredefinedAttributeNames.EnclosingMethod)?.ParsedAttribute as EnclosingMethodAttribute;
{
var attribute = GetAttribute(PredefinedAttributeNames.InnerClasses);
if (attribute != null)
{
InnerClasses = (attribute.ParsedAttribute as InnerClassesAttribute)?.Classes;
}
}
foreach (var method in Methods)
{
method.Parse(readerState);
}
foreach (var field in Fields)
{
field.Parse(readerState);
}
}
/// <summary>
/// Parses field annotations to fill up information
/// </summary>
/// <param name="readerState">Class reader state</param>
internal void Parse(ClassReaderState readerState)
{
Signature = (GetAttribute(PredefinedAttributeNames.Signature)?.ParsedAttribute as SignatureAttribute)?.Value;
{
var attribute = GetAttribute(PredefinedAttributeNames.RuntimeInvisibleAnnotations);
if (attribute != null)
{
InvisibleAnnotations = (attribute.ParsedAttribute as RuntimeInvisibleAnnotationsAttribute)?.Annotations;
}
}
{
var attribute = GetAttribute(PredefinedAttributeNames.RuntimeVisibleAnnotations);
if (attribute != null)
{
VisibleAnnotations = (attribute.ParsedAttribute as RuntimeVisibleAnnotationsAttribute)?.Annotations;
}
}
ConstantValue =
(GetAttribute(PredefinedAttributeNames.ConstantValue)?.ParsedAttribute as
ConstantValueAttribute)?.Value;
IsDeprecated = GetAttribute(PredefinedAttributeNames.Deprecated)?.ParsedAttribute != null;
}
internal override void Read(Stream stream, ClassReaderState readerState)
{
}
public SignatureAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
return(new SignatureAttribute
{
Value = readerState.ConstantPool.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(attributeDataStream)).String
});
}
public EnclosingMethodAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
var attribute = new EnclosingMethodAttribute
{
Class = new ClassName(readerState.ConstantPool
.GetEntry <ClassEntry>(Binary.BigEndian.ReadUInt16(attributeDataStream)).Name.String)
};
var nameAndTypeEntryIndex = Binary.BigEndian.ReadUInt16(attributeDataStream);
if (nameAndTypeEntryIndex == 0)
{
return(attribute);
}
var nameAndTypeEntry = readerState.ConstantPool.GetEntry <NameAndTypeEntry>(nameAndTypeEntryIndex);
attribute.MethodName = nameAndTypeEntry.Name.String;
attribute.MethodDescriptor = MethodDescriptor.Parse(nameAndTypeEntry.Descriptor.String);
return(attribute);
}
internal override void Read(Stream stream, ClassReaderState readerState)
{
Offset = Binary.BigEndian.ReadUInt16(stream);
}
public SourceDebugExtensionAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
return(new SourceDebugExtensionAttribute
{
Value = ModifiedUtf8Helper.Decode(attributeDataStream.ReadBytes(attributeDataLength))
});
}
public AnnotationDefaultAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
return(new AnnotationDefaultAttribute
{
Value = ElementValue.Parse(attributeDataStream, readerState)
});
}
internal override void Read(Stream stream, ClassReaderState readerState)
{
ExceptionTableIndex = Binary.BigEndian.ReadUInt16(stream);
}
public CodeAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
var maxStack = Binary.BigEndian.ReadUInt16(attributeDataStream);
var maxLocals = Binary.BigEndian.ReadUInt16(attributeDataStream);
var code = new byte[Binary.BigEndian.ReadUInt32(attributeDataStream)];
attributeDataStream.Read(code);
var attribute = new CodeAttribute
{
MaxStack = maxStack,
MaxLocals = maxLocals,
Code = code
};
var exceptionTableSize = Binary.BigEndian.ReadUInt16(attributeDataStream);
attribute.ExceptionTable.Capacity = exceptionTableSize;
for (var i = 0; i < exceptionTableSize; i++)
{
var exceptionTableEntry = new CodeAttribute.ExceptionTableEntry
{
StartPc = Binary.BigEndian.ReadUInt16(attributeDataStream),
EndPc = Binary.BigEndian.ReadUInt16(attributeDataStream),
HandlerPc = Binary.BigEndian.ReadUInt16(attributeDataStream)
};
var catchTypeIndex = Binary.BigEndian.ReadUInt16(attributeDataStream);
if (catchTypeIndex != 0)
{
exceptionTableEntry.CatchType = new ClassName(readerState.ConstantPool
.GetEntry <ClassEntry>(catchTypeIndex)
.Name.String);
}
attribute.ExceptionTable.Add(exceptionTableEntry);
}
var attributesCount = Binary.BigEndian.ReadUInt16(attributeDataStream);
attribute.Attributes.Capacity = attributesCount;
for (var i = 0; i < attributesCount; i++)
{
attribute.Attributes.Add(ClassFile.ParseAttribute(attributeDataStream, readerState, AttributeScope.Code));
}
return(attribute);
}
public LocalVariableTypeTableAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
var attribute = new LocalVariableTypeTableAttribute();
var localVariableTypeTableSize = Binary.BigEndian.ReadUInt16(attributeDataStream);
attribute.LocalVariableTypeTable.Capacity = localVariableTypeTableSize;
for (var i = 0; i < localVariableTypeTableSize; i++)
{
attribute.LocalVariableTypeTable.Add(new LocalVariableTypeTableAttribute.LocalVariableTypeTableEntry
{
StartPc = Binary.BigEndian.ReadUInt16(attributeDataStream),
Length = Binary.BigEndian.ReadUInt16(attributeDataStream),
Name = readerState.ConstantPool.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(attributeDataStream)).String,
Signature = readerState.ConstantPool.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(attributeDataStream)).String,
Index = Binary.BigEndian.ReadUInt16(attributeDataStream)
});
}
return(attribute);
}
public SyntheticAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope) => new SyntheticAttribute();
internal override void Read(Stream stream, ClassReaderState readerState)
{
SupertypeIndex = Binary.BigEndian.ReadUInt16(stream);
}
public MethodParametersAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
var attribute = new MethodParametersAttribute();
var exceptionTableSize = attributeDataStream.ReadByteFully();
attribute.Parameters.Capacity = exceptionTableSize;
for (var i = 0; i < exceptionTableSize; i++)
{
attribute.Parameters.Add(new MethodParametersAttribute.Parameter
{
Name = readerState.ConstantPool.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(attributeDataStream)).String,
Access = (ClassAccessModifiers)Binary.BigEndian.ReadUInt16(attributeDataStream)
});
}
return(attribute);
}
public ExceptionsAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
var attribute = new ExceptionsAttribute();
var count = Binary.BigEndian.ReadUInt16(attributeDataStream);
attribute.ExceptionTable.Capacity = count;
for (var i = 0; i < count; i++)
{
attribute.ExceptionTable.Add(new ClassName(readerState.ConstantPool
.GetEntry <ClassEntry>(Binary.BigEndian.ReadUInt16(attributeDataStream)).Name.String));
}
return(attribute);
}
public LineNumberTableAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
var attribute = new LineNumberTableAttribute();
var exceptionTableSize = Binary.BigEndian.ReadUInt16(attributeDataStream);
attribute.LineNumberTable.Capacity = exceptionTableSize;
for (var i = 0; i < exceptionTableSize; i++)
{
attribute.LineNumberTable.Add(new LineNumberTableAttribute.LineNumberTableEntry
{
StartPc = Binary.BigEndian.ReadUInt16(attributeDataStream),
LineNumber = Binary.BigEndian.ReadUInt16(attributeDataStream)
});
}
return(attribute);
}
public DeprecatedAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope) => new DeprecatedAttribute();
public RuntimeVisibleParameterAnnotationsAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
var attribute = new RuntimeVisibleParameterAnnotationsAttribute();
var parametersCount = attributeDataStream.ReadByteFully();
attribute.Parameters.Capacity = parametersCount;
for (var i = 0; i < parametersCount; i++)
{
var parameter = new ParameterAnnotations();
var annotationsCount = Binary.BigEndian.ReadUInt16(attributeDataStream);
parameter.Annotations.Capacity = annotationsCount;
for (var j = 0; j < annotationsCount; j++)
{
parameter.Annotations.Add(AnnotationNode.Parse(attributeDataStream, readerState));
}
attribute.Parameters.Add(parameter);
}
return(attribute);
}
internal override void Read(Stream stream, ClassReaderState readerState)
{
Offset = Binary.BigEndian.ReadUInt16(stream);
TypeArgumentIndex = stream.ReadByteFully();
}
private static StackMapTableAttribute.VerificationElement ReadVerificationElement(Stream stream, ClassReaderState readerState)
{
var verificationElementType = (StackMapTableAttribute.VerificationElementType)stream.ReadByteFully();
return(verificationElementType switch
{
StackMapTableAttribute.VerificationElementType.Top => (StackMapTableAttribute.VerificationElement) new StackMapTableAttribute.SimpleVerificationElement(verificationElementType),
StackMapTableAttribute.VerificationElementType.Integer => new StackMapTableAttribute.SimpleVerificationElement(verificationElementType),
StackMapTableAttribute.VerificationElementType.Float => new StackMapTableAttribute.SimpleVerificationElement(verificationElementType),
StackMapTableAttribute.VerificationElementType.Long => new StackMapTableAttribute.SimpleVerificationElement(verificationElementType),
StackMapTableAttribute.VerificationElementType.Double => new StackMapTableAttribute.SimpleVerificationElement(verificationElementType),
StackMapTableAttribute.VerificationElementType.Null => new StackMapTableAttribute.SimpleVerificationElement(verificationElementType),
StackMapTableAttribute.VerificationElementType.UnitializedThis => new StackMapTableAttribute.SimpleVerificationElement(verificationElementType),
StackMapTableAttribute.VerificationElementType.Object => new StackMapTableAttribute.ObjectVerificationElement
{
ObjectClass = new ClassName(readerState.ConstantPool
.GetEntry <ClassEntry>(Binary.BigEndian.ReadUInt16(stream))
.Name.String)
},
StackMapTableAttribute.VerificationElementType.Unitialized => new StackMapTableAttribute.UninitializedVerificationElement
{
NewInstructionOffset = Binary.BigEndian.ReadUInt16(stream)
},
_ => throw new ArgumentOutOfRangeException(nameof(verificationElementType))
});
public InnerClassesAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
var attribute = new InnerClassesAttribute();
var classesCount = Binary.BigEndian.ReadUInt16(attributeDataStream);
attribute.Classes.Capacity = classesCount;
for (var i = 0; i < classesCount; i++)
{
var innerClass = new InnerClass
{
InnerClassName = new ClassName(readerState.ConstantPool
.GetEntry <ClassEntry>(Binary.BigEndian.ReadUInt16(attributeDataStream)).Name.String)
};
var outerClassIndex = Binary.BigEndian.ReadUInt16(attributeDataStream);
if (outerClassIndex != 0)
{
innerClass.OuterClassName = new ClassName(readerState.ConstantPool
.GetEntry <ClassEntry>(outerClassIndex).Name.String);
}
var innerNameIndex = Binary.BigEndian.ReadUInt16(attributeDataStream);
if (innerNameIndex != 0)
{
innerClass.InnerName = readerState.ConstantPool
.GetEntry <Utf8Entry>(innerNameIndex).String;
}
innerClass.Access = (ClassAccessModifiers)Binary.BigEndian.ReadUInt16(attributeDataStream);
attribute.Classes.Add(innerClass);
}
return(attribute);
}
internal override void Read(Stream stream, ClassReaderState readerState)
{
TypeParameterIndex = stream.ReadByteFully();
}
internal static ElementValue Parse(Stream stream, ClassReaderState readerState)
{
var elementValue = new ElementValue
{
Tag = (ElementValueTag)stream.ReadByteFully()
};
switch (elementValue.Tag)
{
case ElementValueTag.Byte:
case ElementValueTag.Character:
case ElementValueTag.Integer:
case ElementValueTag.Short:
case ElementValueTag.Boolean:
elementValue.ConstValue = readerState.ConstantPool.GetEntry <IntegerEntry>(Binary.BigEndian.ReadUInt16(stream)).Value;
break;
case ElementValueTag.Double:
elementValue.ConstValue = readerState.ConstantPool.GetEntry <DoubleEntry>(Binary.BigEndian.ReadUInt16(stream)).Value;
break;
case ElementValueTag.Float:
elementValue.ConstValue = readerState.ConstantPool.GetEntry <FloatEntry>(Binary.BigEndian.ReadUInt16(stream)).Value;
break;
case ElementValueTag.Long:
elementValue.ConstValue = readerState.ConstantPool.GetEntry <LongEntry>(Binary.BigEndian.ReadUInt16(stream)).Value;
break;
case ElementValueTag.String:
elementValue.ConstValue = readerState.ConstantPool.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(stream)).String;
break;
case ElementValueTag.Enum:
elementValue.EnumConstValue = new EnumConstValueType
{
TypeName = TypeDescriptor.Parse(readerState.ConstantPool
.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(stream)).String),
ConstName = readerState.ConstantPool.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(stream))
.String
};
break;
case ElementValueTag.Class:
elementValue.Class = TypeDescriptor.Parse(readerState.ConstantPool
.GetEntry <Utf8Entry>(Binary.BigEndian.ReadUInt16(stream)).String, true);
break;
case ElementValueTag.Annotation:
elementValue.AnnotationNode = AnnotationNode.Parse(stream, readerState);
break;
case ElementValueTag.Array:
var arraySize = Binary.BigEndian.ReadUInt16(stream);
elementValue.ArrayValue = new List <ElementValue>(arraySize);
for (var i = 0; i < arraySize; i++)
{
elementValue.ArrayValue.Add(Parse(stream, readerState));
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(elementValue.Tag));
}
return(elementValue);
}
public RuntimeVisibleTypeAnnotationsAttribute Parse(Stream attributeDataStream, uint attributeDataLength, ClassReaderState readerState, AttributeScope scope)
{
var attribute = new RuntimeVisibleTypeAnnotationsAttribute();
var annotationsCount = Binary.BigEndian.ReadUInt16(attributeDataStream);
attribute.Annotations.Capacity = annotationsCount;
for (var i = 0; i < annotationsCount; i++)
{
attribute.Annotations.Add(TypeAnnotationNode.Parse(attributeDataStream, readerState, scope));
}
return(attribute);
}
internal abstract void Read(Stream stream, ClassReaderState readerState);