/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
 * GObject introspection: Callable implementation
 *
 * Copyright (C) 2005 Matthias Clasen
 * Copyright (C) 2008,2009 Red Hat, Inc.
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */

#include "config.h"

#include <stdlib.h>

#include <glib.h>

#include <girepository/girepository.h>
#include "gibaseinfo-private.h"
#include "girepository-private.h"
#include "gitypelib-internal.h"
#include "girffi.h"
#include "gicallableinfo.h"

/* GICallableInfo functions */

/**
 * GICallableInfo:
 *
 * `GICallableInfo` represents an entity which is callable.
 *
 * Examples of callable are:
 *
 *  - functions ([class@GIRepository.FunctionInfo])
 *  - virtual functions ([class@GIRepository.VFuncInfo])
 *  - callbacks ([class@GIRepository.CallbackInfo]).
 *
 * A callable has a list of arguments ([class@GIRepository.ArgInfo]), a return
 * type, direction and a flag which decides if it returns `NULL`.
 *
 * Since: 2.80
 */

static uint32_t
signature_offset (GICallableInfo *info)
{
  GIRealInfo *rinfo = (GIRealInfo*)info;
  int sigoff = -1;

  switch (gi_base_info_get_info_type ((GIBaseInfo *) info))
    {
    case GI_INFO_TYPE_FUNCTION:
      sigoff = G_STRUCT_OFFSET (FunctionBlob, signature);
      break;
    case GI_INFO_TYPE_VFUNC:
      sigoff = G_STRUCT_OFFSET (VFuncBlob, signature);
      break;
    case GI_INFO_TYPE_CALLBACK:
      sigoff = G_STRUCT_OFFSET (CallbackBlob, signature);
      break;
    case GI_INFO_TYPE_SIGNAL:
      sigoff = G_STRUCT_OFFSET (SignalBlob, signature);
      break;
    default:
      g_assert_not_reached ();
    }
  if (sigoff >= 0)
    return *(uint32_t *)&rinfo->typelib->data[rinfo->offset + sigoff];
  return 0;
}

/**
 * gi_callable_info_can_throw_gerror:
 * @info: a #GICallableInfo
 *
 * Whether the callable can throw a [type@GLib.Error]
 *
 * Returns: `TRUE` if this `GICallableInfo` can throw a [type@GLib.Error]
 * Since: 2.80
 */
gboolean
gi_callable_info_can_throw_gerror (GICallableInfo *info)
{
  GIRealInfo *rinfo = (GIRealInfo*)info;
  SignatureBlob *signature;

  signature = (SignatureBlob *)&rinfo->typelib->data[signature_offset (info)];
  if (signature->throws)
    return TRUE;

  /* Functions and VFuncs store "throws" in their own blobs.
   * This info was additionally added to the SignatureBlob
   * to support the other callables. For Functions and VFuncs,
   * also check their legacy flag for compatibility.
   */
  switch (gi_base_info_get_info_type ((GIBaseInfo *) info)) {
  case GI_INFO_TYPE_FUNCTION:
    {
      FunctionBlob *blob;
      blob = (FunctionBlob *)&rinfo->typelib->data[rinfo->offset];
      return blob->throws;
    }
  case GI_INFO_TYPE_VFUNC:
    {
      VFuncBlob *blob;
      blob = (VFuncBlob *)&rinfo->typelib->data[rinfo->offset];
      return blob->throws;
    }
  case GI_INFO_TYPE_CALLBACK:
  case GI_INFO_TYPE_SIGNAL:
    return FALSE;
  default:
    g_assert_not_reached ();
  }
}

/**
 * gi_callable_info_is_method:
 * @info: a #GICallableInfo
 *
 * Determines if the callable info is a method.
 *
 * For [class@GIRepository.VFuncInfo]s, [class@GIRepository.CallbackInfo]s, and
 * [class@GIRepository.SignalInfo]s, this is always true. Otherwise, this looks
 * at the `GI_FUNCTION_IS_METHOD` flag on the [class@GIRepository.FunctionInfo].
 *
 * Concretely, this function returns whether
 * [method@GIRepository.CallableInfo.get_n_args] matches the number of arguments
 * in the raw C method. For methods, there is one more C argument than is
 * exposed by introspection: the `self` or `this` object.
 *
 * Returns: `TRUE` if @info is a method, `FALSE` otherwise
 * Since: 2.80
 */
gboolean
gi_callable_info_is_method (GICallableInfo *info)
{
  GIRealInfo *rinfo = (GIRealInfo*)info;
  switch (gi_base_info_get_info_type ((GIBaseInfo *) info)) {
  case GI_INFO_TYPE_FUNCTION:
    {
      FunctionBlob *blob;
      blob = (FunctionBlob *)&rinfo->typelib->data[rinfo->offset];
      return (!blob->constructor && !blob->is_static);
    }
  case GI_INFO_TYPE_VFUNC:
  case GI_INFO_TYPE_SIGNAL:
    return TRUE;
  case GI_INFO_TYPE_CALLBACK:
    return FALSE;
  default:
    g_assert_not_reached ();
  }
}

/**
 * gi_callable_info_get_return_type:
 * @info: a #GICallableInfo
 *
 * Obtain the return type of a callable item as a [class@GIRepository.TypeInfo].
 *
 * If the callable doesn’t return anything, a [class@GIRepository.TypeInfo] of
 * type [enum@GIRepository.TypeTag.VOID] will be returned.
 *
 * Returns: (transfer full): the [class@GIRepository.TypeInfo]. Free the struct
 *   by calling [method@GIRepository.BaseInfo.unref] when done.
 * Since: 2.80
 */
GITypeInfo *
gi_callable_info_get_return_type (GICallableInfo *info)
{
  GIRealInfo *rinfo = (GIRealInfo *)info;
  uint32_t offset;

  g_return_val_if_fail (info != NULL, NULL);
  g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), NULL);

  offset = signature_offset (info);

  return gi_type_info_new ((GIBaseInfo*)info, rinfo->typelib, offset);
}

/**
 * gi_callable_info_load_return_type:
 * @info: a #GICallableInfo
 * @type: (out caller-allocates): Initialized with return type of @info
 *
 * Obtain information about a return value of callable; this
 * function is a variant of [method@GIRepository.CallableInfo.get_return_type]
 * designed for stack allocation.
 *
 * The initialized @type must not be referenced after @info is deallocated.
 *
 * Once you are done with @type, it must be cleared using
 * [method@GIRepository.BaseInfo.clear].
 *
 * Since: 2.80
 */
void
gi_callable_info_load_return_type (GICallableInfo *info,
                                   GITypeInfo     *type)
{
  GIRealInfo *rinfo = (GIRealInfo *)info;
  uint32_t offset;

  g_return_if_fail (info != NULL);
  g_return_if_fail (GI_IS_CALLABLE_INFO (info));

  offset = signature_offset (info);

  gi_type_info_init (type, (GIBaseInfo*)info, rinfo->typelib, offset);
}

/**
 * gi_callable_info_may_return_null:
 * @info: a #GICallableInfo
 *
 * See if a callable could return `NULL`.
 *
 * Returns: `TRUE` if callable could return `NULL`
 * Since: 2.80
 */
gboolean
gi_callable_info_may_return_null (GICallableInfo *info)
{
  GIRealInfo *rinfo = (GIRealInfo *)info;
  SignatureBlob *blob;

  g_return_val_if_fail (info != NULL, FALSE);
  g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), FALSE);

  blob = (SignatureBlob *)&rinfo->typelib->data[signature_offset (info)];

  return blob->may_return_null;
}

/**
 * gi_callable_info_skip_return:
 * @info: a #GICallableInfo
 *
 * See if a callable’s return value is only useful in C.
 *
 * Returns: `TRUE` if return value is only useful in C.
 * Since: 2.80
 */
gboolean
gi_callable_info_skip_return (GICallableInfo *info)
{
  GIRealInfo *rinfo = (GIRealInfo *)info;
  SignatureBlob *blob;

  g_return_val_if_fail (info != NULL, FALSE);
  g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), FALSE);

  blob = (SignatureBlob *)&rinfo->typelib->data[signature_offset (info)];

  return blob->skip_return;
}

/**
 * gi_callable_info_get_caller_owns:
 * @info: a #GICallableInfo
 *
 * See whether the caller owns the return value of this callable.
 *
 * [type@GIRepository.Transfer] contains a list of possible transfer values.
 *
 * Returns: the transfer mode for the return value of the callable
 * Since: 2.80
 */
GITransfer
gi_callable_info_get_caller_owns (GICallableInfo *info)
{
  GIRealInfo *rinfo = (GIRealInfo*) info;
  SignatureBlob *blob;

  g_return_val_if_fail (info != NULL, -1);
  g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), -1);

  blob = (SignatureBlob *)&rinfo->typelib->data[signature_offset (info)];

  if (blob->caller_owns_return_value)
    return GI_TRANSFER_EVERYTHING;
  else if (blob->caller_owns_return_container)
    return GI_TRANSFER_CONTAINER;
  else
    return GI_TRANSFER_NOTHING;
}

/**
 * gi_callable_info_get_instance_ownership_transfer:
 * @info: a #GICallableInfo
 *
 * Obtains the ownership transfer for the instance argument.
 *
 * [type@GIRepository.Transfer] contains a list of possible transfer values.
 *
 * Returns: the transfer mode of the instance argument
 * Since: 2.80
 */
GITransfer
gi_callable_info_get_instance_ownership_transfer (GICallableInfo *info)
{
  GIRealInfo *rinfo = (GIRealInfo*) info;
  SignatureBlob *blob;

  g_return_val_if_fail (info != NULL, -1);
  g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), -1);

  blob = (SignatureBlob *)&rinfo->typelib->data[signature_offset (info)];

  if (blob->instance_transfer_ownership)
    return GI_TRANSFER_EVERYTHING;
  else
    return GI_TRANSFER_NOTHING;
}

/**
 * gi_callable_info_get_n_args:
 * @info: a #GICallableInfo
 *
 * Obtain the number of arguments (both ‘in’ and ‘out’) for this callable.
 *
 * Returns: The number of arguments this callable expects.
 * Since: 2.80
 */
unsigned int
gi_callable_info_get_n_args (GICallableInfo *info)
{
  GIRealInfo *rinfo = (GIRealInfo *)info;
  uint32_t offset;
  SignatureBlob *blob;

  g_return_val_if_fail (info != NULL, -1);
  g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), -1);

  offset = signature_offset (info);
  blob = (SignatureBlob *)&rinfo->typelib->data[offset];

  return blob->n_arguments;
}

/**
 * gi_callable_info_get_arg:
 * @info: a #GICallableInfo
 * @n: the argument index to fetch
 *
 * Obtain information about a particular argument of this callable.
 *
 * Returns: (transfer full): the [class@GIRepository.ArgInfo]. Free it with
 *   [method@GIRepository.BaseInfo.unref] when done.
 * Since: 2.80
 */
GIArgInfo *
gi_callable_info_get_arg (GICallableInfo *info,
                          unsigned int    n)
{
  GIRealInfo *rinfo = (GIRealInfo *)info;
  Header *header;
  uint32_t offset;

  g_return_val_if_fail (info != NULL, NULL);
  g_return_val_if_fail (GI_IS_CALLABLE_INFO (info), NULL);
  g_return_val_if_fail (n <= G_MAXUINT16, NULL);

  offset = signature_offset (info);
  header = (Header *)rinfo->typelib->data;

  return (GIArgInfo *) gi_base_info_new (GI_INFO_TYPE_ARG, (GIBaseInfo*)info, rinfo->typelib,
                                         offset + header->signature_blob_size + n * header->arg_blob_size);
}

/**
 * gi_callable_info_load_arg:
 * @info: a #GICallableInfo
 * @n: the argument index to fetch
 * @arg: (out caller-allocates): Initialize with argument number @n
 *
 * Obtain information about a particular argument of this callable; this
 * function is a variant of [method@GIRepository.CallableInfo.get_arg] designed
 * for stack allocation.
 *
 * The initialized @arg must not be referenced after @info is deallocated.
 *
 * Once you are done with @arg, it must be cleared using
 * [method@GIRepository.BaseInfo.clear].
 *
 * Since: 2.80
 */
void
gi_callable_info_load_arg (GICallableInfo *info,
                           unsigned int    n,
                           GIArgInfo      *arg)
{
  GIRealInfo *rinfo = (GIRealInfo *)info;
  Header *header;
  uint32_t offset;

  g_return_if_fail (info != NULL);
  g_return_if_fail (GI_IS_CALLABLE_INFO (info));
  g_return_if_fail (n <= G_MAXUINT16);

  offset = signature_offset (info);
  header = (Header *)rinfo->typelib->data;

  gi_info_init ((GIRealInfo*)arg, GI_TYPE_ARG_INFO, rinfo->repository, (GIBaseInfo*)info, rinfo->typelib,
                offset + header->signature_blob_size + n * header->arg_blob_size);
}

/**
 * gi_callable_info_get_return_attribute:
 * @info: a #GICallableInfo
 * @name: a freeform string naming an attribute
 *
 * Retrieve an arbitrary attribute associated with the return value.
 *
 * Returns: (nullable): The value of the attribute, or `NULL` if no such
 *   attribute exists
 * Since: 2.80
 */
const char *
gi_callable_info_get_return_attribute (GICallableInfo *info,
                                       const char     *name)
{
  GIAttributeIter iter = GI_ATTRIBUTE_ITER_INIT;
  const char *curname, *curvalue;
  while (gi_callable_info_iterate_return_attributes (info, &iter, &curname, &curvalue))
    {
      if (g_strcmp0 (name, curname) == 0)
        return (const char*) curvalue;
    }

  return NULL;
}

/**
 * gi_callable_info_iterate_return_attributes:
 * @info: a #GICallableInfo
 * @iterator: (inout): a [type@GIRepository.AttributeIter] structure, must be
 *   initialized; see below
 * @name: (out) (transfer none): Returned name, must not be freed
 * @value: (out) (transfer none): Returned name, must not be freed
 *
 * Iterate over all attributes associated with the return value.
 *
 * The iterator structure is typically stack allocated, and must have its
 * first member initialized to `NULL`.
 *
 * Both the @name and @value should be treated as constants
 * and must not be freed.
 *
 * See [method@GIRepository.BaseInfo.iterate_attributes] for an example of how
 * to use a similar API.
 *
 * Returns: `TRUE` if there are more attributes
 * Since: 2.80
 */
gboolean
gi_callable_info_iterate_return_attributes (GICallableInfo   *info,
                                            GIAttributeIter  *iterator,
                                            const char      **name,
                                            const char      **value)
{
  GIRealInfo *rinfo = (GIRealInfo *)info;
  Header *header = (Header *)rinfo->typelib->data;
  AttributeBlob *next, *after;
  uint32_t blob_offset;

  after = (AttributeBlob *) &rinfo->typelib->data[header->attributes +
                                                  header->n_attributes * header->attribute_blob_size];

  blob_offset = signature_offset (info);

  if (iterator->data != NULL)
    next = (AttributeBlob *) iterator->data;
  else
    next = _attribute_blob_find_first ((GIBaseInfo *) info, blob_offset);

  if (next == NULL || next->offset != blob_offset || next >= after)
    return FALSE;

  *name = gi_typelib_get_string (rinfo->typelib, next->name);
  *value = gi_typelib_get_string (rinfo->typelib, next->value);
  iterator->data = next + 1;

  return TRUE;
}

/**
 * gi_type_tag_extract_ffi_return_value:
 * @return_tag: [type@GIRepository.TypeTag] of the return value
 * @interface_type: [type@GObject.Type] of the underlying interface type
 * @ffi_value: pointer to [type@GIRepository.FFIReturnValue] union containing
 *   the return value from `ffi_call()`
 * @arg: (out caller-allocates): pointer to an allocated
 *   [class@GIRepository.Argument]
 *
 * Extract the correct bits from an `ffi_arg` return value into
 * [class@GIRepository.Argument].
 *
 * See: https://bugzilla.gnome.org/show_bug.cgi?id=665152
 *
 * Also see [`ffi_call()`](man:ffi_call(3)): the storage requirements for return
 * values are ‘special’.
 *
 * The @interface_type argument only applies if @return_tag is
 * `GI_TYPE_TAG_INTERFACE`. Otherwise it is ignored.
 *
 * Since: 2.80
 */
void
gi_type_tag_extract_ffi_return_value (GITypeTag         return_tag,
                                      GType             interface_type,
                                      GIFFIReturnValue *ffi_value,
                                      GIArgument       *arg)
{
    switch (return_tag) {
    case GI_TYPE_TAG_INT8:
        arg->v_int8 = (int8_t) ffi_value->v_long;
        break;
    case GI_TYPE_TAG_UINT8:
        arg->v_uint8 = (uint8_t) ffi_value->v_ulong;
        break;
    case GI_TYPE_TAG_INT16:
        arg->v_int16 = (int16_t) ffi_value->v_long;
        break;
    case GI_TYPE_TAG_UINT16:
        arg->v_uint16 = (uint16_t) ffi_value->v_ulong;
        break;
    case GI_TYPE_TAG_INT32:
        arg->v_int32 = (int32_t) ffi_value->v_long;
        break;
    case GI_TYPE_TAG_UINT32:
    case GI_TYPE_TAG_BOOLEAN:
    case GI_TYPE_TAG_UNICHAR:
        arg->v_uint32 = (uint32_t) ffi_value->v_ulong;
        break;
    case GI_TYPE_TAG_INT64:
        arg->v_int64 = (int64_t) ffi_value->v_int64;
        break;
    case GI_TYPE_TAG_UINT64:
        arg->v_uint64 = (uint64_t) ffi_value->v_uint64;
        break;
    case GI_TYPE_TAG_FLOAT:
        arg->v_float = ffi_value->v_float;
        break;
    case GI_TYPE_TAG_DOUBLE:
        arg->v_double = ffi_value->v_double;
        break;
    case GI_TYPE_TAG_INTERFACE:
        if (interface_type == GI_TYPE_ENUM_INFO ||
            interface_type == GI_TYPE_FLAGS_INFO)
          arg->v_int32 = (int32_t) ffi_value->v_long;
        else
          arg->v_pointer = (void *) ffi_value->v_pointer;
        break;
    default:
        arg->v_pointer = (void *) ffi_value->v_pointer;
        break;
    }
}

/**
 * gi_type_info_extract_ffi_return_value:
 * @return_info: [type@GIRepository.TypeInfo] describing the return type
 * @ffi_value: pointer to [type@GIRepository.FFIReturnValue] union containing
 *   the return value from `ffi_call()`
 * @arg: (out caller-allocates): pointer to an allocated
 *   [class@GIRepository.Argument]
 *
 * Extract the correct bits from an `ffi_arg` return value into
 * [class@GIRepository.Argument].
 *
 * See: https://bugzilla.gnome.org/show_bug.cgi?id=665152
 *
 * Also see [`ffi_call()`](man:ffi_call(3)): the storage requirements for return
 * values are ‘special’.
 *
 * Since: 2.80
 */
void
gi_type_info_extract_ffi_return_value (GITypeInfo       *return_info,
                                       GIFFIReturnValue *ffi_value,
                                       GIArgument       *arg)
{
  GITypeTag return_tag = gi_type_info_get_tag (return_info);
  GType interface_type = G_TYPE_INVALID;

  if (return_tag == GI_TYPE_TAG_INTERFACE)
    {
      GIBaseInfo *interface_info = gi_type_info_get_interface (return_info);
      interface_type = G_TYPE_FROM_INSTANCE (interface_info);
      gi_base_info_unref (interface_info);
    }

  gi_type_tag_extract_ffi_return_value (return_tag, interface_type,
                                        ffi_value, arg);
}

/**
 * gi_callable_info_invoke:
 * @info: a #GICallableInfo
 * @function: function pointer to call
 * @in_args: (array length=n_in_args): array of ‘in’ arguments
 * @n_in_args: number of arguments in @in_args
 * @out_args: (array length=n_out_args): array of ‘out’ arguments allocated by
 *   the caller, to be populated with outputted values
 * @n_out_args: number of arguments in @out_args
 * @return_value: (out caller-allocates) (not optional) (nullable): return
 *   location for the return value from the callable; `NULL` may be returned if
 *   the callable returns that
 * @error: return location for a [type@GLib.Error], or `NULL`
 *
 * Invoke the given `GICallableInfo` by calling the given @function pointer.
 *
 * The set of arguments passed to @function will be constructed according to the
 * introspected type of the `GICallableInfo`, using @in_args, @out_args
 * and @error.
 *
 * Returns: `TRUE` if the callable was executed successfully and didn’t throw
 *   a [type@GLib.Error]; `FALSE` if @error is set
 * Since: 2.80
 */
gboolean
gi_callable_info_invoke (GICallableInfo    *info,
                         void              *function,
                         const GIArgument  *in_args,
                         size_t             n_in_args,
                         GIArgument        *out_args,
                         size_t             n_out_args,
                         GIArgument        *return_value,
                         GError           **error)
{
  ffi_cif cif;
  ffi_type *rtype;
  ffi_type **atypes;
  GITypeInfo *tinfo;
  GITypeInfo *rinfo;
  GITypeTag rtag;
  GIArgInfo *ainfo;
  size_t n_args, n_invoke_args, in_pos, out_pos, i;
  void **args;
  gboolean success = FALSE;
  GError *local_error = NULL;
  void *error_address = &local_error;
  GIFFIReturnValue ffi_return_value;
  void *return_value_p; /* Will point inside the union return_value */
  gboolean is_method, throws;

  rinfo = gi_callable_info_get_return_type ((GICallableInfo *)info);
  rtype = gi_type_info_get_ffi_type (rinfo);
  rtag = gi_type_info_get_tag(rinfo);
  is_method = gi_callable_info_is_method (info);
  throws = gi_callable_info_can_throw_gerror (info);

  in_pos = 0;
  out_pos = 0;

  n_args = gi_callable_info_get_n_args ((GICallableInfo *)info);
  if (is_method)
    {
      if (n_in_args == 0)
        {
          g_set_error (error,
                       GI_INVOKE_ERROR,
                       GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
                       "Too few \"in\" arguments (handling this)");
          goto out;
        }
      n_invoke_args = n_args+1;
      in_pos++;
    }
  else
    n_invoke_args = n_args;

  if (throws)
    /* Add an argument for the GError */
    n_invoke_args ++;

  atypes = g_alloca (sizeof (ffi_type*) * n_invoke_args);
  args = g_alloca (sizeof (void *) * n_invoke_args);

  if (is_method)
    {
      atypes[0] = &ffi_type_pointer;
      args[0] = (void *) &in_args[0];
    }
  for (i = 0; i < n_args; i++)
    {
      int offset = (is_method ? 1 : 0);
      ainfo = gi_callable_info_get_arg ((GICallableInfo *)info, i);
      switch (gi_arg_info_get_direction (ainfo))
        {
        case GI_DIRECTION_IN:
          tinfo = gi_arg_info_get_type_info (ainfo);
          atypes[i+offset] = gi_type_info_get_ffi_type (tinfo);
          gi_base_info_unref ((GIBaseInfo *)ainfo);
          gi_base_info_unref ((GIBaseInfo *)tinfo);

          if (in_pos >= n_in_args)
            {
              g_set_error (error,
                           GI_INVOKE_ERROR,
                           GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
                           "Too few \"in\" arguments (handling in)");
              goto out;
            }

          args[i+offset] = (void *)&in_args[in_pos];
          in_pos++;

          break;
        case GI_DIRECTION_OUT:
          atypes[i+offset] = &ffi_type_pointer;
          gi_base_info_unref ((GIBaseInfo *)ainfo);

          if (out_pos >= n_out_args)
            {
              g_set_error (error,
                           GI_INVOKE_ERROR,
                           GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
                           "Too few \"out\" arguments (handling out)");
              goto out;
            }

          args[i+offset] = (void *)&out_args[out_pos];
          out_pos++;
          break;
        case GI_DIRECTION_INOUT:
          atypes[i+offset] = &ffi_type_pointer;
          gi_base_info_unref ((GIBaseInfo *)ainfo);

          if (in_pos >= n_in_args)
            {
              g_set_error (error,
                           GI_INVOKE_ERROR,
                           GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
                           "Too few \"in\" arguments (handling inout)");
              goto out;
            }

          if (out_pos >= n_out_args)
            {
              g_set_error (error,
                           GI_INVOKE_ERROR,
                           GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
                           "Too few \"out\" arguments (handling inout)");
              goto out;
            }

          args[i+offset] = (void *)&in_args[in_pos];
          in_pos++;
          out_pos++;
          break;
        default:
          gi_base_info_unref ((GIBaseInfo *)ainfo);
          g_assert_not_reached ();
        }
    }

  if (throws)
    {
      args[n_invoke_args - 1] = &error_address;
      atypes[n_invoke_args - 1] = &ffi_type_pointer;
    }

  if (in_pos < n_in_args)
    {
      g_set_error (error,
                   GI_INVOKE_ERROR,
                   GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
                   "Too many \"in\" arguments (at end)");
      goto out;
    }
  if (out_pos < n_out_args)
    {
      g_set_error (error,
                   GI_INVOKE_ERROR,
                   GI_INVOKE_ERROR_ARGUMENT_MISMATCH,
                   "Too many \"out\" arguments (at end)");
      goto out;
    }

  if (ffi_prep_cif (&cif, FFI_DEFAULT_ABI, n_invoke_args, rtype, atypes) != FFI_OK)
    goto out;

  g_return_val_if_fail (return_value, FALSE);
  /* See comment for GIFFIReturnValue above */
  switch (rtag)
    {
    case GI_TYPE_TAG_FLOAT:
      return_value_p = &ffi_return_value.v_float;
      break;
    case GI_TYPE_TAG_DOUBLE:
      return_value_p = &ffi_return_value.v_double;
      break;
    case GI_TYPE_TAG_INT64:
    case GI_TYPE_TAG_UINT64:
      return_value_p = &ffi_return_value.v_uint64;
      break;
    default:
      return_value_p = &ffi_return_value.v_long;
    }
  ffi_call (&cif, function, return_value_p, args);

  if (local_error)
    {
      g_propagate_error (error, local_error);
      success = FALSE;
    }
  else
    {
      gi_type_info_extract_ffi_return_value (rinfo, &ffi_return_value, return_value);
      success = TRUE;
    }
 out:
  gi_base_info_unref ((GIBaseInfo *)rinfo);
  return success;
}

void
gi_callable_info_class_init (gpointer g_class,
                             gpointer class_data)
{
  GIBaseInfoClass *info_class = g_class;

  info_class->info_type = GI_INFO_TYPE_CALLABLE;
}
