// 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(); }