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; }