public void ProcessParameters(Net2ObjC n2c, MethodFacet facet, Dictionary <string, object> options = null) { int idx = 0; foreach (ParameterFacet parameter in facet.Parameters) { // Known issues: // // 1. Rendering of T[]& fails as in System.Array:Resize<T>(ref T[], int) // <Parameter Name="array" Type="T[]&" ElementType="T[]" IsByRef="True" ContainsGenericParameters="True"/> // Issue : T[]& renders as T** // Workaround: exclude in config.objc.xml like so <string>System.Array:Resize</string> // Suggested fix: provide a separate Element xml element to detail the ElementType more fully. // if the mono parameters is passed by ref then strip // the suffix to enable type association string monoParameterType = parameter.Type; if (parameter.IsByRef || parameter.IsPointer) { monoParameterType = parameter.ElementType; } // // build the ObjC method interleaved parameter representation // eg: name1:(int32_t)p1 name2:(int64_t)p2 name3:(NSString *)p3 // string objCParamTypeDecl = null; bool objCParameterIsObject = true; // // Get the ObjC type associated with the parameter. // ObjCTypeAssociation objCTypeAssociate = n2c.ObjCTypeAssociate(parameter); ManagedTypeAssociation managedTypeAssociate = null; if (objCTypeAssociate != null) { // // If the parameter is an array, say Int64[], then its Obj-C rep will be System.Array // The mono type association however must reflect the represented type, Int64. // if (parameter.IsArray) { ObjCTypeAssociation objCRepresentedTypeAssociate = n2c.ObjCTypeAssociate(parameter.ElementType); if (objCRepresentedTypeAssociate != null) { managedTypeAssociate = objCRepresentedTypeAssociate.ManagedTypeAssociate; } } if (managedTypeAssociate == null) { managedTypeAssociate = objCTypeAssociate.ManagedTypeAssociate; } objCParamTypeDecl = objCTypeAssociate.ObjCTypeDecl; objCParameterIsObject = objCTypeAssociate.IsNSObject; } else { // // Generate default objC representations // objCParamTypeDecl = n2c.ObjCTypeDeclFromManagedFacet(parameter); objCParameterIsObject = n2c.ObjCRepresentationIsObject(parameter); } // if parameter is an interface then use adoption conforming type ie: id <typename> if (parameter.IsInterface) { objCParamTypeDecl = n2c.ObjCConformingTypeFromObjCTypeDecl(objCParamTypeDecl, false); } if (parameter.IsByRef || parameter.IsPointer) { objCParamTypeDecl += "*"; // add additional indirection } // // Build the mono method argument invocation signature // if (idx > 0) { MonoSigBuilder.Append(","); } string monoParameterTypeInvoke = null; // if type is a GenericParameter defined by the class, as opposed to via a method like so Method<T>(T). // in this case we want to identify the parameter by its position as this makes it simple // to build the required signature at run time if (parameter.IsGenericParameter && !parameter.DeclaredByMethod) { // generic parameters must have an associate if (managedTypeAssociate == null) { throw new Exception("Missing managed type association for generic parameter."); } monoParameterTypeInvoke = managedTypeAssociate.ManagedTypeInvoke; if (parameter.IsArray) { monoParameterTypeInvoke += "[]"; } // in order for the C api to substitute the correct type at run time // the generic parameter position needs to be indicated. monoParameterTypeInvoke = string.Format(monoParameterTypeInvoke, parameter.GenericParameterPosition); } // if parameter is declared by the method like so Method<T>(T) then we want to preserve the type name // as this constitutes part of the method signature this is used to lookup the generic method for inflation else if (parameter.IsGenericParameter && parameter.DeclaredByMethod) { // we expect to be operating on a generic method definition if (!facet.IsGenericMethodDefinition) { throw new Exception("Generic method definition expected."); } // the type sig will be something like Declaring.Type+T but the embedded API sig // uses just the type parameter name T int symbolIndex = monoParameterType.IndexOf('+'); if (symbolIndex == -1) { throw new Exception("Missing nested type symbol for generic parameter."); } monoParameterTypeInvoke = monoParameterType.Substring(symbolIndex + 1); if (parameter.IsArray) { monoParameterTypeInvoke += "[]"; } } else { monoParameterTypeInvoke = n2c.ManagedTypeInvokeFromManagedType(monoParameterType); } // Note that we use a separate variable to hold the actual type sig used in the in mono_method_desc call // as the signature may need to be specfically modified for the mono_method_desc API. string monoParameterTypeInvoke_ = monoParameterTypeInvoke; // The mono_method_desc * APIs prefix nested classes with a '/' rather than a '+' to conform with IL/CTS conventions // The approach used here is trivial and is likely fragile. // We probably need a separate mono param type builder like that found in debug-helpers.c append_class_name(). // Note that Delegates will present as nested classes. // Also note that although we have an IsNested property we shouldn't use it as a conditional test for this operation // as generic types with nested type paramaters such as System.Collections.Generic.IEnumerable`1<A.B+C> // won't identify as nested. monoParameterTypeInvoke_ = monoParameterTypeInvoke_.Replace("+", "/"); // add type signature and access modifier MonoSigBuilder.Append(monoParameterTypeInvoke_); if (parameter.IsPointer) { MonoSigBuilder.Append("*"); } if (parameter.IsByRef) { MonoSigBuilder.Append("&"); // the signature needs to express by ref } // Build ObjC parameter name. // In order to represent overloaded methods effectively the // ObjC paramter name is constructed as follows: // Managed parameter name + Managed parameter type + Ref string objCParamName = ObjCIdentifierFromManagedIdentifier(parameter.Name); // If the method is overloaded by parameter then make the ObjC method // name unique by including type info in the name. // // Managed methods are overloaded by name only. // The Obj-C metjods representation uses interleaved parameters which may // be sufficient to produce a unique method signature. // // If however a managed method overload differs only in the type of its parameters // (the managed method name, parameter count and parameter names all being equal) // then the Obj-C interleaved parameters will include type info. string objCParamOverloadSuffix = ""; if (facet.IsOverloadedParameterMethod) { // We adopt a minimal as opposed to a full type repesentation here in order // to minimize the parameter length. // Time will tell how it flies. objCParamOverloadSuffix = n2c.ObjCMinimalIdentifierFromManagedIdentifier(monoParameterTypeInvoke); if (parameter.IsArray) { objCParamOverloadSuffix += "Array"; } if (parameter.IsPointer) { objCParamOverloadSuffix += "Ptr"; } } if (parameter.IsByRef) { objCParamOverloadSuffix += "Ref"; } if (objCParamOverloadSuffix.Length > 0) { objCParamName += objCParamOverloadSuffix.FirstCharacterToUpper(); } // append the complete interleaved parameter expression if (idx == 0) { if (n2c.AppendFirstArgSignatureToMethodName) { // the leading underscore helps identify the preceding characters as the managed method name ObjCMethodName += "_with"; ObjCParameterBuilder.AppendFormat("{0}", objCParamName.FirstCharacterToUpper()); } } else { ObjCParameterBuilder.AppendFormat(" {0}", objCParamName.FirstCharacterToLower()); } // normalise the obj C parameter type for use as an invocation API parameter string invokeApiObjCParamTypeDecl = n2c.NormaliseObjCTypeDecl(objCParamTypeDecl, ObjCTypeDeclNormalisation.InvokeApiParameterType); ObjCParameterBuilder.AppendFormat(":({0})p{1}", invokeApiObjCParamTypeDecl, idx + 1); // // build the mono invocation argument representation // string argFormat = null; if (idx > 0) { InvokeArgsBuilder.Append(", "); } if (objCParameterIsObject) { if (parameter.IsByRef) { // use reference pointer argFormat = "&refPtr{0}"; } else if (parameter.IsGenericParameter) { if (parameter.DeclaredByMethod) { argFormat = "[method monoRTInvokeArg:p{0}" + $" typeParameterIndex:{parameter.GenericParameterPosition}]"; } else { argFormat = "[self monoRTInvokeArg:p{0}" + $" typeParameterIndex:{parameter.GenericParameterPosition}]"; } } else if (parameter.IsValueType) { // if parameter is of value type then get suitable embedded runtime API argument value. // in general value types are passed as unboxed data. argFormat = "[p{0} monoRTInvokeArg]"; } else { // is parameter is of object type then get suitable embedded runtime API argument value. // note that if the actual argument is of value type it will be passed as a boxed value. argFormat = "[p{0} monoRTInvokeObject]"; } } else { if (parameter.IsByRef || parameter.IsPointer) { argFormat = "p{0}"; // just pass the pointer } else { argFormat = "&p{0}"; } } InvokeArgsBuilder.AppendFormat(argFormat, idx + 1); // // Build reference parameter pre and post process assignment statements // // Reference parameters need to be assigned to temporary variables // to allow for their mutation // if (objCParameterIsObject && parameter.IsByRef) { // dereference and assign temporary variable string preProcess = string.Format("void *refPtr{0} = [*p{0} monoRTInvokeArg];{1}", idx + 1, Environment.NewLine); ReferencePreProcessBuilder.Append(preProcess); // create new object subclass for reference string postProcess = string.Format("*p{0} = [System_Object bestObjectWithMonoObject:refPtr{0}];{1}", idx + 1, Environment.NewLine); ReferencePostProcessBuilder.Append(postProcess); } idx++; } }