// get a name that is safe to use from ObjC code
void GetSignatures(string objName, string monoName, MemberInfo info, ParameterInfo [] parameters, bool useTypeNames, bool isExtension, out string objcSignature, out string monoSignature)
{
var method = (info as MethodBase); // else it's a PropertyInfo
// special case for setter-only - the underscore looks ugly
if ((method != null) && method.IsSpecialName)
{
objName = objName.Replace("_", String.Empty);
}
var objc = new StringBuilder(objName);
var mono = new StringBuilder(monoName);
mono.Append('(');
for (int n = 0; n < parameters.Length; ++n)
{
ParameterInfo p = parameters [n];
if (objc.Length > objName.Length)
{
objc.Append(' ');
mono.Append(',');
}
string paramName = useTypeNames ? p.ParameterType.Name : p.Name;
if ((method != null) && (n > 0 || !isExtension))
{
if (n == 0)
{
bool mutatePropertyOrOperatorMethod = useTypeNames && (method.IsPropertyMethod() || method.IsOperatorMethod());
if (method.IsConstructor || mutatePropertyOrOperatorMethod || !method.IsSpecialName)
{
objc.Append(paramName.PascalCase());
}
}
else
{
objc.Append(paramName.ToLowerInvariant());
}
}
if (n > 0 || !isExtension)
{
string ptname = NameGenerator.GetObjCParamTypeName(p, types);
objc.Append(":(").Append(ptname).Append(")").Append(NameGenerator.GetExtendedParameterName(p, parameters));
}
mono.Append(NameGenerator.GetMonoName(p.ParameterType));
}
mono.Append(')');
objcSignature = objc.ToString();
monoSignature = mono.ToString();
}
void Generate(ParameterInfo [] parameters, bool isExtension, out string postInvoke)
{
StringBuilder post = new StringBuilder();
var pcount = parameters.Length;
implementation.WriteLine($"void* __args [{pcount}];");
for (int i = 0; i < pcount; i++)
{
var p = parameters [i];
var name = (isExtension && (i == 0)) ? "self" : NameGenerator.GetExtendedParameterName(p, parameters);
GenerateArgument(name, $"__args[{i}]", p.ParameterType, ref post);
}
postInvoke = post.ToString();
}
void GenerateDefaultValuesWrapper(string name, MethodBase mb, ParameterInfo[] parameters, int start)
{
MethodInfo mi = mb as MethodInfo;
string objcsig;
string monosig;
var parametersInfo = parameters;
var plist = new List <ParameterInfo> ();
StringBuilder arguments = new StringBuilder();
headers.WriteLine("/** This is an helper method that inlines the following default values:");
foreach (var p in parameters)
{
string pName = NameGenerator.GetExtendedParameterName(p, parameters);
if (arguments.Length == 0)
{
arguments.Append(p.Name.PascalCase()).Append(':');
}
else
{
arguments.Append(' ').Append(p.Name.CamelCase()).Append(':');
}
if (p.Position >= start && p.HasDefaultValue)
{
var raw = FormatRawValue(p.ParameterType, p.RawDefaultValue);
headers.WriteLine($" * ({NameGenerator.GetTypeName (p.ParameterType)}) {pName} = {raw};");
arguments.Append(raw);
}
else
{
arguments.Append(pName);
plist.Add(p);
}
}
headers.WriteLine(" *");
headers.WriteLine($" * @see {name}");
headers.WriteLine(" */");
if (mi == null)
{
name = start == 0 ? "init" : "initWith";
}
else
{
name = mb.Name.CamelCase();
}
GetSignatures(name, mb.Name, mb, plist.ToArray(), false, false, out objcsig, out monosig);
var type = mb.DeclaringType;
var builder = new MethodHelper(headers, implementation)
{
IsStatic = mb.IsStatic,
ReturnType = mi == null ? "nullable instancetype" : GetReturnType(type, mi.ReturnType),
ObjCSignature = objcsig,
};
builder.WriteHeaders();
headers.WriteLine();
builder.BeginImplementation();
if (mi == null || !mi.ReturnType.Is("System", "Void"))
{
implementation.Write("return [");
}
if (mb.IsStatic)
{
implementation.Write(NameGenerator.GetObjCName(mi.DeclaringType));
implementation.Write(' ');
}
else
{
implementation.Write("self ");
}
if (mi == null)
{
name = "initWith";
}
implementation.WriteLine($"{name}{arguments}];");
builder.EndImplementation();
}
