public ClassFile(Stream stream)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
uint magic;
if (!IsClassFile(stream, out magic))
{
throw new BadImageFormatException("Stream doesn't start with valid 0xCAFEBABE header! Found: 0x" + magic.ToString("x"));
}
MinorVersion = stream.ReadNetworkUInt16();
MajorVersion = stream.ReadNetworkUInt16();
ConstantPool = new ConstantPool(stream);
AccessFlags = (ClassAccessFlags)stream.ReadNetworkUInt16();
thisClass = stream.ReadNetworkUInt16();
superClass = stream.ReadNetworkUInt16();
Interfaces = new Interfaces(ConstantPool, stream);
Fields = new Fields(ConstantPool, stream);
Methods = new Methods(ConstantPool, this, stream);
Attributes = new AttributeCollection(ConstantPool, stream);
int e = stream.ReadByte();
if (e >= 0)
{
throw new BadImageFormatException("Stream has trailing data?!");
}
}
static ClassAccessFlags SetPackagePrivate(ClassAccessFlags flags)
{
// Package-private is stored as "no visibility flags"
flags = (flags ^ ClassAccessFlags.Public) & flags;
flags = (flags ^ ClassAccessFlags.Protected) & flags;
flags = (flags ^ ClassAccessFlags.Private) & flags;
return(flags);
}
static string GetClassVisibility (ClassAccessFlags accessFlags)
{
if ((accessFlags & ClassAccessFlags.Public) != 0)
return "public";
if ((accessFlags & ClassAccessFlags.Protected) != 0)
return "protected";
if ((accessFlags & ClassAccessFlags.Private) != 0)
return "private";
return "";
}
/// <summary>
/// Creates a new <see cref="InnerClassInfo"/>.
/// </summary>
/// <param name="innerClassIndex">The index into the <see cref="ConstantPool"/> representing the inner class.</param>
/// <param name="outerClassIndex">The index into the <see cref="ConstantPool"/> representing the outer class.</param>
/// <param name="innerNameIndex">The index into the <see cref="ConstantPool"/> representing the name of the inner class.</param>
/// <param name="innerAccessFlags">The <see cref="ClassAccessFlags"/> of the inner class.</param>
public InnerClassInfo(
ushort innerClassIndex,
ushort outerClassIndex,
ushort innerNameIndex,
ClassAccessFlags innerAccessFlags)
{
InnerClassIndex = innerClassIndex;
OuterClassIndex = outerClassIndex;
InnerNameIndex = innerNameIndex;
InnerAccessFlags = innerAccessFlags;
}
public void PersistentAccessFlags()
{
const ClassAccessFlags flags = ClassAccessFlags.Public | ClassAccessFlags.Enum;
var dummyImage = CreateDummyImage();
dummyImage.RootClass.AccessFlags = flags;
var newImage = Utils.RebuildClassImage(dummyImage);
Assert.Equal(flags, newImage.RootClass.AccessFlags);
}
public LibraryClass(string name, ClassAccessFlags accessFlags, string superName) : base()
{
base.Name = name;
base.Super = superName;
base.AccessFlags = accessFlags;
base.Version = VersionInfo.Java70;
base.ConstantPool = ClassDefaults.EmptyConstantPool;
base.Interfaces = ClassDefaults.EmptyInterfaces;
base.Attributes = ClassDefaults.EmptyAttributes;
}
public JavaClass(VersionInfo version, ConstantPoolItemBase[] constantPool,
ClassAccessFlags accessFlags, string name, string super,
string[] interfaces)
: this()
{
this.Version = version;
this.ConstantPool = constantPool;
this.AccessFlags = accessFlags;
this.Name = name;
this.Super = super;
this.Interfaces = interfaces;
}
private string AccessFlagsAsString(ClassAccessFlags accessFlags)
{
string result = accessFlags.HasFlag(ClassAccessFlags.Public) ? "public " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Final) ? "final " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Super) ? "super " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Interface) ? "interface " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Abstract) ? "abstract " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Synthetic) ? "synthetic " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Annotation) ? "annotation " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Enum) ? "enum " : string.Empty;
return result.Trim();
}
private string AccessFlagsAsString(ClassAccessFlags accessFlags)
{
string result = accessFlags.HasFlag(ClassAccessFlags.Public) ? "public " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Final) ? "final " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Super) ? "super " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Interface) ? "interface " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Abstract) ? "abstract " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Synthetic) ? "synthetic " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Annotation) ? "annotation " : string.Empty;
result += accessFlags.HasFlag(ClassAccessFlags.Enum) ? "enum " : string.Empty;
return(result.Trim());
}
static string GetClassVisibility(ClassAccessFlags accessFlags)
{
if ((accessFlags & ClassAccessFlags.Public) != 0)
{
return("public");
}
if ((accessFlags & ClassAccessFlags.Protected) != 0)
{
return("protected");
}
if ((accessFlags & ClassAccessFlags.Private) != 0)
{
return("private");
}
return("");
}
// Passing null for 'newVisibility' parameter means 'package-private'
static ClassAccessFlags SetVisibility(ClassAccessFlags existing, ClassAccessFlags?newVisibility)
{
// First we need to remove any existing visibility flags,
// without modifying other flags like Abstract
existing = (existing ^ ClassAccessFlags.Public) & existing;
existing = (existing ^ ClassAccessFlags.Protected) & existing;
existing = (existing ^ ClassAccessFlags.Private) & existing;
// Package-private is stored as "no visibility flags", so only add flag if specified
if (newVisibility.HasValue)
{
existing |= newVisibility.Value;
}
return(existing);
}
/// <summary>
/// Creates a new <see cref="ClassFileBody"/>.
/// </summary>
/// <param name="accessFlags">The <see cref="ClassAccessFlags"/>.</param>
/// <param name="thisClass">The index into the <see cref="ConstantPool"/> describing this class.</param>
/// <param name="superClass">The index into the <see cref="ConstantPool"/> describing the superclass.</param>
public ClassFileBody(ClassAccessFlags accessFlags, ushort thisClass, ushort superClass)
{
AccessFlags = accessFlags;
ThisClass = thisClass;
SuperClass = superClass;
}
public static bool IsPubliclyVisible(this ClassAccessFlags flags) => flags.HasFlag(ClassAccessFlags.Public) || flags.HasFlag(ClassAccessFlags.Protected);
/// <summary>
/// Parse .class files using BigEndianBinaryReader.
/// </summary>
/// <param name="name">Class name</param>
/// <param name="parent">The package that contains this class</param>
/// <param name="reader">The reader to get binary data</param>
public ClassFile(string name, JavaPackage parent, BigEndianBinaryReader reader) : base(parent, name, JavaPackageElementTypes.Class)
{
if (reader.ReadUInt32() != Magic)
{
throw new FormatException();
}
MinorVersion = reader.ReadUInt16();
MajorVersion = reader.ReadUInt16();
ConstantPoolCount = reader.ReadUInt16();
Constants = new ConstantInfoBase[ConstantPoolCount];
for (int i = 1; i < ConstantPoolCount; i++)
{
ConstantType tagByte = (ConstantType)reader.ReadByte();
switch (tagByte)
{
case ConstantType.Class:
Constants[i] = new ConstantClassInfo(this, reader);
break;
case ConstantType.Fieldref:
Constants[i] = new ConstantFieldrefInfo(this, reader);
break;
case ConstantType.Methodref:
Constants[i] = new ConstantMethodrefInfo(this, reader);
break;
case ConstantType.InterfaceMethodref:
Constants[i] = new ConstantInterfaceMethodrefInfo(this, reader);
break;
case ConstantType.String:
Constants[i] = new ConstantStringInfo(this, reader);
break;
case ConstantType.Integer:
Constants[i] = new ConstantIntegerInfo(this, reader);
break;
case ConstantType.Float:
Constants[i] = new ConstantFloatInfo(this, reader);
break;
case ConstantType.Long:
Constants[i++] = new ConstantLongInfo(this, reader);
break;
case ConstantType.Double:
Constants[i++] = new ConstantDoubleInfo(this, reader);
break;
case ConstantType.NameAndType:
Constants[i] = new ConstantNameAndTypeInfo(this, reader);
break;
case ConstantType.MethodHandle:
Constants[i] = new ConstantMethodHandleInfo(this, reader);
break;
case ConstantType.MethodType:
Constants[i] = new ConstantMethodType(this, reader);
break;
case ConstantType.InvokeDynamic:
Constants[i] = new ConstantInvokeDynamicInfo(this, reader);
break;
case ConstantType.Utf8:
Constants[i] = new ConstantUtf8Info(this, reader);
break;
default:
throw new InvalidOperationException("Unknown Constant Pool Type");
}
}
ClassAccessFlag = (ClassAccessFlags)reader.ReadUInt16();
ThisClassIndex = reader.ReadUInt16();
SuperClassIndex = reader.ReadUInt16();
InterfacesCount = reader.ReadUInt16();
InterfacesIndexes = new ushort[InterfacesCount];
for (int i = 0; i < InterfacesCount; i++)
{
InterfacesIndexes[i] = reader.ReadUInt16();
}
Interfaces = new ConstantsArray <ConstantClassInfo>(this, InterfacesIndexes);
FieldsInfoCount = reader.ReadUInt16();
Fields = new FieldInfo[FieldsInfoCount];
for (int i = 0; i < FieldsInfoCount; i++)
{
Fields[i] = new FieldInfo(this, reader);
}
MethodsInfoCount = reader.ReadUInt16();
Methods = new MethodInfo[MethodsInfoCount];
for (int i = 0; i < MethodsInfoCount; i++)
{
Methods[i] = new MethodInfo(this, reader);
}
AttributesCount = reader.ReadUInt16();
Attributes = new AttributeInfo[AttributesCount];
for (int i = 0; i < AttributesCount; i++)
{
Attributes[i] = AttributeInfo.GetAttributeInfo(AttributeTarget.ClassFile, this, reader);
}
}
public static ClassFile CreateClassFile(ushort minorVersion, ushort majorVersion, ClassAccessFlags accessFlags,
ushort thisClass, List <ConstantPoolDescription> constantPool, List <MethodInfo> methods)
{
var res = new ClassFile();
res.MinorVersion = minorVersion;
res.MajorVersion = majorVersion;
res.ConstantPool = CalcConstantPool(constantPool);
res.ConstantPoolCount = (ushort)(res.ConstantPool.Length + 1);
res.AccessFlags = (ushort)accessFlags;
res.ThisClass = thisClass;
res.MethodsCount = (ushort)methods.Count;
res.Methods = methods.ToArray();
return(res);
}
