1/* GObject - GLib Type, Object, Parameter and Signal Library
2 * Copyright (C) 1998-1999, 2000-2001 Tim Janik and Red Hat, Inc.
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General
15 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 *
17 * gvaluecollector.h: GValue varargs stubs
18 */
19/**
20 * SECTION:value_collection
21 * @Short_description: Converting varargs to generic values
22 * @Title: Varargs Value Collection
23 *
24 * The macros in this section provide the varargs parsing support needed
25 * in variadic GObject functions such as g_object_new() or g_object_set().
26 * They currently support the collection of integral types, floating point
27 * types and pointers.
28 */
29#ifndef __G_VALUE_COLLECTOR_H__
30#define __G_VALUE_COLLECTOR_H__
31
32#include <glib-object.h>
33
34G_BEGIN_DECLS
35
36/* we may want to add aggregate types here some day, if requested
37 * by users. the basic C types are covered already, everything
38 * smaller than an int is promoted to an integer and floats are
39 * always promoted to doubles for varargs call constructions.
40 */
41enum /*< skip >*/
42{
43 G_VALUE_COLLECT_INT = 'i',
44 G_VALUE_COLLECT_LONG = 'l',
45 G_VALUE_COLLECT_INT64 = 'q',
46 G_VALUE_COLLECT_DOUBLE = 'd',
47 G_VALUE_COLLECT_POINTER = 'p'
48};
49
50
51/* vararg union holding actual values collected
52 */
53/**
54 * GTypeCValue:
55 * @v_int: the field for holding integer values
56 * @v_long: the field for holding long integer values
57 * @v_int64: the field for holding 64 bit integer values
58 * @v_double: the field for holding floating point values
59 * @v_pointer: the field for holding pointers
60 *
61 * A union holding one collected value.
62 */
63union _GTypeCValue
64{
65 gint v_int;
66 glong v_long;
67 gint64 v_int64;
68 gdouble v_double;
69 gpointer v_pointer;
70};
71
72/**
73 * G_VALUE_COLLECT_INIT:
74 * @value: a #GValue return location. @value must contain only 0 bytes.
75 * @_value_type: the #GType to use for @value.
76 * @var_args: the va_list variable; it may be evaluated multiple times
77 * @flags: flags which are passed on to the collect_value() function of
78 * the #GTypeValueTable of @value.
79 * @__error: a #gchar** variable that will be modified to hold a g_new()
80 * allocated error messages if something fails
81 *
82 * Collects a variable argument value from a va_list. We have to
83 * implement the varargs collection as a macro, because on some systems
84 * va_list variables cannot be passed by reference.
85 *
86 * Since: 2.24
87 */
88#define G_VALUE_COLLECT_INIT(value, _value_type, var_args, flags, __error) \
89G_STMT_START { \
90 GValue *g_vci_val = (value); \
91 guint g_vci_flags = (flags); \
92 GTypeValueTable *g_vci_vtab = g_type_value_table_peek (_value_type); \
93 const gchar *g_vci_collect_format = g_vci_vtab->collect_format; \
94 GTypeCValue g_vci_cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, }; \
95 guint g_vci_n_values = 0; \
96 \
97 g_vci_val->g_type = _value_type; /* value_meminit() from gvalue.c */ \
98 while (*g_vci_collect_format) \
99 { \
100 GTypeCValue *g_vci_cvalue = g_vci_cvalues + g_vci_n_values++; \
101 \
102 switch (*g_vci_collect_format++) \
103 { \
104 case G_VALUE_COLLECT_INT: \
105 g_vci_cvalue->v_int = va_arg ((var_args), gint); \
106 break; \
107 case G_VALUE_COLLECT_LONG: \
108 g_vci_cvalue->v_long = va_arg ((var_args), glong); \
109 break; \
110 case G_VALUE_COLLECT_INT64: \
111 g_vci_cvalue->v_int64 = va_arg ((var_args), gint64); \
112 break; \
113 case G_VALUE_COLLECT_DOUBLE: \
114 g_vci_cvalue->v_double = va_arg ((var_args), gdouble); \
115 break; \
116 case G_VALUE_COLLECT_POINTER: \
117 g_vci_cvalue->v_pointer = va_arg ((var_args), gpointer); \
118 break; \
119 default: \
120 g_assert_not_reached (); \
121 } \
122 } \
123 *(__error) = g_vci_vtab->collect_value (g_vci_val, \
124 g_vci_n_values, \
125 g_vci_cvalues, \
126 g_vci_flags); \
127} G_STMT_END
128
129/**
130 * G_VALUE_COLLECT:
131 * @value: a #GValue return location. @value is supposed to be initialized
132 * according to the value type to be collected
133 * @var_args: the va_list variable; it may be evaluated multiple times
134 * @flags: flags which are passed on to the collect_value() function of
135 * the #GTypeValueTable of @value.
136 * @__error: a #gchar** variable that will be modified to hold a g_new()
137 * allocated error messages if something fails
138 *
139 * Collects a variable argument value from a va_list. We have to
140 * implement the varargs collection as a macro, because on some systems
141 * va_list variables cannot be passed by reference.
142 *
143 * Note: If you are creating the @value argument just before calling this macro,
144 * you should use the #G_VALUE_COLLECT_INIT variant and pass the unitialized
145 * #GValue. That variant is faster than #G_VALUE_COLLECT.
146 */
147#define G_VALUE_COLLECT(value, var_args, flags, __error) G_STMT_START { \
148 GValue *g_vc_value = (value); \
149 GType g_vc_value_type = G_VALUE_TYPE (g_vc_value); \
150 GTypeValueTable *g_vc_vtable = g_type_value_table_peek (g_vc_value_type); \
151 \
152 if (g_vc_vtable->value_free) \
153 g_vc_vtable->value_free (g_vc_value); \
154 memset (g_vc_value->data, 0, sizeof (g_vc_value->data)); \
155 \
156 G_VALUE_COLLECT_INIT(value, g_vc_value_type, var_args, flags, __error); \
157} G_STMT_END
158
159/**
160 * G_VALUE_COLLECT_SKIP:
161 * @_value_type: the #GType of the value to skip
162 * @var_args: the va_list variable; it may be evaluated multiple times
163 *
164 * Skip an argument of type @_value_type from @var_args.
165 */
166#define G_VALUE_COLLECT_SKIP(_value_type, var_args) \
167G_STMT_START { \
168 GTypeValueTable *g_vcs_vtable = g_type_value_table_peek (_value_type); \
169 const gchar *g_vcs_collect_format = g_vcs_vtable->collect_format; \
170 \
171 while (*g_vcs_collect_format) \
172 { \
173 switch (*g_vcs_collect_format++) \
174 { \
175 case G_VALUE_COLLECT_INT: \
176 va_arg ((var_args), gint); \
177 break; \
178 case G_VALUE_COLLECT_LONG: \
179 va_arg ((var_args), glong); \
180 break; \
181 case G_VALUE_COLLECT_INT64: \
182 va_arg ((var_args), gint64); \
183 break; \
184 case G_VALUE_COLLECT_DOUBLE: \
185 va_arg ((var_args), gdouble); \
186 break; \
187 case G_VALUE_COLLECT_POINTER: \
188 va_arg ((var_args), gpointer); \
189 break; \
190 default: \
191 g_assert_not_reached (); \
192 } \
193 } \
194} G_STMT_END
195
196/**
197 * G_VALUE_LCOPY:
198 * @value: a #GValue to store into the @var_args; this must be initialized
199 * and set
200 * @var_args: the va_list variable; it may be evaluated multiple times
201 * @flags: flags which are passed on to the lcopy_value() function of
202 * the #GTypeValueTable of @value.
203 * @__error: a #gchar** variable that will be modified to hold a g_new()
204 * allocated error message if something fails
205 *
206 * Stores a value’s value into one or more argument locations from a va_list.
207 * This is the inverse of G_VALUE_COLLECT().
208 */
209#define G_VALUE_LCOPY(value, var_args, flags, __error) \
210G_STMT_START { \
211 const GValue *g_vl_value = (value); \
212 guint g_vl_flags = (flags); \
213 GType g_vl_value_type = G_VALUE_TYPE (g_vl_value); \
214 GTypeValueTable *g_vl_vtable = g_type_value_table_peek (g_vl_value_type); \
215 const gchar *g_vl_lcopy_format = g_vl_vtable->lcopy_format; \
216 GTypeCValue g_vl_cvalues[G_VALUE_COLLECT_FORMAT_MAX_LENGTH] = { { 0, }, }; \
217 guint g_vl_n_values = 0; \
218 \
219 while (*g_vl_lcopy_format) \
220 { \
221 GTypeCValue *g_vl_cvalue = g_vl_cvalues + g_vl_n_values++; \
222 \
223 switch (*g_vl_lcopy_format++) \
224 { \
225 case G_VALUE_COLLECT_INT: \
226 g_vl_cvalue->v_int = va_arg ((var_args), gint); \
227 break; \
228 case G_VALUE_COLLECT_LONG: \
229 g_vl_cvalue->v_long = va_arg ((var_args), glong); \
230 break; \
231 case G_VALUE_COLLECT_INT64: \
232 g_vl_cvalue->v_int64 = va_arg ((var_args), gint64); \
233 break; \
234 case G_VALUE_COLLECT_DOUBLE: \
235 g_vl_cvalue->v_double = va_arg ((var_args), gdouble); \
236 break; \
237 case G_VALUE_COLLECT_POINTER: \
238 g_vl_cvalue->v_pointer = va_arg ((var_args), gpointer); \
239 break; \
240 default: \
241 g_assert_not_reached (); \
242 } \
243 } \
244 *(__error) = g_vl_vtable->lcopy_value (g_vl_value, \
245 g_vl_n_values, \
246 g_vl_cvalues, \
247 g_vl_flags); \
248} G_STMT_END
249
250
251/**
252 * G_VALUE_COLLECT_FORMAT_MAX_LENGTH:
253 *
254 * The maximal number of #GTypeCValues which can be collected for a
255 * single #GValue.
256 */
257#define G_VALUE_COLLECT_FORMAT_MAX_LENGTH (8)
258
259G_END_DECLS
260
261#endif /* __G_VALUE_COLLECTOR_H__ */
262