public bool Validate(CodeGenerationOptions opt, GenericParameterDefinitionList type_params, CodeGeneratorContext context)
{
return(parms == null || parms.Validate(opt, type_params, context));
}
public ManagedMethodBaseSupport(MethodDefinition m)
{
this.m = m;
generic_arguments = m.HasGenericParameters ? GenericParameterDefinitionList.FromMetadata(m.GenericParameters) : null;
}
public static GenericParameterDefinitionList Merge(GenericParameterDefinitionList l1, GenericParameterDefinitionList l2)
{
if (l1 == null)
{
return(l2);
}
if (l2 == null)
{
return(l1);
}
var ret = new GenericParameterDefinitionList();
ret.AddRange(l1);
ret.AddRange(l2);
return(ret);
}
public bool Validate(CodeGenerationOptions opt, GenericParameterDefinitionList type_params)
{
return(true);
}
public XmlGenBaseSupport(XmlElement pkg, XmlElement elem)
{
deprecated = elem.XGetAttribute("deprecated") != "not deprecated";
if (deprecated)
{
deprecatedComment = elem.XGetAttribute("deprecated");
if (deprecatedComment == "deprecated")
{
deprecatedComment = "This class is obsoleted in this android platform";
}
}
visibility = elem.XGetAttribute("visibility");
if (visibility == "protected")
{
visibility = "protected internal";
}
pkg_name = pkg.XGetAttribute("name");
java_name = elem.XGetAttribute("name");
if (pkg.HasAttribute("managedName"))
{
ns = pkg.XGetAttribute("managedName");
}
else
{
ns = StringRocks.PackageToPascalCase(PackageName);
}
var tpn = elem.SelectSingleNode("typeParameters");
if (tpn != null)
{
type_params = GenericParameterDefinitionList.FromXml(tpn);
is_generic = true;
int idx = java_name.IndexOf('<');
if (idx > 0)
{
java_name = java_name.Substring(0, idx);
}
}
else
{
int idx = java_name.IndexOf('<');
if (idx > 0)
{
throw new NotSupportedException("Looks like old API XML is used, which we don't support anymore.");
}
}
if (elem.HasAttribute("managedName"))
{
name = elem.XGetAttribute("managedName");
full_name = String.Format("{0}.{1}", ns, name);
int idx = name.LastIndexOf('.');
name = idx > 0 ? name.Substring(idx + 1) : name;
raw_name = name;
}
else
{
int idx = java_name.LastIndexOf('.');
name = idx > 0 ? java_name.Substring(idx + 1) : java_name;
if (Char.IsLower(name[0]))
{
name = StringRocks.TypeToPascalCase(name);
}
raw_name = name;
name = TypeNamePrefix + raw_name;
full_name = String.Format("{0}.{1}{2}", ns, idx > 0 ? StringRocks.TypeToPascalCase(java_name.Substring(0, idx + 1)) : String.Empty, name);
}
//marshaler = elem.XGetAttribute ("marshaler");
//if (!string.IsNullOrEmpty (marshaler)) throw new Exception ();
}
public static GenericParameterDefinitionList GenericArguments(this MethodDefinition m) => m.HasGenericParameters ? GenericParameterDefinitionList.FromMetadata(m.GenericParameters) : null;
public static GenBaseSupport CreateGenBaseSupport(XElement pkg, XElement elem, bool isInterface)
{
var support = new GenBaseSupport {
IsAcw = true,
IsDeprecated = elem.XGetAttribute("deprecated") != "not deprecated",
IsGeneratable = true,
JavaSimpleName = elem.XGetAttribute("name"),
PackageName = pkg.XGetAttribute("name"),
Visibility = elem.XGetAttribute("visibility")
};
if (support.IsDeprecated)
{
support.DeprecatedComment = elem.XGetAttribute("deprecated");
if (support.DeprecatedComment == "deprecated")
{
support.DeprecatedComment = "This class is obsoleted in this android platform";
}
}
if (support.Visibility == "protected")
{
support.Visibility = "protected internal";
}
if (pkg.Attribute("managedName") != null)
{
support.Namespace = pkg.XGetAttribute("managedName");
}
else
{
support.Namespace = StringRocks.PackageToPascalCase(support.PackageName);
}
var tpn = elem.Element("typeParameters");
if (tpn != null)
{
support.TypeParameters = GenericParameterDefinitionList.FromXml(tpn);
support.IsGeneric = true;
int idx = support.JavaSimpleName.IndexOf('<');
if (idx > 0)
{
support.JavaSimpleName = support.JavaSimpleName.Substring(0, idx);
}
}
else
{
int idx = support.JavaSimpleName.IndexOf('<');
if (idx > 0)
{
throw new NotSupportedException("Looks like old API XML is used, which we don't support anymore.");
}
}
string raw_name;
if (elem.Attribute("managedName") != null)
{
support.Name = elem.XGetAttribute("managedName");
support.FullName = string.IsNullOrWhiteSpace(support.Namespace) ? support.Name : $"{support.Namespace}.{support.Name}";
int idx = support.Name.LastIndexOf('.');
support.Name = idx > 0 ? support.Name.Substring(idx + 1) : support.Name;
raw_name = support.Name;
}
else
{
int idx = support.JavaSimpleName.LastIndexOf('.');
support.Name = idx > 0 ? support.JavaSimpleName.Substring(idx + 1) : support.JavaSimpleName;
if (char.IsLower(support.Name [0]))
{
support.Name = StringRocks.TypeToPascalCase(support.Name);
}
raw_name = support.Name;
support.TypeNamePrefix = isInterface ? IsPrefixableName(raw_name) ? "I" : string.Empty : string.Empty;
support.Name = EnsureValidIdentifer(support.TypeNamePrefix + raw_name);
var supportNamespace = string.IsNullOrWhiteSpace(support.Namespace) ? string.Empty : $"{support.Namespace}.";
var supportSimpleName = idx > 0 ? StringRocks.TypeToPascalCase(support.JavaSimpleName.Substring(0, idx + 1)) : string.Empty;
support.FullName = string.Format("{0}{1}{2}", supportNamespace, supportSimpleName, support.Name);
}
support.IsObfuscated = IsObfuscatedName(pkg.Elements().Count(), support.JavaSimpleName) && elem.XGetAttribute("obfuscated") != "false";
return(support);
}
protected virtual bool OnValidate(CodeGenerationOptions opt, GenericParameterDefinitionList type_params)
{
if (Name.Length > TypeNamePrefix.Length &&
(Name [TypeNamePrefix.Length] == '.' || Char.IsDigit(Name [TypeNamePrefix.Length]))) // see bug #5111
{
return(false);
}
if (!support.ValidateNamespace())
{
return(false);
}
List <GenBase> valid_nests = new List <GenBase> ();
foreach (GenBase gen in nested_types)
{
if (gen.Validate(opt, TypeParameters))
{
valid_nests.Add(gen);
}
}
nested_types = valid_nests;
AdjustNestedTypeFullName(this);
foreach (string iface_name in iface_names)
{
ISymbol isym = SymbolTable.Lookup(iface_name);
if (isym != null && isym.Validate(opt, TypeParameters))
{
ifaces.Add(isym);
}
else
{
if (isym == null)
{
Report.Warning(0, Report.WarningGenBase + 0, "For type {0}, base interface {1} does not exist.", FullName, iface_name);
}
else
{
Report.Warning(0, Report.WarningGenBase + 0, "For type {0}, base interface {1} is invalid.", FullName, iface_name);
}
iface_validation_failed = true;
}
}
List <Field> valid_fields = new List <Field> ();
foreach (Field f in fields)
{
if (!f.Validate(opt, TypeParameters))
{
continue;
}
valid_fields.Add(f);
}
fields = valid_fields;
int method_cnt = methods.Count;
methods = methods.Where(m => ValidateMethod(opt, m)).ToList();
method_validation_failed = method_cnt != methods.Count;
foreach (Method m in methods)
{
if (m.IsVirtual)
{
has_virtual_methods = true;
}
if (m.Name == "HashCode" && m.Parameters.Count == 0)
{
m.IsOverride = true;
m.Name = "GetHashCode";
}
jni_sig_hash [m.JavaName + m.JniSignature] = m;
if ((m.Name == "ToString" && m.Parameters.Count == 0) || (BaseSymbol != null && BaseSymbol.ContainsMethod(m, true)))
{
m.IsOverride = true;
}
}
return(true);
}
public ISymbol Lookup(string java_type, GenericParameterDefinitionList in_params)
{
string type_params;
int arrayRank;
bool has_ellipsis;
string key = GetSymbolInfo(java_type, out type_params, out arrayRank, out has_ellipsis);
// FIXME: we should make sure to differentiate those ref types IF we use those modifiers in the future.
switch (key [key.Length - 1])
{
case '&': // managed ref type
case '*': // managed (well, unmanaged...) pointer type
key = key.Substring(0, key.Length - 1);
break;
}
key = FilterPrimitiveFullName(key) ?? key;
switch (key)
{
case "android.content.res.XmlResourceParser":
return(CreateArray(xmlresourceparser_sym, arrayRank, has_ellipsis));
case "org.xmlpull.v1.XmlPullParser":
return(CreateArray(xmlpullparser_sym, arrayRank, has_ellipsis));
case "java.io.FileInputStream":
return(CreateArray(fileinstream_sym, arrayRank, has_ellipsis));
case "java.io.FileOutputStream":
return(CreateArray(fileoutstream_sym, arrayRank, has_ellipsis));
case "java.io.InputStream":
return(CreateArray(instream_sym, arrayRank, has_ellipsis));
case "java.io.OutputStream":
return(CreateArray(outstream_sym, arrayRank, has_ellipsis));
case "java.lang.CharSequence":
return(CreateArray(char_seq, arrayRank, has_ellipsis));
case "java.lang.String":
return(CreateArray(string_sym, arrayRank, has_ellipsis));
case "java.util.List":
case "java.util.ArrayList":
case "System.Collections.IList":
return(CreateArray(new CollectionSymbol(key, "IList", "Android.Runtime.JavaList", type_params), arrayRank, has_ellipsis));
case "java.util.Map":
case "java.util.HashMap":
case "java.util.SortedMap":
case "System.Collections.IDictionary":
return(CreateArray(new CollectionSymbol(key, "IDictionary", "Android.Runtime.JavaDictionary", type_params), arrayRank, has_ellipsis));
case "java.util.Set":
return(CreateArray(new CollectionSymbol(key, "ICollection", "Android.Runtime.JavaSet", type_params), arrayRank, has_ellipsis));
case "java.util.Collection":
case "System.Collections.ICollection":
return(CreateArray(new CollectionSymbol(key, "ICollection", "Android.Runtime.JavaCollection", type_params), arrayRank, has_ellipsis));
default:
break;
}
ISymbol result;
var gpd = in_params != null?in_params.FirstOrDefault(t => t.Name == key) : null;
if (gpd != null)
{
result = new GenericTypeParameter(gpd);
}
else
{
result = Lookup(key + type_params);
}
return(CreateArray(result, arrayRank, has_ellipsis));
}
public static GenericParameterDefinitionList GenericArguments(this XElement elem)
{
var tps = elem.Element("typeParameters");
return(tps != null?GenericParameterDefinitionList.FromXml(tps) : null);
}
public bool Validate (CodeGenerationOptions opt, GenericParameterDefinitionList type_params, CodeGeneratorContext context)
{
return true;
}
