redef class MExplicitCall
	redef fun compile_callback_to_c(mmodule, ffi_ccu)
	do
		var mproperty = mproperty.as(MMethod)

		var full_cname = mproperty.build_cname(recv_mtype, mmodule, null, long_signature)
		var friendly_cname = mproperty.build_cname(recv_mtype, mmodule, null, short_signature)
		ffi_ccu.body_decl.add("#define {friendly_cname} {full_cname}\n")
	end
end

redef class MExplicitCall
	private fun compile_extern_callback(v: AbstractCompilerVisitor, ccu: CCompilationUnit, compile_implementation_too: Bool)
	do
		var mproperty = mproperty
		assert mproperty isa MMethod

		# In nitni files, declare internal function as extern
		var full_friendly_csignature = mproperty.build_csignature(recv_mtype, v.compiler.mainmodule, null, long_signature, internal_call_context)
		ccu.header_decl.add("extern {full_friendly_csignature};\n")

		if not compile_implementation_too then return

		# Internally, implement internal function
		var nitni_visitor = v.compiler.new_visitor
		nitni_visitor.frame = v.frame
		var msignature = mproperty.lookup_first_definition(v.compiler.mainmodule, recv_mtype).msignature
		var csignature_blind = mproperty.build_csignature(recv_mtype, v.compiler.mainmodule, null, long_signature, internal_call_context)

		nitni_visitor.add_decl("/* nitni callback for {mproperty.full_name} */")
		nitni_visitor.add_decl("{csignature_blind} \{")

		var vars = new Array[RuntimeVariable]
		var mtype: MType = recv_mtype
		var recv_var = null
		if mproperty.is_init then
			var recv_mtype = recv_mtype
			recv_var = nitni_visitor.init_instance_or_extern(recv_mtype)
			nitni_visitor.add("{mtype.ctype} self /* var self: {mtype} */;")
			nitni_visitor.add("self = {recv_var};")
		else
			mtype = mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
			recv_var = nitni_visitor.var_from_c("self", mtype)
			recv_var = nitni_visitor.box_extern(recv_var, mtype)
		end

		vars.add(recv_var)

		for p in msignature.mparameters do
			var arg_mtype = p.mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
			var arg = nitni_visitor.var_from_c(p.name, arg_mtype)
			arg = nitni_visitor.box_extern(arg, arg_mtype)
			vars.add(arg)
		end

		var ret_var = nitni_visitor.send(mproperty, vars)

		var return_mtype = msignature.return_mtype
		if mproperty.is_init then
			if recv_mtype.mclass.kind != extern_kind then ret_var = recv_var
			return_mtype = recv_mtype
		end
		if return_mtype != null then
			assert ret_var != null
			return_mtype = return_mtype.anchor_to(v.compiler.mainmodule, recv_mtype)
			ret_var = nitni_visitor.autobox(ret_var, return_mtype)
			ret_var = nitni_visitor.unbox_extern(ret_var, return_mtype)
			nitni_visitor.ret_to_c(ret_var, return_mtype)
		end
		nitni_visitor.add("\}")
	end
end

redef class MExplicitCall
	redef fun compile_callback_to_cpp(mmodule, mainmodule)
	do
		var mproperty = mproperty
		assert mproperty isa MMethod

		var cpp_signature = mproperty.build_csignature(recv_mtype, mainmodule, null, short_signature, from_cpp_call_context)
		var ccall = mproperty.build_ccall(recv_mtype, mainmodule, null, long_signature, from_cpp_call_context, null)
		var fc = new CFunction(cpp_signature)
		fc.exprs.add(ccall)
		mmodule.cpp_file.add_local_function( fc )
	end
end

redef class MExplicitCall
	redef fun compile_callback_to_objc(mmodule, mainmodule)
	do
		var mproperty = mproperty
		assert mproperty isa MMethod

		var objc_signature = mproperty.build_csignature(recv_mtype, mainmodule, null, short_signature, from_objc_call_context)
		var ccall = mproperty.build_ccall(recv_mtype, mainmodule, null, long_signature, from_objc_call_context, null)
		var fc = new CFunction(objc_signature)
		fc.exprs.add ccall
		mmodule.objc_file.add_local_function fc
	end
end

redef class MExplicitCall
	redef fun compile_callback_to_java(mmodule, mainmodule, ccu)
	do
		if not mmodule.callbacks_used_from_java.callbacks.has(self) then return

		var mproperty = mproperty
		assert mproperty isa MMethod

		# In C, indirection implementing the Java extern methods
		var csignature = mproperty.build_c_implementation_signature(recv_mtype, mmodule, "___indirect", long_signature, from_java_call_context)
		var cf = new CFunction("JNIEXPORT {csignature}")
		cf.exprs.add "\t{mproperty.build_ccall(recv_mtype, mainmodule, null, long_signature, from_java_call_context, null)}\n"
		ccu.add_non_static_local_function cf

		# In Java, declare the extern method as a private static local method
		var java_signature = mproperty.build_csignature(recv_mtype, mainmodule, null, short_signature, java_call_context)
		mmodule.java_file.class_content.add "private native static {java_signature};\n"
	end

	redef fun jni_methods_declaration(from_mmodule)
	do
		var mproperty = mproperty
		assert mproperty isa MMethod

		var java_name = mproperty.build_cname(recv_mtype, from_mmodule, null, short_signature)
		var jni_format = mproperty.build_jni_format(recv_mtype, from_mmodule)
		var c_name = mproperty.build_cname(recv_mtype, from_mmodule, "___indirect", long_signature)

		return ["""{"{{{java_name}}}", "{{{jni_format}}}", {{{c_name}}}}"""]
	end
end