public string[]? GetParameterNames(JavaMethodParameterNameInfo info)
{
var package = info.PackageName;
var type = info.TypeName;
var method = info.MethodName;
var ptypes = info.ParameterTypes.Select(p => p.JavaType).ToArray();
var methods = this.packages
.Where(p => p.Name == package && p.Types != null)
.SelectMany(p => p.Types !)
.Where(t => t.Name == type && t.Methods != null)
.SelectMany(t => t.Methods !)
.Where(m => m.Name == method);
var namedMethod = methods.FirstOrDefault(m => ParametersEqual(m.Parameters, ptypes));
if (namedMethod == null)
{
return(null);
}
return(namedMethod.Parameters?.Select(p => p.Name !).ToArray());
}
void FixupParametersFromDocs(XElement api, string path)
{
var jdoc = CreateDocScraper(path);
var elements = api.XPathSelectElements("./package/class[@visibility = 'public' or @visibility = 'protected']").ToList();
elements.AddRange(api.XPathSelectElements("./package/interface[@visibility = 'public' or @visibility = 'protected']"));
foreach (var elem in elements)
{
var currentpackage = elem.Parent?.Attribute("name")?.Value ?? "";
var className = elem.Attribute("name")?.Value;
if (className == null)
{
continue;
}
var methodsAndConstructors = elem.XPathSelectElements("./method[@visibility = 'public' or @visibility = 'protected']").ToList();
methodsAndConstructors.AddRange(elem.XPathSelectElements("./constructor[@visibility = 'public' or @visibility = 'protected']"));
foreach (var method in methodsAndConstructors)
{
var currentMethod = method.Attribute("name")?.Value;
if (currentMethod == null)
{
continue;
}
var parameterElements = method.Elements("parameter").ToList();
if (!parameterElements.Select(x => x.Attribute("name")?.Value).Any(p => p != null && IsGeneratedName(p)))
{
continue;
}
var parameterTypes = parameterElements
.Select(p => new JavaMethodParameterTypeInfo(
jniType: (string?)p.Attribute("jni-type") ?? "",
javaType: (string?)p.Attribute("type") ?? ""))
.ToArray();
if (!parameterTypes.Any())
{
continue;
}
var nameInfo = new JavaMethodParameterNameInfo(
currentpackage,
className,
currentMethod,
(string?)method.Attribute("jni-signature"),
parameterTypes,
isVarArgs: false
);
var pnames = jdoc.GetParameterNames(nameInfo);
if (pnames == null || pnames.Length != parameterElements.Count)
{
continue;
}
for (int i = 0; i < parameterElements.Count; i++)
{
var a = parameterElements [i].Attribute("name");
if (a == null)
{
continue;
}
a.Value = pnames [i];
}
}
}
}
public string[]? GetParameterNames(JavaMethodParameterNameInfo info)
{
var xtype = xdoc
.Elements("api")
.Elements("package")
.Where(p => ((string?)p.Attribute("name")) == info.PackageName)
.Elements()
.Where(t => ((string?)t.Attribute("name")) == info.TypeName)
.FirstOrDefault();
if (xtype == null)
{
return(null);
}
var members = info.MethodName == "constructor"
? xtype.Elements("constructor")
: xtype.Elements("method").Where(m => ((string?)m.Attribute("name")) == info.MethodName);
var pcount = info.ParameterTypes.Length;
members = members
.Where(m => m.Elements("parameter").Count() == pcount);
XElement?member =
members.FirstOrDefault(m => info.MethodSignature == (string?)m.Attribute("jni-signature"));
if (member == null)
{
foreach (var m in members)
{
var found = true;
int i = 0;
foreach (var p in m.Elements("parameter"))
{
if (!ParameterTypesMatch(p, info.ParameterTypes [i++].JavaType))
{
found = false;
break;
}
}
if (found)
{
member = m;
break;
}
}
}
if (member == null)
{
return(null);
}
return(member.Elements("parameter")
.Select(p => ((string?)p.Attribute("name")) ?? "")
.ToArray());
bool ParameterTypesMatch(XElement parameter, string ptype)
{
var jtype = (string?)parameter.Attribute("type");
if (jtype == null)
{
return(false);
}
if (!jtype.StartsWith(".*", StringComparison.Ordinal))
{
return(jtype == ptype);
}
jtype = "." + jtype.Substring(".*".Length);
return(ptype.EndsWith(jtype, StringComparison.Ordinal));
}
}
public virtual string[]? GetParameterNames(JavaMethodParameterNameInfo info)
{
var package = info.PackageName;
var type = info.TypeName;
var method = info.MethodName;
var ptypes = info.ParameterTypes.Select(p => p.JavaType).ToArray();
string path = package.Replace('.', '/') + '/' + type.Replace('$', '.') + ".html";
string file = Path.Combine(root, path);
if (!File.Exists(file))
{
Log.Warning(1, "Warning: no document found : " + file);
return(null);
}
var buffer = new StringBuilder();
buffer.Append(pattern_head);
buffer.Append(path);
buffer.Append("#");
buffer.Append(method);
buffer.Append(open_method);
for (int i = 0; i < ptypes.Length; i++)
{
if (i != 0)
{
buffer.Append(param_sep);
}
var ptype = ptypes [i];
if (ShouldEliminateGenericArguments)
{
while (ptype.IndexOf("<", StringComparison.Ordinal) > 0 &&
ptype.IndexOf(">", StringComparison.Ordinal) > ptype.IndexOf("<", StringComparison.Ordinal))
{
ptype = ptype.Substring(0, ptype.IndexOf("<", StringComparison.Ordinal)) +
ptype.Substring(ptype.IndexOf(">", StringComparison.Ordinal) + 1);
}
}
buffer.Append(ptype.Replace('$', '.'));
}
if (ShouldEscapeBrackets)
{
buffer.Replace("[", "\\[").Replace("]", "\\]");
}
if (ShouldAlterArraySpec)
{
buffer.Replace("[]", ":A");
}
buffer.Append(close_method);
buffer.Append("\".*\\(([^\\(\\)]*)\\)");
buffer.Append(post_close_method_parens);
buffer.Replace("?", "\\?");
Regex pattern = new Regex(buffer.ToString(), RegexOptions.Multiline);
try {
String text = "";
String?prev = null;
foreach (var _text in GetContentLines(file))
{
text = _text.TrimEnd('\r');
if (prev != null)
{
prev = text = prev + text;
}
var matcher = pattern.Match(text);
if (matcher.Success)
{
var plist = matcher.Groups [1];
String[] parms = StripTagsFromParameters(plist.Value).Split(new string [] { ", " }, StringSplitOptions.RemoveEmptyEntries);
if (parms.Length != ptypes.Length)
{
Log.Warning(1, "failed matching {0} (expected {1} params, got {2} params)", buffer, ptypes.Length, parms.Length);
return(null);
}
String[] result = new String [ptypes.Length];
for (int i = 0; i < ptypes.Length; i++)
{
String[] toks = parms [i].Split(parameter_pair_splitter, StringSplitOptions.RemoveEmptyEntries);
result [i] = toks [toks.Length - 1];
}
return(result);
}
if (ShouldResetMatchBuffer(text))
{
prev = null;
}
else
{
prev = text;
}
}
} catch (Exception e) {
Log.Error("ERROR in {0}.{1}: {2}", type, method, e);
return(null);
}
Log.Warning(1, "Warning : no match for {0}.{1} (rex: {2})", type, method, buffer);
return(null);
}
