xamarin-macios/runtime/delegates.t4

<# // vim: set filetype=cs :
#>
<#@ template language="C#" #>
<#@ import namespace="System" #>
<#@ import namespace="System.Text" #>
<#@ import namespace="System.Collections.Generic" #>
<#
	var delegates = new XDelegates {
		new XDelegate ("void", "void", "xamarin_register_nsobject",
			"MonoObject *", "IntPtr", "managed_obj",
			"id", "IntPtr", "native_obj"
		) {
			WrappedManagedFunction = "RegisterNSObject",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("void", "void", "xamarin_register_assembly",
			"MonoReflectionAssembly *", "IntPtr", "assembly"
		) {
			WrappedManagedFunction = "RegisterAssembly",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("void", "void", "xamarin_throw_ns_exception",
			"NSException *", "IntPtr", "exc"
		) {
			WrappedManagedFunction = "ThrowNSException",
			ExceptionHandling = false,
			OnlyDynamicUsage = false,
		},

		new XDelegate ("void", "void", "xamarin_rethrow_managed_exception",
			"guint32", "uint", "original_exception_gchandle"
		) {
			WrappedManagedFunction = "RethrowManagedException",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("int", "int", "xamarin_create_ns_exception",
			"NSException *", "IntPtr", "exc"
		) {
			WrappedManagedFunction = "CreateNSException",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("NSException *", "IntPtr", "xamarin_unwrap_ns_exception",
			"uint32_t", "uint", "exc_handle"
		) {
			WrappedManagedFunction = "UnwrapNSException",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("MonoObject *", "IntPtr", "xamarin_get_block_wrapper_creator",
			"MonoObject *", "IntPtr", "method",
			"unsigned long", "uint", "parameter"
		) {
			WrappedManagedFunction = "GetBlockWrapperCreator",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("MonoObject *", "IntPtr", "xamarin_create_block_proxy",
			"MonoObject *", "IntPtr", "method",
			"void *", "IntPtr", "block"
		) {
			WrappedManagedFunction = "CreateBlockProxy",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("id", "IntPtr", "xamarin_create_delegate_proxy",
			"MonoObject *", "IntPtr", "method",
			"MonoObject *", "IntPtr", "block",
			"const char *", "IntPtr", "signature",
			"unsigned int", "uint", "token_ref"
		) {
			WrappedManagedFunction = "CreateDelegateProxy",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("void", "void", "xamarin_register_entry_assembly",
			"MonoReflectionAssembly *", "IntPtr", "assembly"
		) {
			WrappedManagedFunction = "RegisterEntryAssembly",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("MonoObject *", "IntPtr", "xamarin_get_class",
			"Class", "IntPtr", "ptr"
		) {
			WrappedManagedFunction = "GetClass",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("MonoObject *", "IntPtr", "xamarin_get_selector",
			"SEL", "IntPtr", "ptr"
		) {
			WrappedManagedFunction = "GetSelector",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("void", "void", "xamarin_get_method_for_selector",
			"Class", "IntPtr", "cls",
			"SEL", "IntPtr", "sel",
			"bool", "bool", "is_static",
			"MethodDescription *", "IntPtr", "desc"
		) {
			WrappedManagedFunction = "GetMethodForSelector",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("MonoObject *", "IntPtr", "xamarin_get_nsobject",
			"id", "IntPtr", "obj"
		) {
			WrappedManagedFunction = "GetNSObjectWrapped",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("bool", "bool", "xamarin_has_nsobject",
			"id", "IntPtr", "obj"
		) {
			WrappedManagedFunction = "HasNSObject",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("id", "IntPtr", "xamarin_get_handle_for_inativeobject",
			"MonoObject *", "IntPtr", "obj"
		) {
			WrappedManagedFunction = "GetHandleForINativeObject",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("void", "void", "xamarin_unregister_nsobject",
			"id", "IntPtr", "native_obj",
			"MonoObject *", "IntPtr", "managed_obj"
		) {
			WrappedManagedFunction = "UnregisterNSObject",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("MonoObject *", "IntPtr", "xamarin_try_get_or_construct_nsobject",
			"id", "IntPtr", "obj"
		) {
			WrappedManagedFunction = "TryGetOrConstructNSObjectWrapped",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("MonoObject *", "IntPtr", "xamarin_get_inative_object_dynamic",
			"id", "IntPtr", "obj",
			"bool", "bool", "owns",
			"void *", "IntPtr", "type"
		) {
			WrappedManagedFunction = "GetINativeObject_Dynamic",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("MonoReflectionMethod *", "IntPtr", "xamarin_get_method_from_token",
			"unsigned int", "uint", "token_ref"
		) {
			WrappedManagedFunction = "GetMethodFromToken",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("MonoReflectionMethod *", "IntPtr", "xamarin_get_generic_method_from_token",
			"MonoObject *", "IntPtr", "obj",
			"unsigned int", "uint", "token_ref"
		) {
			WrappedManagedFunction = "GetGenericMethodFromToken",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("MonoObject *", "IntPtr", "xamarin_get_inative_object_static",
			"id", "IntPtr", "obj",
			"bool", "bool", "owns",
			"unsigned int", "uint", "iface_token_ref",
			"unsigned int", "uint", "implementation_token_ref"
		) {
			WrappedManagedFunction = "GetINativeObject_Static",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("MonoObject *", "IntPtr", "xamarin_get_nsobject_with_type",
			"id", "IntPtr", "obj",
			"void *", "IntPtr", "type",
			"int32_t *", "out bool", "created"
		) {
			WrappedManagedFunction = "GetNSObjectWithType",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("void", "void", "xamarin_dispose",
			"MonoObject *", "IntPtr", "mobj"
		) {
			WrappedManagedFunction = "Dispose",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("bool", "bool", "xamarin_is_parameter_transient",
			"MonoReflectionMethod *", "IntPtr", "method",
			"int", "int", "parameter"
		) {
			WrappedManagedFunction = "IsParameterTransient",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("bool", "bool", "xamarin_is_parameter_out",
			"MonoReflectionMethod *", "IntPtr", "method",
			"unsigned long", "uint", "parameter"
		) {
			WrappedManagedFunction = "IsParameterOut",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("void", "void", "xamarin_get_method_and_object_for_selector",
			"Class", "IntPtr", "cls",
			"SEL", "IntPtr", "sel",
			"bool", "bool", "is_static",
			"id", "IntPtr", "obj",
			"MonoObject **", "ref IntPtr", "mthis",
			"MethodDescription *", "IntPtr", "desc"
		) {
			WrappedManagedFunction = "GetMethodAndObjectForSelector",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("guint32", "int", "xamarin_create_product_exception_for_error",
			"int", "int", "code",
			"guint32", "uint", "inner_exception_gchandle",
			"const char *", "string", "message"
		) {
			WrappedManagedFunction = "CreateProductException",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("char *", "IntPtr", "xamarin_reflection_type_get_full_name",
			"MonoReflectionType *", "IntPtr", "type"
		) {
			WrappedManagedFunction = "TypeGetFullName",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("char *", "IntPtr", "xamarin_lookup_managed_type_name",
			"Class", "IntPtr", "klass"
		) {
			WrappedManagedFunction = "LookupManagedTypeName",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("enum MarshalManagedExceptionMode", "MarshalManagedExceptionMode", "xamarin_on_marshal_managed_exception",
			"int", "int", "exception"
		) {
			WrappedManagedFunction = "OnMarshalManagedException",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("enum MarshalObjectiveCExceptionMode", "MarshalObjectiveCExceptionMode", "xamarin_on_marshal_objectivec_exception",
			"id", "IntPtr", "exception",
			"bool", "bool", "throwManagedAsDefault"
		) {
			WrappedManagedFunction = "OnMarshalObjectiveCException",
			OnlyDynamicUsage = false,
		},

		new XDelegate ("NSString *", "IntPtr", "xamarin_convert_smart_enum_to_nsstring",
			"void *", "IntPtr", "value"
		) {
			WrappedManagedFunction = "ConvertSmartEnumToNSString",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("void *", "IntPtr", "xamarin_convert_nsstring_to_smart_enum",
			"NSString *", "IntPtr", "value",
			"MonoReflectionType *", "IntPtr", "type"
		) {
			WrappedManagedFunction = "ConvertNSStringToSmartEnum",
			OnlyDynamicUsage = true,
		},

		new XDelegate ("int32_t", "int", "xamarin_create_runtime_exception",
			"int32_t", "int", "code",
			"const char *", "IntPtr", "message"
		) {
			WrappedManagedFunction = "CreateRuntimeException",
			OnlyDynamicUsage = false,
		},
	};
	delegates.CalculateLengths ();
#><#+
	class Arg
	{
		public string CType;
		public string MType;
		public string Name;
	}

	class XDelegates : List<XDelegate>
	{
		public void CalculateLengths ()
		{
			foreach (var x in this) {
				MaxEntryPointLength = Math.Max (MaxEntryPointLength, x.EntryPoint.Length);
				MaxCReturnTypeLength = Math.Max (MaxCReturnTypeLength, x.CReturnType.Length);
				x.Delegates = this;
			}
		}

		public int MaxEntryPointLength;
		public int MaxCReturnTypeLength;
	}

	class XDelegate
	{
		public string CReturnType;
		public string MReturnType;
		public string EntryPoint;
		public List<Arg> Arguments;
		public string WrappedManagedFunction;
		public bool ExceptionHandling = true;
		// Detemines whether the function is only used by the dynamic registrar (in which case we might be able to link the function away if the static registrar is being used)
		public bool OnlyDynamicUsage;

		public XDelegates Delegates;

		public XDelegate (string cReturnType, string mReturnType, string entryPoint, params string [] arguments)
		{
			CReturnType = cReturnType;
			MReturnType = mReturnType;
			EntryPoint = entryPoint;

			if (arguments == null || arguments.Length == 0)
				return;

			if (arguments.Length % 3 != 0)
				throw new Exception (string.Format ("Export arguments params must be a multiple of 3 to form a set of (c type, managed name, name) triples for {0}", entryPoint));

			if (!entryPoint.StartsWith ("xamarin_"))
				throw new Exception ("All entry points must start with 'xamarin_'");

			Arguments = new List<Arg> ();
			for (var i = 0; i < arguments.Length; i += 3)
				Arguments.Add (new Arg {
					CType = arguments [i],
					MType = arguments [i + 1],
					Name = arguments [i + 2]
				});
		}

		public string SimpleEntryPoint {
			get {
				return EntryPoint.Substring ("xamarin_".Length);
			}
		}

		public string AlignEntryPoint {
			get {
				return new string (' ', Delegates.MaxEntryPointLength - EntryPoint.Length);
			}
		}

		public string AlignCReturnType {
			get {
				return new string (' ', Delegates.MaxCReturnTypeLength - CReturnType.Length);
			}
		}

		string CFormatArgs (string empty, bool nameOnly)
		{
			if (Arguments == null || Arguments.Count == 0)
				return empty;

			var builder = new StringBuilder ();

			foreach (var arg in Arguments) {
				if (!nameOnly) {
					builder.Append (arg.CType);
					builder.Append (' ');
				}
			
				builder.Append (arg.Name);
				builder.Append (", ");
			}

			builder.Length -= 2;

			if (ExceptionHandling) {
				if (nameOnly) {
					builder.Append (", exception_gchandle");
				} else {
					builder.Append (", guint32 *exception_gchandle");
				}
			}

			return builder.ToString ();
		}

		string MFormatArgs (string empty, bool nameOnly)
		{
			if (Arguments == null || Arguments.Count == 0)
				return empty;

			var builder = new StringBuilder ();

			foreach (var arg in Arguments) {
				if (!nameOnly) {
					builder.Append (arg.MType);
					builder.Append (' ');
				} else if (arg.MType.StartsWith ("out ")) {
					builder.Append ("out ");
				} else if (arg.MType.StartsWith ("ref ")) {
					builder.Append ("ref ");
				}
			
				builder.Append (arg.Name);
				builder.Append (", ");
			}

			builder.Length -= 2;

			if (ExceptionHandling) {
				if (nameOnly) {
					// nothing to do
				} else {
					builder.Append (", out int exception_gchandle");
				}
			}

			return builder.ToString ();
		}

		public string CArgumentSignature {
			get { return CFormatArgs ("void", nameOnly: false); }
		}

		public string CArgumentNames {
			get { return CFormatArgs (String.Empty, nameOnly: true); }
		}

		public string MArgumentSignature {
			get { return MFormatArgs ("", nameOnly: false); }
		}

		public string MArgumentNames {
			get { return MFormatArgs (String.Empty, nameOnly: true); }
		}
	}
#>