fpcsrc/packages/gtk2/src/glib/gvaluecollector.inc


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

// included by glib2.pas

{$IFDEF read_forward_definitions}
   PGTypeCValue = ^TGTypeCValue;
{$ENDIF read_forward_definitions}


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

{$IFDEF read_interface_types}
   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_interface_types}

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

{$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