/// <summary>
/// Create a name for a parameter of the given type.
/// </summary>
private string CreateParameterName(NetTypeReference parameterType, DocParameter doc, TargetFramework target)
{
if ((doc != null) && (!string.IsNullOrEmpty(doc.Name)))
{
return(doc.Name);
}
target.ReportMissingParameterName(javaMethod.DeclaringClass.ClassName);
var name = parameterType.Name;
var elementType = parameterType.GetElementType();
if (elementType != null)
{
name = elementType.Name.Replace('.', '_');
}
if (name == null)
{
name = "p";
}
if ((name.StartsWith("I")) && (name.Length > 1) && (elementType != null) && (elementType.IsInterface))
{
name = name.Substring(1);
}
name = name.Substring(0, 1).ToLower() + name.Substring(1);
return(name);
}
/// <summary>
/// Make sure that the visibility of the given member is limited by the visibility of the given type is that is in another scope.
/// </summary>
/// <returns>True if member has changed</returns>
public static bool LimitVisibility(this INetMemberVisibility member, NetTypeReference type)
{
if (type == null)
{
return(false);
}
return(type.Accept(LimitVisibilityTypeVisitor.Instance, member));
}
/// <summary>
/// Make sure that the visibility of the given type definition is high enough to be used in the signature of the given member.
/// </summary>
/// <returns>True if type has changed</returns>
public static bool EnsureVisibility(this NetTypeReference type, INetMemberVisibility member)
{
if (type == null)
{
return(false);
}
return(type.Accept(EnsureVisibilityTypeVisitor.Instance, member));
}
/// <summary>
/// Default ctor
/// </summary>
public NetParameterDefinition(string name, NetTypeReference type, bool isParams)
{
if (type.IsVoid())
throw new ArgumentException("type cannot be void");
this.name = Keywords.IsKeyword(name) ? "@" + name : name;
this.type = type;
this.isParams = isParams;
if (isParams && !(type is NetArrayType))
{
throw new ArgumentException("Params parameter must have array type");
}
}
/// <summary>
/// Do type1 and type2 refer to the same type?
/// </summary>
/// <remarks>
/// The types are also the same, if the Generic Parameters have a different name.
/// MyClass<T> is the same as MyClass<U>.
/// So we need to do some special processing to check this.
/// </remarks>
internal static bool AreSame(this NetTypeReference type1, NetTypeReference type2)
{
if ((type1 == null) && (type2 == null))
return true;
if ((type1 == null) || (type2 == null))
return false;
string fullName1 = type1.FullName;
string fullName2 = type2.FullName;
return AreSameGenericParameters(fullName1, fullName2, false);
}
/// <summary>
/// Does the given type is an unsigned byte or references on in its
/// elements types or generic types?
/// </summary>
internal static bool ContainsUnsignedByte(this NetTypeReference type)
{
if (type == null)
{
return(false);
}
if (type.IsByte())
{
return(true);
}
return(type.GetReferencedTypes().Any(r => r.IsByte()));
}
/// <summary>
/// Resolve all generic parameters in the given type in the given context.
/// </summary>
internal static bool TryResolve(NetTypeReference type, INetGenericParameterProvider context, TypeNameMap typeNameMap, out NetTypeReference result)
{
result = null;
if (type == null)
{
return(false);
}
if (context == null)
{
throw new ArgumentNullException("context");
}
result = type.Accept(new Resolver(context, typeNameMap), 0);
return(result != null);
}
/// <summary>
/// Resolve all generic parameters in the given type in the given context.
/// </summary>
internal static NetTypeReference Resolve(NetTypeReference type, INetGenericParameterProvider context, TypeNameMap typeNameMap)
{
if (type == null)
{
return(null);
}
NetTypeReference result;
if (!TryResolve(type, context, typeNameMap, out result))
{
throw new ArgumentException(string.Format("Cannot resolve {0} in context of {1}", type, context));
}
return(result);
}
internal static bool AreEqual(NetTypeReference type1, NetTypeReference type2)
{
if ((type1 == null) && (type2 == null))
{
return(true);
}
if ((type1 == null) || (type2 == null))
{
return(false);
}
string fullName1 = type1.FullName;
string fullName2 = type2.FullName;
return(fullName1 == fullName2);
}
/// <summary>
/// Do type1 and type2 refer to the same type?
/// </summary>
/// <remarks>
/// The types are also the same, if the Generic Parameters have a different name.
/// MyClass<T> is the same as MyClass<U>.
/// So we need to do some special processing to check this.
/// </remarks>
internal static bool AreSame(this NetTypeReference type1, NetTypeReference type2)
{
if ((type1 == null) && (type2 == null))
{
return(true);
}
if ((type1 == null) || (type2 == null))
{
return(false);
}
string fullName1 = type1.FullName;
string fullName2 = type2.FullName;
return(AreSameGenericParameters(fullName1, fullName2, false));
}
/// <summary>
/// Resolve the given generic parameter into a type reference.
/// </summary>
bool IBuilderGenericContext.TryResolveTypeParameter(string name, TargetFramework target,
out NetTypeReference type)
{
var methodTypeParam = method.GenericParameters.FirstOrDefault(x => (x.Name == name) || (x.OriginalName == name));
if (methodTypeParam != null)
{
type = methodTypeParam;
return(true);
}
if (((IBuilderGenericContext)declaringTypeBuilder).TryResolveTypeParameter(name, target, out type))
{
return(true);
}
// Look in parent type
type = ResolveTypeParameterInBaseClass(javaMethod.DeclaringClass, name, target);
return(type != null);
}
/// <summary>
/// Resolve the given java based type reference to a Cecil based type reference.
/// </summary>
internal static bool TryResolve(this TypeReference jRef, TargetFramework target, IBuilderGenericContext gcontext, bool convertSignedBytes, out NetTypeReference result)
{
result = null;
if (jRef.IsArray)
{
var aType = (ArrayTypeReference) jRef;
NetTypeReference elementType;
if (!aType.ElementType.TryResolve(target, gcontext, convertSignedBytes, out elementType))
return false;
result = new NetArrayType(elementType);
return true;
}
if (jRef.IsVoid)
{
result = target.TypeNameMap.GetByType(typeof(void));
return true;
}
if (jRef.IsBaseType)
{
var bType = (BaseTypeReference) jRef;
result = target.TypeNameMap.GetByType(bType.GetClrType(convertSignedBytes));
return true;
}
if (jRef.IsObjectType)
{
return TryResolveObjectType((ObjectTypeReference) jRef, target, gcontext, out result);
}
if (jRef.IsTypeVariable)
{
var tRef = (TypeVariableReference) jRef;
if (gcontext.TryResolveTypeParameter(tRef.ClassName, target, out result))
return true;
result = target.TypeNameMap.Object; // Hack for incorrect behaving java classes
return true;
}
return false;
//throw new ArgumentException(string.Format("Unknown java type ref. {0}", jRef));
}
/// <summary>
/// Resolve the given java based type reference to a Cecil based type reference.
/// </summary>
private static bool TryResolveObjectType(ObjectTypeReference jRef, TargetFramework target, IBuilderGenericContext gcontext, out NetTypeReference result)
{
var objecType = jRef;
switch (objecType.ClassName)
{
case "java/lang/Exception":
case "java/lang/Throwable":
result = target.TypeNameMap.GetByType(typeof(Exception));
return true;
case "java/lang/Boolean":
case "java/lang/Byte":
case "java/lang/Character":
case "java/lang/Double":
case "java/lang/Float":
case "java/lang/Integer":
case "java/lang/Long":
case "java/lang/Short":
result = new NetNullableType(target.TypeNameMap.GetType(objecType, target, gcontext));
return true;
default:
return target.TypeNameMap.TryGetType(objecType, target, gcontext, out result);
}
}
/// <summary>
/// Create a type reference
/// </summary>
private static string CreateRef(NetTypeReference typeRef, bool allowVoid, bool useShortTypeNames, bool useShortNestedTypeNames, bool useGlobalPrefix, NetTypeDefinition context, TargetFramework target)
{
if (typeRef == null)
{
if (allowVoid)
{
return("void");
}
throw new ArgumentNullException("typeRef");
}
var result = typeRef.Accept(new CodeTypeReferenceBuilder(context, useShortTypeNames, useShortNestedTypeNames, allowVoid, target.TypeNameMap), true);
if (context != null)
{
switch (result)
{
case "global::Android.Widget.AdapterView<object>.IOnItemClickListener":
switch (context.FullName)
{
case "Android.Widget.Spinner":
return(result.Replace("<object>", "<global::Android.Widget.ISpinnerAdapter>"));
case "Android.Widget.ExpandableListView":
return(result.Replace("<object>", "<global::Android.Widget.IListAdapter>"));
}
break;
}
}
if (useGlobalPrefix)
{
if (!result.StartsWith("global::"))
{
result = "global::" + result;
}
}
return(result);
}
/// <summary>
/// Resolve the given generic parameter into a type reference.
/// </summary>
protected override bool TryResolveTypeParameter(string name, TargetFramework target, out NetTypeReference type)
{
var parentContext = (IBuilderGenericContext)parent;
type = typeDef.GenericParameters.FirstOrDefault(x => x.Name == name);
if (type != null)
{
return(true);
}
return(parentContext.TryResolveTypeParameter(name, target, out type));
}
/// <summary>
/// Resolve the given java based type reference to a Cecil based type reference.
/// </summary>
private static bool TryResolveObjectType(ObjectTypeReference jRef, TargetFramework target, IBuilderGenericContext gcontext, out NetTypeReference result)
{
var objecType = jRef;
switch (objecType.ClassName)
{
case "java/lang/Exception":
case "java/lang/Throwable":
result = target.TypeNameMap.GetByType(typeof(Exception));
return(true);
case "java/lang/Boolean":
case "java/lang/Byte":
case "java/lang/Character":
case "java/lang/Double":
case "java/lang/Float":
case "java/lang/Integer":
case "java/lang/Long":
case "java/lang/Short":
result = new NetNullableType(target.TypeNameMap.GetType(objecType, target, gcontext));
return(true);
default:
return(target.TypeNameMap.TryGetType(objecType, target, gcontext, out result));
}
}
/// <summary>
/// Resolve the given java based type reference to a Cecil based type reference.
/// </summary>
internal static bool TryResolve(this TypeReference jRef, TargetFramework target, IBuilderGenericContext gcontext, bool convertSignedBytes, out NetTypeReference result)
{
result = null;
if (jRef.IsArray)
{
var aType = (ArrayTypeReference)jRef;
NetTypeReference elementType;
if (!aType.ElementType.TryResolve(target, gcontext, convertSignedBytes, out elementType))
{
return(false);
}
result = new NetArrayType(elementType);
return(true);
}
if (jRef.IsVoid)
{
result = target.TypeNameMap.GetByType(typeof(void));
return(true);
}
if (jRef.IsBaseType)
{
var bType = (BaseTypeReference)jRef;
result = target.TypeNameMap.GetByType(bType.GetClrType(convertSignedBytes));
return(true);
}
if (jRef.IsObjectType)
{
return(TryResolveObjectType((ObjectTypeReference)jRef, target, gcontext, out result));
}
if (jRef.IsTypeVariable)
{
var tRef = (TypeVariableReference)jRef;
if (gcontext.TryResolveTypeParameter(tRef.ClassName, target, out result))
{
return(true);
}
result = target.TypeNameMap.Object; // Hack for incorrect behaving java classes
return(true);
}
return(false);
//throw new ArgumentException(string.Format("Unknown java type ref. {0}", jRef));
}
/// <summary>
/// Mark this method as an explicit interface implementation.
/// </summary>
public void SetExplicitImplementation(NetMethodDefinition iMethod, NetTypeReference iType)
{
if (iMethod == null)
throw new ArgumentNullException("iMethod");
if (iType == null)
throw new ArgumentNullException("iType");
InterfaceMethod = iMethod;
InterfaceType = iType;
}
/// <summary>
/// Do type refer to System.Void?
/// </summary>
internal static bool IsVoid(this NetTypeReference type)
{
return((type == null) || (StripGlobalPrefix(type.FullName) == "System.Void"));
}
/// <summary>
/// Do type refer to System.String?
/// </summary>
internal static bool IsString(this NetTypeReference type)
{
return(StripGlobalPrefix(type.FullName) == "System.String");
}
/// <summary>
/// Resolve the given generic parameter into a type reference.
/// </summary>
bool IBuilderGenericContext.TryResolveTypeParameter(string name, TargetFramework target, out NetTypeReference type)
{
return(TryResolveTypeParameter(name, target, out type));
}
/// <summary>
/// Resolve the given generic parameter into a type reference.
/// </summary>
bool IBuilderGenericContext.TryResolveTypeParameter(string name, TargetFramework target,
out NetTypeReference type)
{
var methodTypeParam = method.GenericParameters.FirstOrDefault(x => (x.Name == name) || (x.OriginalName == name));
if (methodTypeParam != null)
{
type = methodTypeParam;
return true;
}
if (((IBuilderGenericContext) declaringTypeBuilder).TryResolveTypeParameter(name, target, out type))
return true;
// Look in parent type
type = ResolveTypeParameterInBaseClass(javaMethod.DeclaringClass, name, target);
return (type != null);
}
internal static bool AreEqual(NetTypeReference type1, NetTypeReference type2)
{
if ((type1 == null) && (type2 == null))
return true;
if ((type1 == null) || (type2 == null))
return false;
string fullName1 = type1.FullName;
string fullName2 = type2.FullName;
return fullName1 == fullName2;
}
/// <summary>
/// Create a name for a parameter of the given type.
/// </summary>
private string CreateParameterName(NetTypeReference parameterType, DocParameter doc, TargetFramework target)
{
if ((doc != null) && (!string.IsNullOrEmpty(doc.Name)))
return doc.Name;
target.ReportMissingParameterName(javaMethod.DeclaringClass.ClassName);
var name = parameterType.Name;
var elementType = parameterType.GetElementType();
if (elementType != null)
{
name = elementType.Name.Replace('.', '_');
}
if (name == null)
{
name = "p";
}
if ((name.StartsWith("I")) && (name.Length > 1) && (elementType != null) && (elementType.IsInterface))
{
name = name.Substring(1);
}
name = name.Substring(0, 1).ToLower() + name.Substring(1);
return name;
}
/// <summary>
/// Resolve the given generic parameter into a type reference.
/// </summary>
protected override bool TryResolveTypeParameter(string name, TargetFramework target, out NetTypeReference type)
{
var parentContext = (IBuilderGenericContext) parent;
type = typeDef.GenericParameters.FirstOrDefault(x => x.Name == name);
if (type != null)
return true;
return parentContext.TryResolveTypeParameter(name, target, out type);
}
/// <summary>
/// Gets a mapping
/// </summary>
public bool TryGetType(ObjectTypeReference javaTypeRef, TargetFramework target, IBuilderGenericContext gcontext, out NetTypeReference result)
{
NetTypeDefinition typeDef;
if (TryGetByJavaClassName(javaTypeRef.ClassName, out typeDef))
{
// Custom
/*if (typeDef.FullName.StartsWith("System.Type"))
* {
* }*/
// Create result
if (!javaTypeRef.Arguments.Any() && (typeDef.GenericParameters.Count == 0))
{
// Normal non-generic type
result = typeDef;
return(true);
}
if (typeDef.IgnoreGenericArguments)
{
// Force use as normal type
result = typeDef;
return(true);
}
// Generic type is used as non-generic?
NetTypeReference declaringType = null;
if (javaTypeRef.Prefix != null)
{
TryGetType(javaTypeRef.Prefix, target, gcontext, out declaringType);
}
var git = new NetGenericInstanceType(typeDef, declaringType);
if (!javaTypeRef.Arguments.Any() && (typeDef.GenericParameters.Count > 0))
{
// Add "object" arguments
foreach (var tp in typeDef.GenericParameters)
{
git.AddGenericArgument(Object, this);
}
result = git;
return(true);
}
if (javaTypeRef.Arguments.Count() != typeDef.GenericParameters.Count)
{
if ((resolver == null) || (typeDef.GenericParameters.Count != 0) ||
(!resolver.AcceptLackOfGenericParameters))
{
throw new ArgumentException(string.Format("Mismatch between generic parameter count and generic argument count in {0}", javaTypeRef));
}
if ((resolver != null) && (resolver.AcceptLackOfGenericParameters) &&
(typeDef.GenericParameters.Count == 0))
{
result = typeDef;
return(true);
}
}
// Type with generic arguments
foreach (var typeArg in javaTypeRef.Arguments)
{
NetTypeReference arg;
if (typeArg.IsAny)
{
arg = Object;
}
else
{
if (!typeArg.Signature.TryResolve(target, gcontext, false, out arg))
{
arg = Object;
//result = null;
//return false;
}
}
git.AddGenericArgument(arg, this);
}
result = git;
return(true);
}
#if DEBUG
var names = map.Keys.OrderBy(x => x).ToArray();
#endif
//throw new ArgumentException(string.Format("{0} not found", javaTypeRef));
result = null;
return(false);
}
/// <summary>
/// Default ctor
/// </summary>
public NetCustomAttribute(NetTypeReference type, params object[] ctorArguments)
{
this.type = type;
ConstructorArguments.AddRange(ctorArguments);
}
/// <summary>
/// Resolve the given generic parameter into a type reference.
/// </summary>
protected virtual bool TryResolveTypeParameter(string name, TargetFramework target, out NetTypeReference type)
{
throw new NotImplementedException();
}
private static string ConvertPrimitive(object value, NetTypeReference expectedType)
{
if (expectedType != null)
{
if (expectedType.IsBoolean())
{
value = System.Convert.ToBoolean(value);
}
else if (expectedType.IsChar())
{
value = System.Convert.ToChar(value);
}
}
if (value is byte[])
{
var arr = (byte[])value;
var seq = arr.Select(x => string.Format("{0}", x));
return("new byte[] { " + string.Join(",", seq) + " } ");
}
if (value is string[])
{
var arr = (string[])value;
var seq = arr.Select(x => ConvertPrimitive(x, null));
return("new string[] { " + string.Join("," + Environment.NewLine + "\t", seq) + " } ");
}
if (value is double)
{
var dvalue = (double)value;
if (double.IsNaN(dvalue))
{
return("0.0d / 0.0d");
}
if (double.IsNegativeInfinity(dvalue))
{
return("-1.0d / 0.0d");
}
if (double.IsPositiveInfinity(dvalue))
{
return("1.0d / 0.0d");
}
}
if (value is float)
{
var fvalue = (float)value;
if (float.IsNaN(fvalue))
{
return("0.0f / 0.0f");
}
if (float.IsNegativeInfinity(fvalue))
{
return("-1.0f / 0.0f");
}
if (float.IsPositiveInfinity(fvalue))
{
return("1.0f / 0.0f");
}
}
var compiler = new CSharpCodeProvider();
var writer = new StringWriter();
compiler.GenerateCodeFromExpression(new CodePrimitiveExpression(value), writer,
new CodeGeneratorOptions());
return(writer.ToString());
}
/// <summary>
/// Gets a mapping
/// </summary>
public bool TryGetType(ObjectTypeReference javaTypeRef, TargetFramework target, IBuilderGenericContext gcontext, out NetTypeReference result)
{
NetTypeDefinition typeDef;
if (TryGetByJavaClassName(javaTypeRef.ClassName, out typeDef))
{
// Custom
/*if (typeDef.FullName.StartsWith("System.Type"))
{
}*/
// Create result
if (!javaTypeRef.Arguments.Any() && (typeDef.GenericParameters.Count == 0))
{
// Normal non-generic type
result = typeDef;
return true;
}
if (typeDef.IgnoreGenericArguments)
{
// Force use as normal type
result = typeDef;
return true;
}
// Generic type is used as non-generic?
NetTypeReference declaringType = null;
if (javaTypeRef.Prefix != null)
{
TryGetType(javaTypeRef.Prefix, target, gcontext, out declaringType);
}
var git = new NetGenericInstanceType(typeDef, declaringType);
if (!javaTypeRef.Arguments.Any() && (typeDef.GenericParameters.Count > 0))
{
// Add "object" arguments
foreach (var tp in typeDef.GenericParameters)
{
git.AddGenericArgument(Object, this);
}
result = git;
return true;
}
if (javaTypeRef.Arguments.Count() != typeDef.GenericParameters.Count)
{
if ((resolver == null) || (typeDef.GenericParameters.Count != 0) ||
(!resolver.AcceptLackOfGenericParameters))
{
throw new ArgumentException(string.Format("Mismatch between generic parameter count and generic argument count in {0}", javaTypeRef));
}
if ((resolver != null) && (resolver.AcceptLackOfGenericParameters) &&
(typeDef.GenericParameters.Count == 0))
{
result = typeDef;
return true;
}
}
// Type with generic arguments
foreach (var typeArg in javaTypeRef.Arguments)
{
NetTypeReference arg;
if (typeArg.IsAny)
{
arg = Object;
}
else
{
if (!typeArg.Signature.TryResolve(target, gcontext, false, out arg))
{
arg = Object;
//result = null;
//return false;
}
}
git.AddGenericArgument(arg, this);
}
result = git;
return true;
}
#if DEBUG
var names = map.Keys.OrderBy(x => x).ToArray();
#endif
//throw new ArgumentException(string.Format("{0} not found", javaTypeRef));
result = null;
return false;
}
/// <summary>
/// Resolve the given generic parameter into a type reference.
/// </summary>
protected override bool TryResolveTypeParameter(string name, TargetFramework target, out NetTypeReference type)
{
if (!AddGenericParameters)
{
if (cf.Signature.TypeParameters.Any(x => x.Name == name))
{
type = target.TypeNameMap.Object;
return true;
}
}
var result = typeDef.GenericParameters.FirstOrDefault(x => x.Name == name);
if (result != null)
{
type = result;
return true;
}
// This is a hack for non-behaving java classes
type = target.TypeNameMap.Object;
return false;
}
/// <summary>
/// Resolve the given generic parameter into a type reference.
/// </summary>
protected override bool TryResolveTypeParameter(string name, TargetFramework target, out NetTypeReference type)
{
if (!AddGenericParameters)
{
if (cf.Signature.TypeParameters.Any(x => x.Name == name))
{
type = target.TypeNameMap.Object;
return(true);
}
}
var result = typeDef.GenericParameters.FirstOrDefault(x => x.Name == name);
if (result != null)
{
type = result;
return(true);
}
// This is a hack for non-behaving java classes
type = target.TypeNameMap.Object;
return(false);
}
