// included by glib2.pas

{$IFDEF read_forward_definitions}
{ vararg union holding actuall values collected
  }
   PGTypeCValue = ^TGTypeCValue;
   TGTypeCValue = record
       case longint of
          0 : ( v_int : gint );
          1 : ( v_long : glong );
          2 : ( v_int64 : gint64 );
          3 : ( v_double : gdouble );
          4 : ( v_pointer : gpointer );
       end;
{$ENDIF read_forward_definitions}

//------------------------------------------------------------------------------

{$IFDEF read_interface_rest}

{ we may want to add aggregate types here some day, if requested
   by users. the basic C types are covered already, everything
   smaller than an int is promoted to an integer and floats are
   always promoted to doubles for varargs call constructions.
  }
{< skip > }
const
   G_VALUE_COLLECT_INT = 'i';
   G_VALUE_COLLECT_LONG = 'l';
   G_VALUE_COLLECT_INT64 = 'q';
   G_VALUE_COLLECT_DOUBLE = 'd';
   G_VALUE_COLLECT_POINTER = 'p';

{ G_VALUE_COLLECT() collects a variable argument value
   from a va_list. we have to implement the varargs collection as a
   macro, because on some systems va_list variables cannot be passed
   by reference.
   value is supposed to be initialized according to the value
   type to be collected.
   var_args is the va_list variable and may be evaluated multiple times.
   __error is a gchar   variable that will be modified to hold a g_new()
   allocated error messages if something fails.
  }
(* ToDo: #define G_VALUE_COLLECT(value, var_args, flags, __error)       \
G_STMT_START {                                                                          \
  GValue  _value = (value);                                                             \
  guint _flags = (flags);                                                               \
  GType _value_type = G_VALUE_TYPE (_value);                                            \
  GTypeValueTable  _vtable = g_type_value_table_peek (_value_type);                     \
  gchar  _collect_format = _vtable->collect_format;                                     \
  GTypeCValue _cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, };                \
  guint _n_values = 0;                                                                  \
                                                                                        \
  if (_vtable->value_free)                                                              \
    _vtable->value_free (_value);                                                       \
  _value->g_type = _value_type;         // value_meminit() from gvalue.c                \
  memset (_value->data, 0, sizeof (_value->data));                                      \
  while ( _collect_format)                                                              \
    {                                                                                   \
      GTypeCValue  _cvalue = _cvalues + _n_values++;                                    \
                                                                                        \
      switch ( _collect_format++)                                                       \
        {                                                                               \
        case G_VALUE_COLLECT_INT:                                                       \
          _cvalue->v_int = va_arg ((var_args), gint);                                   \
          break;                                                                        \
        case G_VALUE_COLLECT_LONG:                                                      \
          _cvalue->v_long = va_arg ((var_args), glong);                                 \
          break;                                                                        \
        case G_VALUE_COLLECT_INT64:                                                     \
          _cvalue->v_int64 = va_arg ((var_args), gint64);                               \
          break;                                                                        \
        case G_VALUE_COLLECT_DOUBLE:                                                    \
          _cvalue->v_double = va_arg ((var_args), gdouble);                             \
          break;                                                                        \
        case G_VALUE_COLLECT_POINTER:                                                   \
          _cvalue->v_pointer = va_arg ((var_args), gpointer);                           \
          break;                                                                        \
        default:                                                                        \
          g_assert_not_reached ();                                                      \
        }                                                                               \
    }                                                                                   \
   (__error) = _vtable->collect_value (_value,                                          \
                                       _n_values,                                       \
                                       _cvalues,                                        \
                                       _flags);                                         \
} G_STMT_END
*)



{ G_VALUE_LCOPY() collects a value's variable argument
   locations from a va_list. usage is analogous to G_VALUE_COLLECT().
  }
(* ToDo: #define G_VALUE_LCOPY(value, var_args, flags, __error) \
G_STMT_START {                                                                          \
  const GValue  _value = (value);                                                       \
  guint _flags = (flags);                                                               \
  GType _value_type = G_VALUE_TYPE (_value);                                            \
  GTypeValueTable  _vtable = g_type_value_table_peek (_value_type);                     \
  gchar  _lcopy_format = _vtable->lcopy_format;                                         \
  GTypeCValue _cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, };                \
  guint _n_values = 0;                                                                  \
                                                                                        \
  while ( _lcopy_format)                                                                \
    {                                                                                   \
      GTypeCValue  _cvalue = _cvalues + _n_values++;                                    \
                                                                                        \
      switch ( _lcopy_format++)                                                         \
        {                                                                               \
        case G_VALUE_COLLECT_INT:                                                       \
          _cvalue->v_int = va_arg ((var_args), gint);                                   \
          break;                                                                        \
        case G_VALUE_COLLECT_LONG:                                                      \
          _cvalue->v_long = va_arg ((var_args), glong);                                 \
          break;                                                                        \
        case G_VALUE_COLLECT_INT64:                                                     \
          _cvalue->v_int64 = va_arg ((var_args), gint64);                               \
          break;                                                                        \
        case G_VALUE_COLLECT_DOUBLE:                                                    \
          _cvalue->v_double = va_arg ((var_args), gdouble);                             \
          break;                                                                        \
        case G_VALUE_COLLECT_POINTER:                                                   \
          _cvalue->v_pointer = va_arg ((var_args), gpointer);                           \
          break;                                                                        \
        default:                                                                        \
          g_assert_not_reached ();                                                      \
        }                                                                               \
    }                                                                                   \
   (__error) = _vtable->lcopy_value (_value,                                            \
                                     _n_values,                                         \
                                     _cvalues,                                          \
                                     _flags);                                           \
} G_STMT_END
*)

const
   G_VALUE_COLLECT_FORMAT_MAX_LENGTH = 8;

{$ENDIF read_interface_rest}
// included by glib2.pas

