/// <summary>
/// Mark all base types and externally visible members reachable
/// </summary>
private static void Walk(ReachableContext context, TypeReference type)
{
if (type == null)
return;
if (type.IsArray)
{
var aType = (ArrayTypeReference)type;
Walk(context, aType.ElementType);
}
else if (type.IsObjectType)
{
var oType = (ObjectTypeReference)type;
foreach (var typeArg in oType.Arguments)
{
Walk(context, typeArg.Signature);
}
ClassFile classFile;
if (context.TryLoadClass(oType.ClassName, out classFile))
{
classFile.MarkReachable(context);
}
}
else if (type.IsBaseType || type.IsVoid || type.IsTypeVariable)
{
// Not need to mark anything
}
else
{
throw new ArgumentException("Unknown type: " + type);
}
}
/// <summary>
/// Default ctor
/// </summary>
public TypeArgument(TypeArgumentWildcard wildcard, TypeReference signature)
{
if (signature == null)
throw new ArgumentNullException("signature");
this.wildcard = wildcard;
this.signature = signature;
}
internal ExceptionHandler(CodeAttribute code, int startPc, int endPc, int handlerPc, TypeReference catchType)
{
this.code = code;
startPC = startPc;
endPC = endPc;
handlerPC = handlerPc;
this.catchType = catchType;
}
public FieldDefinition(ClassFile cf, FieldAccessFlags accessFlags, string name, string descriptor, string signature)
: base(cf, name)
{
this.accessFlags = accessFlags;
this.descriptor = descriptor;
fieldType = Descriptors.ParseFieldType(descriptor);
Signature = (signature != null) ? Signatures.ParseFieldTypeSignature(signature) : fieldType;
}
public ClassSignature(string original, IEnumerable<TypeParameter> typeParameters, TypeReference superClass, IEnumerable<TypeReference> interfaces)
{
this.typeParameters = (typeParameters != null)
? typeParameters.ToList().AsReadOnly()
: new ReadOnlyCollection<TypeParameter>(new List<TypeParameter>());
this.original = original;
this.superClass = superClass;
this.interfaces = interfaces.ToList().AsReadOnly();
}
public MethodSignature(string original, IEnumerable<TypeParameter> typeParameters, TypeReference returnType,
IEnumerable<TypeReference> parameters, IEnumerable<TypeReference> throws)
: base(returnType, parameters)
{
this.original = original;
typeParameters = typeParameters ?? Enumerable.Empty<TypeParameter>();
this.typeParameters = typeParameters.ToList().AsReadOnly();
throws = throws ?? Enumerable.Empty<TypeReference>();
this.throws = throws.ToList().AsReadOnly();
}
/// <summary>
/// Default ctor
/// </summary>
public JavaParameter(XModule module, string name, TypeReference type)
: base(name)
{
this.module = module;
this.type = type;
}
/// <summary>
/// Default ctor
/// </summary>
internal MethodDescriptor(TypeReference returnType, IEnumerable<TypeReference> parameters)
{
this.returnType = returnType;
this.parameters = parameters.ToList().AsReadOnly();
}
/// <summary>
/// Default ctor
/// </summary>
public TypeParameter(string name, TypeReference classBound, IEnumerable<TypeReference> interfaceBound)
{
this.name = name;
this.classBound = classBound;
this.interfaceBound = (interfaceBound != null) ? interfaceBound.ToList() : new List<TypeReference>();
}
/// <summary>
/// Convert an Java method reference to an XMethodReference.
/// </summary>
public static XMethodReference AsMethodReference(XModule module, string methodName, string descriptor, TypeReference classNameAsType, string className, bool hasThis)
{
var declaringType = AsTypeReference(module, classNameAsType, XTypeUsageFlags.DeclaringType);
return AsMethodReference(module, methodName, descriptor, declaringType, className, hasThis);
}
/// <summary>
/// Convert an Java type reference to an XTypeReference.
/// </summary>
public static XTypeReference AsTypeReference(XModule module, TypeReference type, XTypeUsageFlags usageFlags)
{
if (type.IsArray)
{
var arrayType = (ArrayTypeReference)type;
return new XArrayType(AsTypeReference(module, arrayType.ElementType, usageFlags));
}
if (type.IsBaseType)
{
var baseType = (BaseTypeReference)type;
var ts = module.TypeSystem;
switch (baseType.Type)
{
case BaseTypes.Boolean:
return ts.Bool;
case BaseTypes.Byte:
return ts.SByte;
case BaseTypes.Char:
return ts.Char;
case BaseTypes.Short:
return ts.Short;
case BaseTypes.Int:
return ts.Int;
case BaseTypes.Long:
return ts.Long;
case BaseTypes.Float:
return ts.Float;
case BaseTypes.Double:
return ts.Double;
}
throw new NotImplementedException("Unknown base type " + (int)baseType.Type);
}
if (type.IsVoid)
{
return module.TypeSystem.Void;
}
if (type.IsTypeVariable)
{
throw new NotImplementedException("Unknown type " + type);
}
{
var objectType = (ObjectTypeReference) type;
if ((usageFlags != XTypeUsageFlags.DeclaringType) && (usageFlags != XTypeUsageFlags.BaseType))
{
switch (objectType.ClassName)
{
case "java/lang/Boolean":
return CreateNullableT(module, module.TypeSystem.Bool);
case "java/lang/Byte":
return CreateNullableT(module, module.TypeSystem.Byte);
case "java/lang/Character":
return CreateNullableT(module, module.TypeSystem.Char);
case "java/lang/Short":
return CreateNullableT(module, module.TypeSystem.Short);
case "java/lang/Integer":
return CreateNullableT(module, module.TypeSystem.Int);
case "java/lang/Long":
return CreateNullableT(module, module.TypeSystem.Long);
case "java/lang/Float":
return CreateNullableT(module, module.TypeSystem.Float);
case "java/lang/Double":
return CreateNullableT(module, module.TypeSystem.Double);
}
}
var typeRef = new JavaTypeReference(module, objectType, objectType.ClassName);
return typeRef;
}
}
/// <summary>
/// Convert an Java field reference to an XFieldReference.
/// </summary>
public static XFieldReference AsFieldReference(XModule module, string fieldName, string descriptor, TypeReference classNameAsType, string className)
{
var declaringType = AsTypeReference(module, classNameAsType, XTypeUsageFlags.DeclaringType);
return AsFieldReference(module, fieldName, descriptor, declaringType, className);
}
/// <summary>
/// Default ctor
/// </summary>
public ArrayTypeReference(TypeReference elementType)
{
this.elementType = elementType;
}
/// <summary>
/// Signals that all attributes have been loaded.
/// </summary>
void IModifiableAttributeProvider.AttributesLoaded()
{
var signatureAttributes = Attributes.OfType<SignatureAttribute>();
Signature = signatureAttributes.Select(x => Signatures.ParseFieldTypeSignature(x.Value)).SingleOrDefault() ?? fieldType;
}
