| blob | f8dd681b827e9ba25d027404840d96babf6a3c4a |
1 <STRUCT>
2 <NAME>GError</NAME>
3 </STRUCT>
4 <STRUCT>
5 <NAME>GError</NAME>
6 struct GError
7 {
8 GQuark domain;
9 gint code;
10 gchar *message;
11 };
12 </STRUCT>
13 <FUNCTION>
14 <NAME>g_error_new</NAME>
15 <RETURNS>GError *</RETURNS>
16 GQuark domain,gint code,const gchar *format,...
17 </FUNCTION>
18 <FUNCTION>
19 <NAME>g_error_new_literal</NAME>
20 <RETURNS>GError *</RETURNS>
21 GQuark domain,gint code,const gchar *message
22 </FUNCTION>
23 <FUNCTION>
24 <NAME>g_error_free</NAME>
25 <RETURNS>void </RETURNS>
26 GError *error
27 </FUNCTION>
28 <FUNCTION>
29 <NAME>g_error_copy</NAME>
30 <RETURNS>GError *</RETURNS>
31 const GError *error
32 </FUNCTION>
33 <FUNCTION>
34 <NAME>g_error_matches</NAME>
35 <RETURNS>gboolean </RETURNS>
36 const GError *error,GQuark domain,gint code
37 </FUNCTION>
38 <FUNCTION>
39 <NAME>g_set_error</NAME>
40 <RETURNS>void </RETURNS>
41 GError **err,GQuark domain,gint code,const gchar *format,...
42 </FUNCTION>
43 <FUNCTION>
44 <NAME>g_propagate_error</NAME>
45 <RETURNS>void </RETURNS>
46 GError **dest,GError *src
47 </FUNCTION>
48 <FUNCTION>
49 <NAME>g_clear_error</NAME>
50 <RETURNS>void </RETURNS>
51 GError **err
52 </FUNCTION>
53 <MACRO>
54 <NAME>G_GNUC_EXTENSION</NAME>
55 # define G_GNUC_EXTENSION __extension__
56 </MACRO>
57 <MACRO>
58 <NAME>G_GNUC_EXTENSION</NAME>
59 # define G_GNUC_EXTENSION
60 </MACRO>
61 <MACRO>
62 <NAME>G_E</NAME>
63 #define G_E 2.7182818284590452354E0
64 </MACRO>
65 <MACRO>
66 <NAME>G_LN2</NAME>
67 #define G_LN2 6.9314718055994530942E-1
68 </MACRO>
69 <MACRO>
70 <NAME>G_LN10</NAME>
71 #define G_LN10 2.3025850929940456840E0
72 </MACRO>
73 <MACRO>
74 <NAME>G_PI</NAME>
75 #define G_PI 3.14159265358979323846E0
76 </MACRO>
77 <MACRO>
78 <NAME>G_PI_2</NAME>
79 #define G_PI_2 1.57079632679489661923E0
80 </MACRO>
81 <MACRO>
82 <NAME>G_PI_4</NAME>
83 #define G_PI_4 0.78539816339744830962E0
84 </MACRO>
85 <MACRO>
86 <NAME>G_SQRT2</NAME>
87 #define G_SQRT2 1.4142135623730950488E0
88 </MACRO>
89 <MACRO>
90 <NAME>G_DIR_SEPARATOR</NAME>
91 #define G_DIR_SEPARATOR '\\'
92 </MACRO>
93 <MACRO>
94 <NAME>G_DIR_SEPARATOR_S</NAME>
95 #define G_DIR_SEPARATOR_S "\\"
96 </MACRO>
97 <MACRO>
98 <NAME>G_SEARCHPATH_SEPARATOR</NAME>
99 #define G_SEARCHPATH_SEPARATOR ';'
100 </MACRO>
101 <MACRO>
102 <NAME>G_SEARCHPATH_SEPARATOR_S</NAME>
103 #define G_SEARCHPATH_SEPARATOR_S ";"
104 </MACRO>
105 <MACRO>
106 <NAME>G_DIR_SEPARATOR</NAME>
107 #define G_DIR_SEPARATOR '/'
108 </MACRO>
109 <MACRO>
110 <NAME>G_DIR_SEPARATOR_S</NAME>
111 #define G_DIR_SEPARATOR_S "/"
112 </MACRO>
113 <MACRO>
114 <NAME>G_SEARCHPATH_SEPARATOR</NAME>
115 #define G_SEARCHPATH_SEPARATOR ':'
116 </MACRO>
117 <MACRO>
118 <NAME>G_SEARCHPATH_SEPARATOR_S</NAME>
119 #define G_SEARCHPATH_SEPARATOR_S ":"
120 </MACRO>
121 <MACRO>
122 <NAME>NULL</NAME>
123 # define NULL (0L)
124 </MACRO>
125 <MACRO>
126 <NAME>NULL</NAME>
127 # define NULL ((void*) 0)
128 </MACRO>
129 <MACRO>
130 <NAME>FALSE</NAME>
131 #define FALSE (0)
132 </MACRO>
133 <MACRO>
134 <NAME>TRUE</NAME>
135 #define TRUE (!FALSE)
136 </MACRO>
137 <MACRO>
138 <NAME>MAX</NAME>
139 #define MAX(a, b) (((a) > (b)) ? (a) : (b))
140 </MACRO>
141 <MACRO>
142 <NAME>MIN</NAME>
143 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
144 </MACRO>
145 <MACRO>
146 <NAME>ABS</NAME>
147 #define ABS(a) (((a) < 0) ? -(a) : (a))
148 </MACRO>
149 <MACRO>
150 <NAME>CLAMP</NAME>
151 #define CLAMP(x, low, high) (((x) > (high)) ? (high) : (((x) < (low)) ? (low) : (x)))
152 </MACRO>
153 <MACRO>
154 <NAME>G_STRINGIFY</NAME>
155 #define G_STRINGIFY(macro_or_string) G_STRINGIFY_ARG (macro_or_string)
156 </MACRO>
157 <MACRO>
158 <NAME>G_STRINGIFY_ARG</NAME>
159 #define G_STRINGIFY_ARG(contents) #contents
160 </MACRO>
161 <MACRO>
162 <NAME>G_STRLOC</NAME>
163 # define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__) ":" __PRETTY_FUNCTION__ "()"
164 </MACRO>
165 <MACRO>
166 <NAME>G_STRLOC</NAME>
167 # define G_STRLOC __FILE__ ":" G_STRINGIFY (__LINE__)
168 </MACRO>
169 <MACRO>
170 <NAME>G_N_ELEMENTS</NAME>
171 #define G_N_ELEMENTS(arr) (sizeof (arr) / sizeof ((arr)[0]))
172 </MACRO>
173 <MACRO>
174 <NAME>G_VA_COPY</NAME>
175 # define G_VA_COPY(ap1, ap2) (*(ap1) = *(ap2))
176 </MACRO>
177 <MACRO>
178 <NAME>G_VA_COPY</NAME>
179 # define G_VA_COPY(ap1, ap2) g_memmove ((ap1), (ap2), sizeof (va_list))
180 </MACRO>
181 <MACRO>
182 <NAME>G_VA_COPY</NAME>
183 # define G_VA_COPY(ap1, ap2) ((ap1) = (ap2))
184 </MACRO>
185 <MACRO>
186 <NAME>G_STRUCT_OFFSET</NAME>
187 #define G_STRUCT_OFFSET(struct_type, member) \
188 ((glong) ((guint8*) &((struct_type*) 0)->member))
189 </MACRO>
190 <MACRO>
191 <NAME>G_STRUCT_MEMBER_P</NAME>
192 #define G_STRUCT_MEMBER_P(struct_p, struct_offset) \
193 ((gpointer) ((guint8*) (struct_p) + (glong) (struct_offset)))
194 </MACRO>
195 <MACRO>
196 <NAME>G_STRUCT_MEMBER</NAME>
197 #define G_STRUCT_MEMBER(member_type, struct_p, struct_offset) \
198 (*(member_type*) G_STRUCT_MEMBER_P ((struct_p), (struct_offset)))
199 </MACRO>
200 <MACRO>
201 <NAME>G_CAN_INLINE</NAME>
202 # define G_CAN_INLINE 1
203 </MACRO>
204 <MACRO>
205 <NAME>inline</NAME>
206 # define inline __inline__
207 </MACRO>
208 <MACRO>
209 <NAME>inline</NAME>
210 # define inline __inline__
211 </MACRO>
212 <MACRO>
213 <NAME>inline</NAME>
214 # define inline __inline
215 </MACRO>
216 <MACRO>
217 <NAME>inline</NAME>
218 # define inline /* don't inline, then */
219 </MACRO>
220 <MACRO>
221 <NAME>G_INLINE_FUNC</NAME>
222 # define G_INLINE_FUNC extern inline
223 </MACRO>
224 <MACRO>
225 <NAME>G_INLINE_FUNC</NAME>
226 # define G_INLINE_FUNC extern
227 </MACRO>
228 <MACRO>
229 <NAME>G_INLINE_FUNC</NAME>
230 # define G_INLINE_FUNC static inline
231 </MACRO>
232 <MACRO>
233 <NAME>G_INLINE_FUNC</NAME>
234 # define G_INLINE_FUNC extern
235 </MACRO>
236 <MACRO>
237 <NAME>G_STMT_START</NAME>
238 # define G_STMT_START (void)(
239 </MACRO>
240 <MACRO>
241 <NAME>G_STMT_END</NAME>
242 # define G_STMT_END )
243 </MACRO>
244 <MACRO>
245 <NAME>G_STMT_START</NAME>
246 # define G_STMT_START if (1)
247 </MACRO>
248 <MACRO>
249 <NAME>G_STMT_END</NAME>
250 # define G_STMT_END else (void)0
251 </MACRO>
252 <MACRO>
253 <NAME>G_STMT_START</NAME>
254 # define G_STMT_START do
255 </MACRO>
256 <MACRO>
257 <NAME>G_STMT_END</NAME>
258 # define G_STMT_END while (0)
259 </MACRO>
260 <MACRO>
261 <NAME>G_GNUC_PRINTF</NAME>
262 #define G_GNUC_PRINTF( format_idx, arg_idx ) \
263 __attribute__((format (printf, format_idx, arg_idx)))
264 </MACRO>
265 <MACRO>
266 <NAME>G_GNUC_SCANF</NAME>
267 #define G_GNUC_SCANF( format_idx, arg_idx ) \
268 __attribute__((format (scanf, format_idx, arg_idx)))
269 </MACRO>
270 <MACRO>
271 <NAME>G_GNUC_FORMAT</NAME>
272 #define G_GNUC_FORMAT( arg_idx ) \
273 __attribute__((format_arg (arg_idx)))
274 </MACRO>
275 <MACRO>
276 <NAME>G_GNUC_NORETURN</NAME>
277 #define G_GNUC_NORETURN \
278 __attribute__((noreturn))
279 </MACRO>
280 <MACRO>
281 <NAME>G_GNUC_CONST</NAME>
282 #define G_GNUC_CONST \
283 __attribute__((const))
284 </MACRO>
285 <MACRO>
286 <NAME>G_GNUC_UNUSED</NAME>
287 #define G_GNUC_UNUSED \
288 __attribute__((unused))
289 </MACRO>
290 <MACRO>
291 <NAME>G_GNUC_PRINTF</NAME>
292 #define G_GNUC_PRINTF( format_idx, arg_idx )
293 </MACRO>
294 <MACRO>
295 <NAME>G_GNUC_SCANF</NAME>
296 #define G_GNUC_SCANF( format_idx, arg_idx )
297 </MACRO>
298 <MACRO>
299 <NAME>G_GNUC_FORMAT</NAME>
300 #define G_GNUC_FORMAT( arg_idx )
301 </MACRO>
302 <MACRO>
303 <NAME>G_GNUC_NORETURN</NAME>
304 #define G_GNUC_NORETURN
305 </MACRO>
306 <MACRO>
307 <NAME>G_GNUC_CONST</NAME>
308 #define G_GNUC_CONST
309 </MACRO>
310 <MACRO>
311 <NAME>G_GNUC_UNUSED</NAME>
312 #define G_GNUC_UNUSED
313 </MACRO>
314 <MACRO>
315 <NAME>G_GNUC_FUNCTION</NAME>
316 #define G_GNUC_FUNCTION __FUNCTION__
317 </MACRO>
318 <MACRO>
319 <NAME>G_GNUC_PRETTY_FUNCTION</NAME>
320 #define G_GNUC_PRETTY_FUNCTION __PRETTY_FUNCTION__
321 </MACRO>
322 <MACRO>
323 <NAME>G_GNUC_FUNCTION</NAME>
324 #define G_GNUC_FUNCTION ""
325 </MACRO>
326 <MACRO>
327 <NAME>G_GNUC_PRETTY_FUNCTION</NAME>
328 #define G_GNUC_PRETTY_FUNCTION ""
329 </MACRO>
330 <MACRO>
331 <NAME>ATEXIT</NAME>
332 # define ATEXIT(proc) g_ATEXIT(proc)
333 </MACRO>
334 <MACRO>
335 <NAME>G_NATIVE_ATEXIT</NAME>
336 # define G_NATIVE_ATEXIT
337 </MACRO>
338 <MACRO>
339 <NAME>G_BREAKPOINT</NAME>
340 #define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("int $03"); }G_STMT_END
341 </MACRO>
342 <MACRO>
343 <NAME>G_BREAKPOINT</NAME>
344 #define G_BREAKPOINT() G_STMT_START{ __asm__ __volatile__ ("bpt"); }G_STMT_END
345 </MACRO>
346 <MACRO>
347 <NAME>G_BREAKPOINT</NAME>
348 #define G_BREAKPOINT()
349 </MACRO>
350 <MACRO>
351 <NAME>g_new</NAME>
352 # define g_new(type, count) (ALLOC (type, count))
353 </MACRO>
354 <MACRO>
355 <NAME>g_new0</NAME>
356 # define g_new0(type, count) (CALLOC (type, count))
357 </MACRO>
358 <MACRO>
359 <NAME>g_renew</NAME>
360 # define g_renew(type, mem, count) (REALLOC (mem, type, count))
361 </MACRO>
362 <MACRO>
363 <NAME>g_new</NAME>
364 # define g_new(type, count) \
365 ((type *) g_malloc ((unsigned) sizeof (type) * (count)))
366 </MACRO>
367 <MACRO>
368 <NAME>g_new0</NAME>
369 # define g_new0(type, count) \
370 ((type *) g_malloc0 ((unsigned) sizeof (type) * (count)))
371 </MACRO>
372 <MACRO>
373 <NAME>g_renew</NAME>
374 # define g_renew(type, mem, count) \
375 ((type *) g_realloc (mem, (unsigned) sizeof (type) * (count)))
376 </MACRO>
377 <MACRO>
378 <NAME>g_mem_chunk_create</NAME>
379 #define g_mem_chunk_create(type, pre_alloc, alloc_type) ( \
380 g_mem_chunk_new (#type " mem chunks (" #pre_alloc ")", \
381 sizeof (type), \
382 sizeof (type) * (pre_alloc), \
383 (alloc_type)) \
384 )
385 </MACRO>
386 <MACRO>
387 <NAME>g_chunk_new</NAME>
388 #define g_chunk_new(type, chunk) ( \
389 (type *) g_mem_chunk_alloc (chunk) \
390 )
391 </MACRO>
392 <MACRO>
393 <NAME>g_chunk_new0</NAME>
394 #define g_chunk_new0(type, chunk) ( \
395 (type *) g_mem_chunk_alloc0 (chunk) \
396 )
397 </MACRO>
398 <MACRO>
399 <NAME>g_chunk_free</NAME>
400 #define g_chunk_free(mem, mem_chunk) G_STMT_START { \
401 g_mem_chunk_free ((mem_chunk), (mem)); \
402 } G_STMT_END
403 </MACRO>
404 <MACRO>
405 <NAME>g_assert</NAME>
406 #define g_assert(expr)
407 </MACRO>
408 <MACRO>
409 <NAME>g_assert_not_reached</NAME>
410 #define g_assert_not_reached()
411 </MACRO>
412 <MACRO>
413 <NAME>g_assert</NAME>
414 #define g_assert(expr) G_STMT_START{ \
415 if (!(expr)) \
416 g_log (G_LOG_DOMAIN, \
417 G_LOG_LEVEL_ERROR, \
418 "file %s: line %d (%s): assertion failed: (%s)", \
419 __FILE__, \
420 __LINE__, \
421 __PRETTY_FUNCTION__, \
422 #expr); }G_STMT_END
423 </MACRO>
424 <MACRO>
425 <NAME>g_assert_not_reached</NAME>
426 #define g_assert_not_reached() G_STMT_START{ \
427 g_log (G_LOG_DOMAIN, \
428 G_LOG_LEVEL_ERROR, \
429 "file %s: line %d (%s): should not be reached", \
430 __FILE__, \
431 __LINE__, \
432 __PRETTY_FUNCTION__); }G_STMT_END
433 </MACRO>
434 <MACRO>
435 <NAME>g_assert</NAME>
436 #define g_assert(expr) G_STMT_START{ \
437 if (!(expr)) \
438 g_log (G_LOG_DOMAIN, \
439 G_LOG_LEVEL_ERROR, \
440 "file %s: line %d: assertion failed: (%s)", \
441 __FILE__, \
442 __LINE__, \
443 #expr); }G_STMT_END
444 </MACRO>
445 <MACRO>
446 <NAME>g_assert_not_reached</NAME>
447 #define g_assert_not_reached() G_STMT_START{ \
448 g_log (G_LOG_DOMAIN, \
449 G_LOG_LEVEL_ERROR, \
450 "file %s: line %d: should not be reached", \
451 __FILE__, \
452 __LINE__); }G_STMT_END
453 </MACRO>
454 <MACRO>
455 <NAME>g_return_if_fail</NAME>
456 #define g_return_if_fail(expr)
457 </MACRO>
458 <MACRO>
459 <NAME>g_return_val_if_fail</NAME>
460 #define g_return_val_if_fail(expr,val)
461 </MACRO>
462 <MACRO>
463 <NAME>g_return_if_reached</NAME>
464 #define g_return_if_reached() return
465 </MACRO>
466 <MACRO>
467 <NAME>g_return_val_if_reached</NAME>
468 #define g_return_val_if_reached(val) return (val)
469 </MACRO>
470 <MACRO>
471 <NAME>g_return_if_fail</NAME>
472 #define g_return_if_fail(expr) G_STMT_START{ \
473 if (!(expr)) \
474 { \
475 g_log (G_LOG_DOMAIN, \
476 G_LOG_LEVEL_CRITICAL, \
477 "file %s: line %d (%s): assertion `%s' failed", \
478 __FILE__, \
479 __LINE__, \
480 __PRETTY_FUNCTION__, \
481 #expr); \
482 return; \
483 }; }G_STMT_END
484 </MACRO>
485 <MACRO>
486 <NAME>g_return_val_if_fail</NAME>
487 #define g_return_val_if_fail(expr,val) G_STMT_START{ \
488 if (!(expr)) \
489 { \
490 g_log (G_LOG_DOMAIN, \
491 G_LOG_LEVEL_CRITICAL, \
492 "file %s: line %d (%s): assertion `%s' failed", \
493 __FILE__, \
494 __LINE__, \
495 __PRETTY_FUNCTION__, \
496 #expr); \
497 return (val); \
498 }; }G_STMT_END
499 </MACRO>
500 <MACRO>
501 <NAME>g_return_if_reached</NAME>
502 #define g_return_if_reached() G_STMT_START{ \
503 g_log (G_LOG_DOMAIN, \
504 G_LOG_LEVEL_CRITICAL, \
505 "file %s: line %d (%s): should not be reached", \
506 __FILE__, \
507 __LINE__, \
508 __PRETTY_FUNCTION__); \
509 return; }G_STMT_END
510 </MACRO>
511 <MACRO>
512 <NAME>g_return_val_if_reached</NAME>
513 #define g_return_val_if_reached(val) G_STMT_START{ \
514 g_log (G_LOG_DOMAIN, \
515 G_LOG_LEVEL_CRITICAL, \
516 "file %s: line %d (%s): should not be reached", \
517 __FILE__, \
518 __LINE__, \
519 __PRETTY_FUNCTION__); \
520 return (val); }G_STMT_END
521 </MACRO>
522 <MACRO>
523 <NAME>g_return_if_fail</NAME>
524 #define g_return_if_fail(expr) G_STMT_START{ \
525 if (!(expr)) \
526 { \
527 g_log (G_LOG_DOMAIN, \
528 G_LOG_LEVEL_CRITICAL, \
529 "file %s: line %d: assertion `%s' failed", \
530 __FILE__, \
531 __LINE__, \
532 #expr); \
533 return; \
534 }; }G_STMT_END
535 </MACRO>
536 <MACRO>
537 <NAME>g_return_val_if_fail</NAME>
538 #define g_return_val_if_fail(expr, val) G_STMT_START{ \
539 if (!(expr)) \
540 { \
541 g_log (G_LOG_DOMAIN, \
542 G_LOG_LEVEL_CRITICAL, \
543 "file %s: line %d: assertion `%s' failed", \
544 __FILE__, \
545 __LINE__, \
546 #expr); \
547 return (val); \
548 }; }G_STMT_END
549 </MACRO>
550 <MACRO>
551 <NAME>g_return_if_reached</NAME>
552 #define g_return_if_reached() G_STMT_START{ \
553 g_log (G_LOG_DOMAIN, \
554 G_LOG_LEVEL_CRITICAL, \
555 "file %s: line %d: should not be reached", \
556 __FILE__, \
557 __LINE__); \
558 return; }G_STMT_END
559 </MACRO>
560 <MACRO>
561 <NAME>g_return_val_if_reached</NAME>
562 #define g_return_val_if_reached(val) G_STMT_START{ \
563 g_log (G_LOG_DOMAIN, \
564 G_LOG_LEVEL_CRITICAL, \
565 "file %s: line %d: should not be reached", \
566 __FILE__, \
567 __LINE__); \
568 return (val); }G_STMT_END
569 </MACRO>
570 <TYPEDEF>
571 <NAME>gchar</NAME>
572 typedef char gchar;
573 </TYPEDEF>
574 <TYPEDEF>
575 <NAME>gshort</NAME>
576 typedef short gshort;
577 </TYPEDEF>
578 <TYPEDEF>
579 <NAME>glong</NAME>
580 typedef long glong;
581 </TYPEDEF>
582 <TYPEDEF>
583 <NAME>gint</NAME>
584 typedef int gint;
585 </TYPEDEF>
586 <TYPEDEF>
587 <NAME>gboolean</NAME>
588 typedef gint gboolean;
589 </TYPEDEF>
590 <TYPEDEF>
591 <NAME>gstring</NAME>
592 typedef gchar* gstring;
593 </TYPEDEF>
594 <TYPEDEF>
595 <NAME>guchar</NAME>
596 typedef unsigned char guchar;
597 </TYPEDEF>
598 <TYPEDEF>
599 <NAME>gushort</NAME>
600 typedef unsigned short gushort;
601 </TYPEDEF>
602 <TYPEDEF>
603 <NAME>gulong</NAME>
604 typedef unsigned long gulong;
605 </TYPEDEF>
606 <TYPEDEF>
607 <NAME>guint</NAME>
608 typedef unsigned int guint;
609 </TYPEDEF>
610 <MACRO>
611 <NAME>G_GSHORT_FORMAT</NAME>
612 #define G_GSHORT_FORMAT "hi"
613 </MACRO>
614 <MACRO>
615 <NAME>G_GUSHORT_FORMAT</NAME>
616 #define G_GUSHORT_FORMAT "hu"
617 </MACRO>
618 <MACRO>
619 <NAME>G_GINT_FORMAT</NAME>
620 #define G_GINT_FORMAT "i"
621 </MACRO>
622 <MACRO>
623 <NAME>G_GUINT_FORMAT</NAME>
624 #define G_GUINT_FORMAT "u"
625 </MACRO>
626 <MACRO>
627 <NAME>G_GLONG_FORMAT</NAME>
628 #define G_GLONG_FORMAT "li"
629 </MACRO>
630 <MACRO>
631 <NAME>G_GULONG_FORMAT</NAME>
632 #define G_GULONG_FORMAT "lu"
633 </MACRO>
634 <TYPEDEF>
635 <NAME>gfloat</NAME>
636 typedef float gfloat;
637 </TYPEDEF>
638 <TYPEDEF>
639 <NAME>gdouble</NAME>
640 typedef double gdouble;
641 </TYPEDEF>
642 <TYPEDEF>
643 <NAME>gldouble</NAME>
644 typedef long double gldouble;
645 </TYPEDEF>
646 <TYPEDEF>
647 <NAME>gldouble</NAME>
648 typedef double gldouble;
649 </TYPEDEF>
650 <TYPEDEF>
651 <NAME>gpointer</NAME>
652 typedef void* gpointer;
653 </TYPEDEF>
654 <TYPEDEF>
655 <NAME>gconstpointer</NAME>
656 typedef const void *gconstpointer;
657 </TYPEDEF>
658 <TYPEDEF>
659 <NAME>GQuark</NAME>
660 typedef guint32 GQuark;
661 </TYPEDEF>
662 <TYPEDEF>
663 <NAME>GTime</NAME>
664 typedef gint32 GTime;
665 </TYPEDEF>
666 <MACRO>
667 <NAME>G_LITTLE_ENDIAN</NAME>
668 #define G_LITTLE_ENDIAN 1234
669 </MACRO>
670 <MACRO>
671 <NAME>G_BIG_ENDIAN</NAME>
672 #define G_BIG_ENDIAN 4321
673 </MACRO>
674 <MACRO>
675 <NAME>G_PDP_ENDIAN</NAME>
676 #define G_PDP_ENDIAN 3412 /* unused, need specific PDP check */
677 </MACRO>
678 <MACRO>
679 <NAME>GUINT16_SWAP_LE_BE_CONSTANT</NAME>
680 #define GUINT16_SWAP_LE_BE_CONSTANT(val) ((guint16) ( \
681 (((guint16) (val) & (guint16) 0x00ffU) << 8) | \
682 (((guint16) (val) & (guint16) 0xff00U) >> 8)))
683 </MACRO>
684 <MACRO>
685 <NAME>GUINT32_SWAP_LE_BE_CONSTANT</NAME>
686 #define GUINT32_SWAP_LE_BE_CONSTANT(val) ((guint32) ( \
687 (((guint32) (val) & (guint32) 0x000000ffU) << 24) | \
688 (((guint32) (val) & (guint32) 0x0000ff00U) << 8) | \
689 (((guint32) (val) & (guint32) 0x00ff0000U) >> 8) | \
690 (((guint32) (val) & (guint32) 0xff000000U) >> 24)))
691 </MACRO>
692 <MACRO>
693 <NAME>GUINT16_SWAP_LE_BE_X86</NAME>
694 # define GUINT16_SWAP_LE_BE_X86(val) \
695 (__extension__ \
696 ({ register guint16 __v; \
697 if (__builtin_constant_p (val)) \
698 __v = GUINT16_SWAP_LE_BE_CONSTANT (val); \
699 else \
700 __asm__ __const__ ("rorw $8, %w0" \
701 : "=r" (__v) \
702 : "0" ((guint16) (val))); \
703 __v; }))
704 </MACRO>
705 <MACRO>
706 <NAME>GUINT16_SWAP_LE_BE</NAME>
707 # define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_X86 (val))
708 </MACRO>
709 <MACRO>
710 <NAME>GUINT32_SWAP_LE_BE_X86</NAME>
711 # define GUINT32_SWAP_LE_BE_X86(val) \
712 (__extension__ \
713 ({ register guint32 __v; \
714 if (__builtin_constant_p (val)) \
715 __v = GUINT32_SWAP_LE_BE_CONSTANT (val); \
716 else \
717 __asm__ __const__ ("rorw $8, %w0\n\t" \
718 "rorl $16, %0\n\t" \
719 "rorw $8, %w0" \
720 : "=r" (__v) \
721 : "0" ((guint32) (val))); \
722 __v; }))
723 </MACRO>
724 <MACRO>
725 <NAME>GUINT32_SWAP_LE_BE_X86</NAME>
726 # define GUINT32_SWAP_LE_BE_X86(val) \
727 (__extension__ \
728 ({ register guint32 __v; \
729 if (__builtin_constant_p (val)) \
730 __v = GUINT32_SWAP_LE_BE_CONSTANT (val); \
731 else \
732 __asm__ __const__ ("bswap %0" \
733 : "=r" (__v) \
734 : "0" ((guint32) (val))); \
735 __v; }))
736 </MACRO>
737 <MACRO>
738 <NAME>GUINT32_SWAP_LE_BE</NAME>
739 # define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_X86 (val))
740 </MACRO>
741 <MACRO>
742 <NAME>GUINT16_SWAP_LE_BE</NAME>
743 # define GUINT16_SWAP_LE_BE(val) (GUINT16_SWAP_LE_BE_CONSTANT (val))
744 </MACRO>
745 <MACRO>
746 <NAME>GUINT32_SWAP_LE_BE</NAME>
747 # define GUINT32_SWAP_LE_BE(val) (GUINT32_SWAP_LE_BE_CONSTANT (val))
748 </MACRO>
749 <MACRO>
750 <NAME>GUINT64_SWAP_LE_BE_CONSTANT</NAME>
751 # define GUINT64_SWAP_LE_BE_CONSTANT(val) ((guint64) ( \
752 (((guint64) (val) & \
753 (guint64) G_GINT64_CONSTANT(0x00000000000000ffU)) << 56) | \
754 (((guint64) (val) & \
755 (guint64) G_GINT64_CONSTANT(0x000000000000ff00U)) << 40) | \
756 (((guint64) (val) & \
757 (guint64) G_GINT64_CONSTANT(0x0000000000ff0000U)) << 24) | \
758 (((guint64) (val) & \
759 (guint64) G_GINT64_CONSTANT(0x00000000ff000000U)) << 8) | \
760 (((guint64) (val) & \
761 (guint64) G_GINT64_CONSTANT(0x000000ff00000000U)) >> 8) | \
762 (((guint64) (val) & \
763 (guint64) G_GINT64_CONSTANT(0x0000ff0000000000U)) >> 24) | \
764 (((guint64) (val) & \
765 (guint64) G_GINT64_CONSTANT(0x00ff000000000000U)) >> 40) | \
766 (((guint64) (val) & \
767 (guint64) G_GINT64_CONSTANT(0xff00000000000000U)) >> 56)))
768 </MACRO>
769 <MACRO>
770 <NAME>GUINT64_SWAP_LE_BE_X86</NAME>
771 # define GUINT64_SWAP_LE_BE_X86(val) \
772 (__extension__ \
773 ({ union { guint64 __ll; \
774 guint32 __l[2]; } __r; \
775 if (__builtin_constant_p (val)) \
776 __r.__ll = GUINT64_SWAP_LE_BE_CONSTANT (val); \
777 else \
778 { \
779 union { guint64 __ll; \
780 guint32 __l[2]; } __w; \
781 __w.__ll = ((guint64) val); \
782 __r.__l[0] = GUINT32_SWAP_LE_BE (__w.__l[1]); \
783 __r.__l[1] = GUINT32_SWAP_LE_BE (__w.__l[0]); \
784 } \
785 __r.__ll; }))
786 </MACRO>
787 <MACRO>
788 <NAME>GUINT64_SWAP_LE_BE</NAME>
789 # define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_X86 (val))
790 </MACRO>
791 <MACRO>
792 <NAME>GUINT64_SWAP_LE_BE</NAME>
793 # define GUINT64_SWAP_LE_BE(val) (GUINT64_SWAP_LE_BE_CONSTANT(val))
794 </MACRO>
795 <MACRO>
796 <NAME>GUINT16_SWAP_LE_PDP</NAME>
797 #define GUINT16_SWAP_LE_PDP(val) ((guint16) (val))
798 </MACRO>
799 <MACRO>
800 <NAME>GUINT16_SWAP_BE_PDP</NAME>
801 #define GUINT16_SWAP_BE_PDP(val) (GUINT16_SWAP_LE_BE (val))
802 </MACRO>
803 <MACRO>
804 <NAME>GUINT32_SWAP_LE_PDP</NAME>
805 #define GUINT32_SWAP_LE_PDP(val) ((guint32) ( \
806 (((guint32) (val) & (guint32) 0x0000ffffU) << 16) | \
807 (((guint32) (val) & (guint32) 0xffff0000U) >> 16)))
808 </MACRO>
809 <MACRO>
810 <NAME>GUINT32_SWAP_BE_PDP</NAME>
811 #define GUINT32_SWAP_BE_PDP(val) ((guint32) ( \
812 (((guint32) (val) & (guint32) 0x00ff00ffU) << 8) | \
813 (((guint32) (val) & (guint32) 0xff00ff00U) >> 8)))
814 </MACRO>
815 <MACRO>
816 <NAME>GINT16_FROM_LE</NAME>
817 #define GINT16_FROM_LE(val) (GINT16_TO_LE (val))
818 </MACRO>
819 <MACRO>
820 <NAME>GUINT16_FROM_LE</NAME>
821 #define GUINT16_FROM_LE(val) (GUINT16_TO_LE (val))
822 </MACRO>
823 <MACRO>
824 <NAME>GINT16_FROM_BE</NAME>
825 #define GINT16_FROM_BE(val) (GINT16_TO_BE (val))
826 </MACRO>
827 <MACRO>
828 <NAME>GUINT16_FROM_BE</NAME>
829 #define GUINT16_FROM_BE(val) (GUINT16_TO_BE (val))
830 </MACRO>
831 <MACRO>
832 <NAME>GINT32_FROM_LE</NAME>
833 #define GINT32_FROM_LE(val) (GINT32_TO_LE (val))
834 </MACRO>
835 <MACRO>
836 <NAME>GUINT32_FROM_LE</NAME>
837 #define GUINT32_FROM_LE(val) (GUINT32_TO_LE (val))
838 </MACRO>
839 <MACRO>
840 <NAME>GINT32_FROM_BE</NAME>
841 #define GINT32_FROM_BE(val) (GINT32_TO_BE (val))
842 </MACRO>
843 <MACRO>
844 <NAME>GUINT32_FROM_BE</NAME>
845 #define GUINT32_FROM_BE(val) (GUINT32_TO_BE (val))
846 </MACRO>
847 <MACRO>
848 <NAME>GINT64_FROM_LE</NAME>
849 #define GINT64_FROM_LE(val) (GINT64_TO_LE (val))
850 </MACRO>
851 <MACRO>
852 <NAME>GUINT64_FROM_LE</NAME>
853 #define GUINT64_FROM_LE(val) (GUINT64_TO_LE (val))
854 </MACRO>
855 <MACRO>
856 <NAME>GINT64_FROM_BE</NAME>
857 #define GINT64_FROM_BE(val) (GINT64_TO_BE (val))
858 </MACRO>
859 <MACRO>
860 <NAME>GUINT64_FROM_BE</NAME>
861 #define GUINT64_FROM_BE(val) (GUINT64_TO_BE (val))
862 </MACRO>
863 <MACRO>
864 <NAME>GLONG_FROM_LE</NAME>
865 #define GLONG_FROM_LE(val) (GLONG_TO_LE (val))
866 </MACRO>
867 <MACRO>
868 <NAME>GULONG_FROM_LE</NAME>
869 #define GULONG_FROM_LE(val) (GULONG_TO_LE (val))
870 </MACRO>
871 <MACRO>
872 <NAME>GLONG_FROM_BE</NAME>
873 #define GLONG_FROM_BE(val) (GLONG_TO_BE (val))
874 </MACRO>
875 <MACRO>
876 <NAME>GULONG_FROM_BE</NAME>
877 #define GULONG_FROM_BE(val) (GULONG_TO_BE (val))
878 </MACRO>
879 <MACRO>
880 <NAME>GINT_FROM_LE</NAME>
881 #define GINT_FROM_LE(val) (GINT_TO_LE (val))
882 </MACRO>
883 <MACRO>
884 <NAME>GUINT_FROM_LE</NAME>
885 #define GUINT_FROM_LE(val) (GUINT_TO_LE (val))
886 </MACRO>
887 <MACRO>
888 <NAME>GINT_FROM_BE</NAME>
889 #define GINT_FROM_BE(val) (GINT_TO_BE (val))
890 </MACRO>
891 <MACRO>
892 <NAME>GUINT_FROM_BE</NAME>
893 #define GUINT_FROM_BE(val) (GUINT_TO_BE (val))
894 </MACRO>
895 <MACRO>
896 <NAME>g_ntohl</NAME>
897 #define g_ntohl(val) (GUINT32_FROM_BE (val))
898 </MACRO>
899 <MACRO>
900 <NAME>g_ntohs</NAME>
901 #define g_ntohs(val) (GUINT16_FROM_BE (val))
902 </MACRO>
903 <MACRO>
904 <NAME>g_htonl</NAME>
905 #define g_htonl(val) (GUINT32_TO_BE (val))
906 </MACRO>
907 <MACRO>
908 <NAME>g_htons</NAME>
909 #define g_htons(val) (GUINT16_TO_BE (val))
910 </MACRO>
911 <MACRO>
912 <NAME>GLIB_VAR</NAME>
913 # define GLIB_VAR __declspec(dllexport)
914 </MACRO>
915 <MACRO>
916 <NAME>GLIB_VAR</NAME>
917 # define GLIB_VAR extern __declspec(dllimport)
918 </MACRO>
919 <MACRO>
920 <NAME>GLIB_VAR</NAME>
921 # define GLIB_VAR extern
922 </MACRO>
923 <MACRO>
924 <NAME>GLIB_CHECK_VERSION</NAME>
925 #define GLIB_CHECK_VERSION(major,minor,micro) \
926 (GLIB_MAJOR_VERSION > (major) || \
927 (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION > (minor)) || \
928 (GLIB_MAJOR_VERSION == (major) && GLIB_MINOR_VERSION == (minor) && \
929 GLIB_MICRO_VERSION >= (micro)))
930 </MACRO>
931 <STRUCT>
932 <NAME>GAllocator</NAME>
933 </STRUCT>
934 <STRUCT>
935 <NAME>GArray</NAME>
936 </STRUCT>
937 <STRUCT>
938 <NAME>GByteArray</NAME>
939 </STRUCT>
940 <STRUCT>
941 <NAME>GCache</NAME>
942 </STRUCT>
943 <STRUCT>
944 <NAME>GCompletion</NAME>
945 </STRUCT>
946 <STRUCT>
947 <NAME>GData</NAME>
948 </STRUCT>
949 <STRUCT>
950 <NAME>GDebugKey</NAME>
951 </STRUCT>
952 <STRUCT>
953 <NAME>GHashTable</NAME>
954 </STRUCT>
955 <STRUCT>
956 <NAME>GHook</NAME>
957 </STRUCT>
958 <STRUCT>
959 <NAME>GHookList</NAME>
960 </STRUCT>
961 <STRUCT>
962 <NAME>GList</NAME>
963 </STRUCT>
964 <STRUCT>
965 <NAME>GMemChunk</NAME>
966 </STRUCT>
967 <STRUCT>
968 <NAME>GNode</NAME>
969 </STRUCT>
970 <STRUCT>
971 <NAME>GPtrArray</NAME>
972 </STRUCT>
973 <STRUCT>
974 <NAME>GQueue</NAME>
975 </STRUCT>
976 <STRUCT>
977 <NAME>GRand</NAME>
978 </STRUCT>
979 <STRUCT>
980 <NAME>GRelation</NAME>
981 </STRUCT>
982 <STRUCT>
983 <NAME>GScanner</NAME>
984 </STRUCT>
985 <STRUCT>
986 <NAME>GScannerConfig</NAME>
987 </STRUCT>
988 <STRUCT>
989 <NAME>GSList</NAME>
990 </STRUCT>
991 <STRUCT>
992 <NAME>GString</NAME>
993 </STRUCT>
994 <STRUCT>
995 <NAME>GStringChunk</NAME>
996 </STRUCT>
997 <STRUCT>
998 <NAME>GTimer</NAME>
999 </STRUCT>
1000 <STRUCT>
1001 <NAME>GTrashStack</NAME>
1002 </STRUCT>
1003 <STRUCT>
1004 <NAME>GTree</NAME>
1005 </STRUCT>
1006 <STRUCT>
1007 <NAME>GTuples</NAME>
1008 </STRUCT>
1009 <STRUCT>
1010 <NAME>GIOChannel</NAME>
1011 </STRUCT>
1012 <ENUM>
1013 <NAME>GTraverseFlags</NAME>
1014 typedef enum
1015 {
1016 G_TRAVERSE_LEAFS = 1 << 0,
1017 G_TRAVERSE_NON_LEAFS = 1 << 1,
1018 G_TRAVERSE_ALL = G_TRAVERSE_LEAFS | G_TRAVERSE_NON_LEAFS,
1019 G_TRAVERSE_MASK = 0x03
1020 } GTraverseFlags;
1021 </ENUM>
1022 <ENUM>
1023 <NAME>GTraverseType</NAME>
1024 typedef enum
1025 {
1026 G_IN_ORDER,
1027 G_PRE_ORDER,
1028 G_POST_ORDER,
1029 G_LEVEL_ORDER
1030 } GTraverseType;
1031 </ENUM>
1032 <MACRO>
1033 <NAME>G_LOG_LEVEL_USER_SHIFT</NAME>
1034 #define G_LOG_LEVEL_USER_SHIFT (8)
1035 </MACRO>
1036 <ENUM>
1037 <NAME>GLogLevelFlags</NAME>
1038 typedef enum
1039 {
1040 /* log flags */
1041 G_LOG_FLAG_RECURSION = 1 << 0,
1042 G_LOG_FLAG_FATAL = 1 << 1,
1044 /* GLib log levels */
1045 G_LOG_LEVEL_ERROR = 1 << 2, /* always fatal */
1046 G_LOG_LEVEL_CRITICAL = 1 << 3,
1047 G_LOG_LEVEL_WARNING = 1 << 4,
1048 G_LOG_LEVEL_MESSAGE = 1 << 5,
1049 G_LOG_LEVEL_INFO = 1 << 6,
1050 G_LOG_LEVEL_DEBUG = 1 << 7,
1052 G_LOG_LEVEL_MASK = ~(G_LOG_FLAG_RECURSION | G_LOG_FLAG_FATAL)
1053 } GLogLevelFlags;
1054 </ENUM>
1055 <MACRO>
1056 <NAME>G_LOG_FATAL_MASK</NAME>
1057 #define G_LOG_FATAL_MASK (G_LOG_FLAG_RECURSION | G_LOG_LEVEL_ERROR)
1058 </MACRO>
1059 <USER_FUNCTION>
1060 <NAME>GCacheNewFunc</NAME>
1061 <RETURNS>gpointer </RETURNS>
1062 gpointer key
1063 </USER_FUNCTION>
1064 <USER_FUNCTION>
1065 <NAME>GCacheDupFunc</NAME>
1066 <RETURNS>gpointer </RETURNS>
1067 gpointer value
1068 </USER_FUNCTION>
1069 <USER_FUNCTION>
1070 <NAME>GCacheDestroyFunc</NAME>
1071 <RETURNS>void </RETURNS>
1072 gpointer value
1073 </USER_FUNCTION>
1074 <USER_FUNCTION>
1075 <NAME>GCompareFunc</NAME>
1076 <RETURNS>gint </RETURNS>
1077 gconstpointer a,
1078 gconstpointer b
1079 </USER_FUNCTION>
1080 <USER_FUNCTION>
1081 <NAME>GCompletionFunc</NAME>
1082 <RETURNS>gchar *</RETURNS>
1083 gpointer
1084 </USER_FUNCTION>
1085 <USER_FUNCTION>
1086 <NAME>GDestroyNotify</NAME>
1087 <RETURNS>void </RETURNS>
1088 gpointer data
1089 </USER_FUNCTION>
1090 <USER_FUNCTION>
1091 <NAME>GDataForeachFunc</NAME>
1092 <RETURNS>void </RETURNS>
1093 GQuark key_id,
1094 gpointer data,
1095 gpointer user_data
1096 </USER_FUNCTION>
1097 <USER_FUNCTION>
1098 <NAME>GFunc</NAME>
1099 <RETURNS>void </RETURNS>
1100 gpointer data,
1101 gpointer user_data
1102 </USER_FUNCTION>
1103 <USER_FUNCTION>
1104 <NAME>GHashFunc</NAME>
1105 <RETURNS>guint </RETURNS>
1106 gconstpointer key
1107 </USER_FUNCTION>
1108 <USER_FUNCTION>
1109 <NAME>GFreeFunc</NAME>
1110 <RETURNS>void </RETURNS>
1111 gpointer data
1112 </USER_FUNCTION>
1113 <USER_FUNCTION>
1114 <NAME>GHFunc</NAME>
1115 <RETURNS>void </RETURNS>
1116 gpointer key,
1117 gpointer value,
1118 gpointer user_data
1119 </USER_FUNCTION>
1120 <USER_FUNCTION>
1121 <NAME>GHRFunc</NAME>
1122 <RETURNS>gboolean </RETURNS>
1123 gpointer key,
1124 gpointer value,
1125 gpointer user_data
1126 </USER_FUNCTION>
1127 <USER_FUNCTION>
1128 <NAME>GHookCompareFunc</NAME>
1129 <RETURNS>gint </RETURNS>
1130 GHook *new_hook,
1131 GHook *sibling
1132 </USER_FUNCTION>
1133 <USER_FUNCTION>
1134 <NAME>GHookFindFunc</NAME>
1135 <RETURNS>gboolean </RETURNS>
1136 GHook *hook,
1137 gpointer data
1138 </USER_FUNCTION>
1139 <USER_FUNCTION>
1140 <NAME>GHookMarshaller</NAME>
1141 <RETURNS>void </RETURNS>
1142 GHook *hook,
1143 gpointer data
1144 </USER_FUNCTION>
1145 <USER_FUNCTION>
1146 <NAME>GHookCheckMarshaller</NAME>
1147 <RETURNS>gboolean </RETURNS>
1148 GHook *hook,
1149 gpointer data
1150 </USER_FUNCTION>
1151 <USER_FUNCTION>
1152 <NAME>GHookFunc</NAME>
1153 <RETURNS>void </RETURNS>
1154 gpointer data
1155 </USER_FUNCTION>
1156 <USER_FUNCTION>
1157 <NAME>GHookCheckFunc</NAME>
1158 <RETURNS>gboolean </RETURNS>
1159 gpointer data
1160 </USER_FUNCTION>
1161 <USER_FUNCTION>
1162 <NAME>GHookFreeFunc</NAME>
1163 <RETURNS>void </RETURNS>
1164 GHookList *hook_list,
1165 GHook *hook
1166 </USER_FUNCTION>
1167 <USER_FUNCTION>
1168 <NAME>GLogFunc</NAME>
1169 <RETURNS>void </RETURNS>
1170 const gchar *log_domain,
1171 GLogLevelFlags log_level,
1172 const gchar *message,
1173 gpointer user_data
1174 </USER_FUNCTION>
1175 <USER_FUNCTION>
1176 <NAME>GNodeTraverseFunc</NAME>
1177 <RETURNS>gboolean </RETURNS>
1178 GNode *node,
1179 gpointer data
1180 </USER_FUNCTION>
1181 <USER_FUNCTION>
1182 <NAME>GNodeForeachFunc</NAME>
1183 <RETURNS>void </RETURNS>
1184 GNode *node,
1185 gpointer data
1186 </USER_FUNCTION>
1187 <USER_FUNCTION>
1188 <NAME>GScannerMsgFunc</NAME>
1189 <RETURNS>void </RETURNS>
1190 GScanner *scanner,
1191 gchar *message,
1192 gint error
1193 </USER_FUNCTION>
1194 <USER_FUNCTION>
1195 <NAME>GTraverseFunc</NAME>
1196 <RETURNS>gint </RETURNS>
1197 gpointer key,
1198 gpointer value,
1199 gpointer data
1200 </USER_FUNCTION>
1201 <USER_FUNCTION>
1202 <NAME>GVoidFunc</NAME>
1203 <RETURNS>void </RETURNS>
1204 void
1205 </USER_FUNCTION>
1206 <STRUCT>
1207 <NAME>GArray</NAME>
1208 struct GArray
1209 {
1210 gchar *data;
1211 guint len;
1212 };
1213 </STRUCT>
1214 <STRUCT>
1215 <NAME>GByteArray</NAME>
1216 struct GByteArray
1217 {
1218 guint8 *data;
1219 guint len;
1220 };
1221 </STRUCT>
1222 <STRUCT>
1223 <NAME>GDebugKey</NAME>
1224 struct GDebugKey
1225 {
1226 gchar *key;
1227 guint value;
1228 };
1229 </STRUCT>
1230 <STRUCT>
1231 <NAME>GList</NAME>
1232 struct GList
1233 {
1234 gpointer data;
1235 GList *next;
1236 GList *prev;
1237 };
1238 </STRUCT>
1239 <STRUCT>
1240 <NAME>GPtrArray</NAME>
1241 struct GPtrArray
1242 {
1243 gpointer *pdata;
1244 guint len;
1245 };
1246 </STRUCT>
1247 <STRUCT>
1248 <NAME>GQueue</NAME>
1249 struct GQueue
1250 {
1251 GList *head;
1252 GList *tail;
1253 guint length;
1254 };
1255 </STRUCT>
1256 <STRUCT>
1257 <NAME>GSList</NAME>
1258 struct GSList
1259 {
1260 gpointer data;
1261 GSList *next;
1262 };
1263 </STRUCT>
1264 <STRUCT>
1265 <NAME>GString</NAME>
1266 struct GString
1267 {
1268 gchar *str;
1269 gint len;
1270 };
1271 </STRUCT>
1272 <STRUCT>
1273 <NAME>GTrashStack</NAME>
1274 struct GTrashStack
1275 {
1276 GTrashStack *next;
1277 };
1278 </STRUCT>
1279 <STRUCT>
1280 <NAME>GTuples</NAME>
1281 struct GTuples
1282 {
1283 guint len;
1284 };
1285 </STRUCT>
1286 <MACRO>
1287 <NAME>G_IEEE754_FLOAT_BIAS</NAME>
1288 #define G_IEEE754_FLOAT_BIAS (127)
1289 </MACRO>
1290 <MACRO>
1291 <NAME>G_IEEE754_DOUBLE_BIAS</NAME>
1292 #define G_IEEE754_DOUBLE_BIAS (1023)
1293 </MACRO>
1294 <MACRO>
1295 <NAME>G_LOG_2_BASE_10</NAME>
1296 #define G_LOG_2_BASE_10 (0.30102999566398119521)
1297 </MACRO>
1298 <UNION>
1299 <NAME>GFloatIEEE754</NAME>
1300 union GFloatIEEE754
1301 {
1302 gfloat v_float;
1303 struct {
1304 guint mantissa : 23;
1305 guint biased_exponent : 8;
1306 guint sign : 1;
1307 } mpn;
1308 };
1309 </UNION>
1310 <UNION>
1311 <NAME>GDoubleIEEE754</NAME>
1312 union GDoubleIEEE754
1313 {
1314 gdouble v_double;
1315 struct {
1316 guint mantissa_low : 32;
1317 guint mantissa_high : 20;
1318 guint biased_exponent : 11;
1319 guint sign : 1;
1320 } mpn;
1321 };
1322 </UNION>
1323 <UNION>
1324 <NAME>GFloatIEEE754</NAME>
1325 union GFloatIEEE754
1326 {
1327 gfloat v_float;
1328 struct {
1329 guint sign : 1;
1330 guint biased_exponent : 8;
1331 guint mantissa : 23;
1332 } mpn;
1333 };
1334 </UNION>
1335 <UNION>
1336 <NAME>GDoubleIEEE754</NAME>
1337 union GDoubleIEEE754
1338 {
1339 gdouble v_double;
1340 struct {
1341 guint sign : 1;
1342 guint biased_exponent : 11;
1343 guint mantissa_high : 20;
1344 guint mantissa_low : 32;
1345 } mpn;
1346 };
1347 </UNION>
1348 <FUNCTION>
1349 <NAME>g_list_push_allocator</NAME>
1350 <RETURNS>void </RETURNS>
1351 GAllocator *allocator
1352 </FUNCTION>
1353 <FUNCTION>
1354 <NAME>g_list_pop_allocator</NAME>
1355 <RETURNS>void </RETURNS>
1356 void
1357 </FUNCTION>
1358 <FUNCTION>
1359 <NAME>g_list_alloc</NAME>
1360 <RETURNS>GList *</RETURNS>
1361 void
1362 </FUNCTION>
1363 <FUNCTION>
1364 <NAME>g_list_free</NAME>
1365 <RETURNS>void </RETURNS>
1366 GList *list
1367 </FUNCTION>
1368 <FUNCTION>
1369 <NAME>g_list_free_1</NAME>
1370 <RETURNS>void </RETURNS>
1371 GList *list
1372 </FUNCTION>
1373 <FUNCTION>
1374 <NAME>g_list_append</NAME>
1375 <RETURNS>GList *</RETURNS>
1376 GList *list,gpointer data
1377 </FUNCTION>
1378 <FUNCTION>
1379 <NAME>g_list_prepend</NAME>
1380 <RETURNS>GList *</RETURNS>
1381 GList *list,gpointer data
1382 </FUNCTION>
1383 <FUNCTION>
1384 <NAME>g_list_insert</NAME>
1385 <RETURNS>GList *</RETURNS>
1386 GList *list,gpointer data,gint position
1387 </FUNCTION>
1388 <FUNCTION>
1389 <NAME>g_list_insert_sorted</NAME>
1390 <RETURNS>GList *</RETURNS>
1391 GList *list,gpointer data,GCompareFunc func
1392 </FUNCTION>
1393 <FUNCTION>
1394 <NAME>g_list_concat</NAME>
1395 <RETURNS>GList *</RETURNS>
1396 GList *list1,GList *list2
1397 </FUNCTION>
1398 <FUNCTION>
1399 <NAME>g_list_remove</NAME>
1400 <RETURNS>GList *</RETURNS>
1401 GList *list,gconstpointer data
1402 </FUNCTION>
1403 <FUNCTION>
1404 <NAME>g_list_remove_link</NAME>
1405 <RETURNS>GList *</RETURNS>
1406 GList *list,GList *llink
1407 </FUNCTION>
1408 <FUNCTION>
1409 <NAME>g_list_delete_link</NAME>
1410 <RETURNS>GList *</RETURNS>
1411 GList *list,GList *link
1412 </FUNCTION>
1413 <FUNCTION>
1414 <NAME>g_list_reverse</NAME>
1415 <RETURNS>GList *</RETURNS>
1416 GList *list
1417 </FUNCTION>
1418 <FUNCTION>
1419 <NAME>g_list_copy</NAME>
1420 <RETURNS>GList *</RETURNS>
1421 GList *list
1422 </FUNCTION>
1423 <FUNCTION>
1424 <NAME>g_list_nth</NAME>
1425 <RETURNS>GList *</RETURNS>
1426 GList *list,guint n
1427 </FUNCTION>
1428 <FUNCTION>
1429 <NAME>g_list_find</NAME>
1430 <RETURNS>GList *</RETURNS>
1431 GList *list,gconstpointer data
1432 </FUNCTION>
1433 <FUNCTION>
1434 <NAME>g_list_find_custom</NAME>
1435 <RETURNS>GList *</RETURNS>
1436 GList *list,gconstpointer data,GCompareFunc func
1437 </FUNCTION>
1438 <FUNCTION>
1439 <NAME>g_list_position</NAME>
1440 <RETURNS>gint </RETURNS>
1441 GList *list,GList *llink
1442 </FUNCTION>
1443 <FUNCTION>
1444 <NAME>g_list_index</NAME>
1445 <RETURNS>gint </RETURNS>
1446 GList *list,gconstpointer data
1447 </FUNCTION>
1448 <FUNCTION>
1449 <NAME>g_list_last</NAME>
1450 <RETURNS>GList *</RETURNS>
1451 GList *list
1452 </FUNCTION>
1453 <FUNCTION>
1454 <NAME>g_list_first</NAME>
1455 <RETURNS>GList *</RETURNS>
1456 GList *list
1457 </FUNCTION>
1458 <FUNCTION>
1459 <NAME>g_list_length</NAME>
1460 <RETURNS>guint </RETURNS>
1461 GList *list
1462 </FUNCTION>
1463 <FUNCTION>
1464 <NAME>g_list_foreach</NAME>
1465 <RETURNS>void </RETURNS>
1466 GList *list,GFunc func,gpointer user_data
1467 </FUNCTION>
1468 <FUNCTION>
1469 <NAME>g_list_sort</NAME>
1470 <RETURNS>GList *</RETURNS>
1471 GList *list,GCompareFunc compare_func
1472 </FUNCTION>
1473 <FUNCTION>
1474 <NAME>g_list_nth_data</NAME>
1475 <RETURNS>gpointer </RETURNS>
1476 GList *list,guint n
1477 </FUNCTION>
1478 <MACRO>
1479 <NAME>g_list_previous</NAME>
1480 #define g_list_previous(list) ((list) ? (((GList *)(list))->prev) : NULL)
1481 </MACRO>
1482 <MACRO>
1483 <NAME>g_list_next</NAME>
1484 #define g_list_next(list) ((list) ? (((GList *)(list))->next) : NULL)
1485 </MACRO>
1486 <FUNCTION>
1487 <NAME>g_slist_push_allocator</NAME>
1488 <RETURNS>void </RETURNS>
1489 GAllocator *allocator
1490 </FUNCTION>
1491 <FUNCTION>
1492 <NAME>g_slist_pop_allocator</NAME>
1493 <RETURNS>void </RETURNS>
1494 void
1495 </FUNCTION>
1496 <FUNCTION>
1497 <NAME>g_slist_alloc</NAME>
1498 <RETURNS>GSList *</RETURNS>
1499 void
1500 </FUNCTION>
1501 <FUNCTION>
1502 <NAME>g_slist_free</NAME>
1503 <RETURNS>void </RETURNS>
1504 GSList *list
1505 </FUNCTION>
1506 <FUNCTION>
1507 <NAME>g_slist_free_1</NAME>
1508 <RETURNS>void </RETURNS>
1509 GSList *list
1510 </FUNCTION>
1511 <FUNCTION>
1512 <NAME>g_slist_append</NAME>
1513 <RETURNS>GSList *</RETURNS>
1514 GSList *list,gpointer data
1515 </FUNCTION>
1516 <FUNCTION>
1517 <NAME>g_slist_prepend</NAME>
1518 <RETURNS>GSList *</RETURNS>
1519 GSList *list,gpointer data
1520 </FUNCTION>
1521 <FUNCTION>
1522 <NAME>g_slist_insert</NAME>
1523 <RETURNS>GSList *</RETURNS>
1524 GSList *list,gpointer data,gint position
1525 </FUNCTION>
1526 <FUNCTION>
1527 <NAME>g_slist_insert_sorted</NAME>
1528 <RETURNS>GSList *</RETURNS>
1529 GSList *list,gpointer data,GCompareFunc func
1530 </FUNCTION>
1531 <FUNCTION>
1532 <NAME>g_slist_insert_before</NAME>
1533 <RETURNS>GSList *</RETURNS>
1534 GSList *slist,GSList *sibling,gpointer data
1535 </FUNCTION>
1536 <FUNCTION>
1537 <NAME>g_slist_concat</NAME>
1538 <RETURNS>GSList *</RETURNS>
1539 GSList *list1,GSList *list2
1540 </FUNCTION>
1541 <FUNCTION>
1542 <NAME>g_slist_remove</NAME>
1543 <RETURNS>GSList *</RETURNS>
1544 GSList *list,gconstpointer data
1545 </FUNCTION>
1546 <FUNCTION>
1547 <NAME>g_slist_remove_link</NAME>
1548 <RETURNS>GSList *</RETURNS>
1549 GSList *list,GSList *link
1550 </FUNCTION>
1551 <FUNCTION>
1552 <NAME>g_slist_delete_link</NAME>
1553 <RETURNS>GSList *</RETURNS>
1554 GSList *list,GSList *link
1555 </FUNCTION>
1556 <FUNCTION>
1557 <NAME>g_slist_reverse</NAME>
1558 <RETURNS>GSList *</RETURNS>
1559 GSList *list
1560 </FUNCTION>
1561 <FUNCTION>
1562 <NAME>g_slist_copy</NAME>
1563 <RETURNS>GSList *</RETURNS>
1564 GSList *list
1565 </FUNCTION>
1566 <FUNCTION>
1567 <NAME>g_slist_nth</NAME>
1568 <RETURNS>GSList *</RETURNS>
1569 GSList *list,guint n
1570 </FUNCTION>
1571 <FUNCTION>
1572 <NAME>g_slist_find</NAME>
1573 <RETURNS>GSList *</RETURNS>
1574 GSList *list,gconstpointer data
1575 </FUNCTION>
1576 <FUNCTION>
1577 <NAME>g_slist_find_custom</NAME>
1578 <RETURNS>GSList *</RETURNS>
1579 GSList *list,gconstpointer data,GCompareFunc func
1580 </FUNCTION>
1581 <FUNCTION>
1582 <NAME>g_slist_position</NAME>
1583 <RETURNS>gint </RETURNS>
1584 GSList *list,GSList *llink
1585 </FUNCTION>
1586 <FUNCTION>
1587 <NAME>g_slist_index</NAME>
1588 <RETURNS>gint </RETURNS>
1589 GSList *list,gconstpointer data
1590 </FUNCTION>
1591 <FUNCTION>
1592 <NAME>g_slist_last</NAME>
1593 <RETURNS>GSList *</RETURNS>
1594 GSList *list
1595 </FUNCTION>
1596 <FUNCTION>
1597 <NAME>g_slist_length</NAME>
1598 <RETURNS>guint </RETURNS>
1599 GSList *list
1600 </FUNCTION>
1601 <FUNCTION>
1602 <NAME>g_slist_foreach</NAME>
1603 <RETURNS>void </RETURNS>
1604 GSList *list,GFunc func,gpointer user_data
1605 </FUNCTION>
1606 <FUNCTION>
1607 <NAME>g_slist_sort</NAME>
1608 <RETURNS>GSList *</RETURNS>
1609 GSList *list,GCompareFunc compare_func
1610 </FUNCTION>
1611 <FUNCTION>
1612 <NAME>g_slist_nth_data</NAME>
1613 <RETURNS>gpointer </RETURNS>
1614 GSList *list,guint n
1615 </FUNCTION>
1616 <MACRO>
1617 <NAME>g_slist_next</NAME>
1618 #define g_slist_next(slist) ((slist) ? (((GSList *)(slist))->next) : NULL)
1619 </MACRO>
1620 <FUNCTION>
1621 <NAME>g_queue_new</NAME>
1622 <RETURNS>GQueue *</RETURNS>
1623 void
1624 </FUNCTION>
1625 <FUNCTION>
1626 <NAME>g_queue_free</NAME>
1627 <RETURNS>void </RETURNS>
1628 GQueue *queue
1629 </FUNCTION>
1630 <FUNCTION>
1631 <NAME>g_queue_push_head</NAME>
1632 <RETURNS>void </RETURNS>
1633 GQueue *queue,gpointer data
1634 </FUNCTION>
1635 <FUNCTION>
1636 <NAME>g_queue_push_tail</NAME>
1637 <RETURNS>void </RETURNS>
1638 GQueue *queue,gpointer data
1639 </FUNCTION>
1640 <FUNCTION>
1641 <NAME>g_queue_pop_head</NAME>
1642 <RETURNS>gpointer </RETURNS>
1643 GQueue *queue
1644 </FUNCTION>
1645 <FUNCTION>
1646 <NAME>g_queue_pop_tail</NAME>
1647 <RETURNS>gpointer </RETURNS>
1648 GQueue *queue
1649 </FUNCTION>
1650 <FUNCTION>
1651 <NAME>g_queue_is_empty</NAME>
1652 <RETURNS>gboolean </RETURNS>
1653 GQueue *queue
1654 </FUNCTION>
1655 <FUNCTION>
1656 <NAME>g_queue_peek_head</NAME>
1657 <RETURNS>gpointer </RETURNS>
1658 GQueue *queue
1659 </FUNCTION>
1660 <FUNCTION>
1661 <NAME>g_queue_peek_tail</NAME>
1662 <RETURNS>gpointer </RETURNS>
1663 GQueue *queue
1664 </FUNCTION>
1665 <FUNCTION>
1666 <NAME>g_queue_push_head_link</NAME>
1667 <RETURNS>void </RETURNS>
1668 GQueue *queue,GList *link
1669 </FUNCTION>
1670 <FUNCTION>
1671 <NAME>g_queue_push_tail_link</NAME>
1672 <RETURNS>void </RETURNS>
1673 GQueue *queue,GList *link
1674 </FUNCTION>
1675 <FUNCTION>
1676 <NAME>g_queue_pop_head_link</NAME>
1677 <RETURNS>GList *</RETURNS>
1678 GQueue *queue
1679 </FUNCTION>
1680 <FUNCTION>
1681 <NAME>g_queue_pop_tail_link</NAME>
1682 <RETURNS>GList *</RETURNS>
1683 GQueue *queue
1684 </FUNCTION>
1685 <FUNCTION>
1686 <NAME>g_hash_table_new</NAME>
1687 <RETURNS>GHashTable *</RETURNS>
1688 GHashFunc hash_func,GCompareFunc key_compare_func
1689 </FUNCTION>
1690 <FUNCTION>
1691 <NAME>g_hash_table_destroy</NAME>
1692 <RETURNS>void </RETURNS>
1693 GHashTable *hash_table
1694 </FUNCTION>
1695 <FUNCTION>
1696 <NAME>g_hash_table_insert</NAME>
1697 <RETURNS>void </RETURNS>
1698 GHashTable *hash_table,gpointer key,gpointer value
1699 </FUNCTION>
1700 <FUNCTION>
1701 <NAME>g_hash_table_remove</NAME>
1702 <RETURNS>void </RETURNS>
1703 GHashTable *hash_table,gconstpointer key
1704 </FUNCTION>
1705 <FUNCTION>
1706 <NAME>g_hash_table_lookup</NAME>
1707 <RETURNS>gpointer </RETURNS>
1708 GHashTable *hash_table,gconstpointer key
1709 </FUNCTION>
1710 <FUNCTION>
1711 <NAME>g_hash_table_lookup_extended</NAME>
1712 <RETURNS>gboolean </RETURNS>
1713 GHashTable *hash_table,gconstpointer lookup_key,gpointer *orig_key,gpointer *value
1714 </FUNCTION>
1715 <FUNCTION>
1716 <NAME>g_hash_table_foreach</NAME>
1717 <RETURNS>void </RETURNS>
1718 GHashTable *hash_table,GHFunc func,gpointer user_data
1719 </FUNCTION>
1720 <FUNCTION>
1721 <NAME>g_hash_table_foreach_remove</NAME>
1722 <RETURNS>guint </RETURNS>
1723 GHashTable *hash_table,GHRFunc func,gpointer user_data
1724 </FUNCTION>
1725 <FUNCTION>
1726 <NAME>g_hash_table_size</NAME>
1727 <RETURNS>guint </RETURNS>
1728 GHashTable *hash_table
1729 </FUNCTION>
1730 <FUNCTION>
1731 <NAME>g_hash_table_freeze</NAME>
1732 <RETURNS>void </RETURNS>
1733 GHashTable *hash_table
1734 </FUNCTION>
1735 <FUNCTION>
1736 <NAME>g_hash_table_thaw</NAME>
1737 <RETURNS>void </RETURNS>
1738 GHashTable *hash_table
1739 </FUNCTION>
1740 <FUNCTION>
1741 <NAME>g_cache_new</NAME>
1742 <RETURNS>GCache *</RETURNS>
1743 GCacheNewFunc value_new_func,GCacheDestroyFunc value_destroy_func,GCacheDupFunc key_dup_func,GCacheDestroyFunc key_destroy_func,GHashFunc hash_key_func,GHashFunc hash_value_func,GCompareFunc key_compare_func
1744 </FUNCTION>
1745 <FUNCTION>
1746 <NAME>g_cache_destroy</NAME>
1747 <RETURNS>void </RETURNS>
1748 GCache *cache
1749 </FUNCTION>
1750 <FUNCTION>
1751 <NAME>g_cache_insert</NAME>
1752 <RETURNS>gpointer </RETURNS>
1753 GCache *cache,gpointer key
1754 </FUNCTION>
1755 <FUNCTION>
1756 <NAME>g_cache_remove</NAME>
1757 <RETURNS>void </RETURNS>
1758 GCache *cache,gconstpointer value
1759 </FUNCTION>
1760 <FUNCTION>
1761 <NAME>g_cache_key_foreach</NAME>
1762 <RETURNS>void </RETURNS>
1763 GCache *cache,GHFunc func,gpointer user_data
1764 </FUNCTION>
1765 <FUNCTION>
1766 <NAME>g_cache_value_foreach</NAME>
1767 <RETURNS>void </RETURNS>
1768 GCache *cache,GHFunc func,gpointer user_data
1769 </FUNCTION>
1770 <FUNCTION>
1771 <NAME>g_tree_new</NAME>
1772 <RETURNS>GTree *</RETURNS>
1773 GCompareFunc key_compare_func
1774 </FUNCTION>
1775 <FUNCTION>
1776 <NAME>g_tree_destroy</NAME>
1777 <RETURNS>void </RETURNS>
1778 GTree *tree
1779 </FUNCTION>
1780 <FUNCTION>
1781 <NAME>g_tree_insert</NAME>
1782 <RETURNS>void </RETURNS>
1783 GTree *tree,gpointer key,gpointer value
1784 </FUNCTION>
1785 <FUNCTION>
1786 <NAME>g_tree_remove</NAME>
1787 <RETURNS>void </RETURNS>
1788 GTree *tree,gconstpointer key
1789 </FUNCTION>
1790 <FUNCTION>
1791 <NAME>g_tree_lookup</NAME>
1792 <RETURNS>gpointer </RETURNS>
1793 GTree *tree,gconstpointer key
1794 </FUNCTION>
1795 <FUNCTION>
1796 <NAME>g_tree_traverse</NAME>
1797 <RETURNS>void </RETURNS>
1798 GTree *tree,GTraverseFunc traverse_func,GTraverseType traverse_type,gpointer data
1799 </FUNCTION>
1800 <FUNCTION>
1801 <NAME>g_tree_search</NAME>
1802 <RETURNS>gpointer </RETURNS>
1803 GTree *tree,GCompareFunc search_func,gconstpointer data
1804 </FUNCTION>
1805 <FUNCTION>
1806 <NAME>g_tree_height</NAME>
1807 <RETURNS>gint </RETURNS>
1808 GTree *tree
1809 </FUNCTION>
1810 <FUNCTION>
1811 <NAME>g_tree_nnodes</NAME>
1812 <RETURNS>gint </RETURNS>
1813 GTree *tree
1814 </FUNCTION>
1815 <STRUCT>
1816 <NAME>GNode</NAME>
1817 struct GNode
1818 {
1819 gpointer data;
1820 GNode *next;
1821 GNode *prev;
1822 GNode *parent;
1823 GNode *children;
1824 };
1825 </STRUCT>
1826 <MACRO>
1827 <NAME>G_NODE_IS_ROOT</NAME>
1828 #define G_NODE_IS_ROOT(node) (((GNode*) (node))->parent == NULL && \
1829 ((GNode*) (node))->prev == NULL && \
1830 ((GNode*) (node))->next == NULL)
1831 </MACRO>
1832 <MACRO>
1833 <NAME>G_NODE_IS_LEAF</NAME>
1834 #define G_NODE_IS_LEAF(node) (((GNode*) (node))->children == NULL)
1835 </MACRO>
1836 <FUNCTION>
1837 <NAME>g_node_push_allocator</NAME>
1838 <RETURNS>void </RETURNS>
1839 GAllocator *allocator
1840 </FUNCTION>
1841 <FUNCTION>
1842 <NAME>g_node_pop_allocator</NAME>
1843 <RETURNS>void </RETURNS>
1844 void
1845 </FUNCTION>
1846 <FUNCTION>
1847 <NAME>g_node_new</NAME>
1848 <RETURNS>GNode *</RETURNS>
1849 gpointer data
1850 </FUNCTION>
1851 <FUNCTION>
1852 <NAME>g_node_destroy</NAME>
1853 <RETURNS>void </RETURNS>
1854 GNode *root
1855 </FUNCTION>
1856 <FUNCTION>
1857 <NAME>g_node_unlink</NAME>
1858 <RETURNS>void </RETURNS>
1859 GNode *node
1860 </FUNCTION>
1861 <FUNCTION>
1862 <NAME>g_node_copy</NAME>
1863 <RETURNS>GNode *</RETURNS>
1864 GNode *node
1865 </FUNCTION>
1866 <FUNCTION>
1867 <NAME>g_node_insert</NAME>
1868 <RETURNS>GNode *</RETURNS>
1869 GNode *parent,gint position,GNode *node
1870 </FUNCTION>
1871 <FUNCTION>
1872 <NAME>g_node_insert_before</NAME>
1873 <RETURNS>GNode *</RETURNS>
1874 GNode *parent,GNode *sibling,GNode *node
1875 </FUNCTION>
1876 <FUNCTION>
1877 <NAME>g_node_prepend</NAME>
1878 <RETURNS>GNode *</RETURNS>
1879 GNode *parent,GNode *node
1880 </FUNCTION>
1881 <FUNCTION>
1882 <NAME>g_node_n_nodes</NAME>
1883 <RETURNS>guint </RETURNS>
1884 GNode *root,GTraverseFlags flags
1885 </FUNCTION>
1886 <FUNCTION>
1887 <NAME>g_node_get_root</NAME>
1888 <RETURNS>GNode *</RETURNS>
1889 GNode *node
1890 </FUNCTION>
1891 <FUNCTION>
1892 <NAME>g_node_is_ancestor</NAME>
1893 <RETURNS>gboolean </RETURNS>
1894 GNode *node,GNode *descendant
1895 </FUNCTION>
1896 <FUNCTION>
1897 <NAME>g_node_depth</NAME>
1898 <RETURNS>guint </RETURNS>
1899 GNode *node
1900 </FUNCTION>
1901 <FUNCTION>
1902 <NAME>g_node_find</NAME>
1903 <RETURNS>GNode *</RETURNS>
1904 GNode *root,GTraverseType order,GTraverseFlags flags,gpointer data
1905 </FUNCTION>
1906 <MACRO>
1907 <NAME>g_node_append</NAME>
1908 #define g_node_append(parent, node) \
1909 g_node_insert_before ((parent), NULL, (node))
1910 </MACRO>
1911 <MACRO>
1912 <NAME>g_node_insert_data</NAME>
1913 #define g_node_insert_data(parent, position, data) \
1914 g_node_insert ((parent), (position), g_node_new (data))
1915 </MACRO>
1916 <MACRO>
1917 <NAME>g_node_insert_data_before</NAME>
1918 #define g_node_insert_data_before(parent, sibling, data) \
1919 g_node_insert_before ((parent), (sibling), g_node_new (data))
1920 </MACRO>
1921 <MACRO>
1922 <NAME>g_node_prepend_data</NAME>
1923 #define g_node_prepend_data(parent, data) \
1924 g_node_prepend ((parent), g_node_new (data))
1925 </MACRO>
1926 <MACRO>
1927 <NAME>g_node_append_data</NAME>
1928 #define g_node_append_data(parent, data) \
1929 g_node_insert_before ((parent), NULL, g_node_new (data))
1930 </MACRO>
1931 <FUNCTION>
1932 <NAME>g_node_traverse</NAME>
1933 <RETURNS>void </RETURNS>
1934 GNode *root,GTraverseType order,GTraverseFlags flags,gint max_depth,GNodeTraverseFunc func,gpointer data
1935 </FUNCTION>
1936 <FUNCTION>
1937 <NAME>g_node_max_height</NAME>
1938 <RETURNS>guint </RETURNS>
1939 GNode *root
1940 </FUNCTION>
1941 <FUNCTION>
1942 <NAME>g_node_children_foreach</NAME>
1943 <RETURNS>void </RETURNS>
1944 GNode *node,GTraverseFlags flags,GNodeForeachFunc func,gpointer data
1945 </FUNCTION>
1946 <FUNCTION>
1947 <NAME>g_node_reverse_children</NAME>
1948 <RETURNS>void </RETURNS>
1949 GNode *node
1950 </FUNCTION>
1951 <FUNCTION>
1952 <NAME>g_node_n_children</NAME>
1953 <RETURNS>guint </RETURNS>
1954 GNode *node
1955 </FUNCTION>
1956 <FUNCTION>
1957 <NAME>g_node_nth_child</NAME>
1958 <RETURNS>GNode *</RETURNS>
1959 GNode *node,guint n
1960 </FUNCTION>
1961 <FUNCTION>
1962 <NAME>g_node_last_child</NAME>
1963 <RETURNS>GNode *</RETURNS>
1964 GNode *node
1965 </FUNCTION>
1966 <FUNCTION>
1967 <NAME>g_node_find_child</NAME>
1968 <RETURNS>GNode *</RETURNS>
1969 GNode *node,GTraverseFlags flags,gpointer data
1970 </FUNCTION>
1971 <FUNCTION>
1972 <NAME>g_node_child_position</NAME>
1973 <RETURNS>gint </RETURNS>
1974 GNode *node,GNode *child
1975 </FUNCTION>
1976 <FUNCTION>
1977 <NAME>g_node_child_index</NAME>
1978 <RETURNS>gint </RETURNS>
1979 GNode *node,gpointer data
1980 </FUNCTION>
1981 <FUNCTION>
1982 <NAME>g_node_first_sibling</NAME>
1983 <RETURNS>GNode *</RETURNS>
1984 GNode *node
1985 </FUNCTION>
1986 <FUNCTION>
1987 <NAME>g_node_last_sibling</NAME>
1988 <RETURNS>GNode *</RETURNS>
1989 GNode *node
1990 </FUNCTION>
1991 <MACRO>
1992 <NAME>g_node_prev_sibling</NAME>
1993 #define g_node_prev_sibling(node) ((node) ? \
1994 ((GNode*) (node))->prev : NULL)
1995 </MACRO>
1996 <MACRO>
1997 <NAME>g_node_next_sibling</NAME>
1998 #define g_node_next_sibling(node) ((node) ? \
1999 ((GNode*) (node))->next : NULL)
2000 </MACRO>
2001 <MACRO>
2002 <NAME>g_node_first_child</NAME>
2003 #define g_node_first_child(node) ((node) ? \
2004 ((GNode*) (node))->children : NULL)
2005 </MACRO>
2006 <MACRO>
2007 <NAME>G_HOOK_FLAG_USER_SHIFT</NAME>
2008 #define G_HOOK_FLAG_USER_SHIFT (4)
2009 </MACRO>
2010 <ENUM>
2011 <NAME>GHookFlagMask</NAME>
2012 typedef enum
2013 {
2014 G_HOOK_FLAG_ACTIVE = 1 << 0,
2015 G_HOOK_FLAG_IN_CALL = 1 << 1,
2016 G_HOOK_FLAG_MASK = 0x0f
2017 } GHookFlagMask;
2018 </ENUM>
2019 <MACRO>
2020 <NAME>G_HOOK_DEFERRED_DESTROY</NAME>
2021 #define G_HOOK_DEFERRED_DESTROY ((GHookFreeFunc) 0x01)
2022 </MACRO>
2023 <STRUCT>
2024 <NAME>GHookList</NAME>
2025 struct GHookList
2026 {
2027 guint seq_id;
2028 guint hook_size;
2029 guint is_setup : 1;
2030 GHook *hooks;
2031 GMemChunk *hook_memchunk;
2032 GHookFreeFunc hook_free; /* virtual function */
2033 GHookFreeFunc hook_destroy; /* virtual function */
2034 };
2035 </STRUCT>
2036 <STRUCT>
2037 <NAME>GHook</NAME>
2038 struct GHook
2039 {
2040 gpointer data;
2041 GHook *next;
2042 GHook *prev;
2043 guint ref_count;
2044 guint hook_id;
2045 guint flags;
2046 gpointer func;
2047 GDestroyNotify destroy;
2048 };
2049 </STRUCT>
2050 <MACRO>
2051 <NAME>G_HOOK_ACTIVE</NAME>
2052 #define G_HOOK_ACTIVE(hook) ((((GHook*) hook)->flags & \
2053 G_HOOK_FLAG_ACTIVE) != 0)
2054 </MACRO>
2055 <MACRO>
2056 <NAME>G_HOOK_IN_CALL</NAME>
2057 #define G_HOOK_IN_CALL(hook) ((((GHook*) hook)->flags & \
2058 G_HOOK_FLAG_IN_CALL) != 0)
2059 </MACRO>
2060 <MACRO>
2061 <NAME>G_HOOK_IS_VALID</NAME>
2062 #define G_HOOK_IS_VALID(hook) (((GHook*) hook)->hook_id != 0 && \
2063 G_HOOK_ACTIVE (hook))
2064 </MACRO>
2065 <MACRO>
2066 <NAME>G_HOOK_IS_UNLINKED</NAME>
2067 #define G_HOOK_IS_UNLINKED(hook) (((GHook*) hook)->next == NULL && \
2068 ((GHook*) hook)->prev == NULL && \
2069 ((GHook*) hook)->hook_id == 0 && \
2070 ((GHook*) hook)->ref_count == 0)
2071 </MACRO>
2072 <FUNCTION>
2073 <NAME>g_hook_list_init</NAME>
2074 <RETURNS>void </RETURNS>
2075 GHookList *hook_list,guint hook_size
2076 </FUNCTION>
2077 <FUNCTION>
2078 <NAME>g_hook_list_clear</NAME>
2079 <RETURNS>void </RETURNS>
2080 GHookList *hook_list
2081 </FUNCTION>
2082 <FUNCTION>
2083 <NAME>g_hook_alloc</NAME>
2084 <RETURNS>GHook *</RETURNS>
2085 GHookList *hook_list
2086 </FUNCTION>
2087 <FUNCTION>
2088 <NAME>g_hook_free</NAME>
2089 <RETURNS>void </RETURNS>
2090 GHookList *hook_list,GHook *hook
2091 </FUNCTION>
2092 <FUNCTION>
2093 <NAME>g_hook_ref</NAME>
2094 <RETURNS>void </RETURNS>
2095 GHookList *hook_list,GHook *hook
2096 </FUNCTION>
2097 <FUNCTION>
2098 <NAME>g_hook_unref</NAME>
2099 <RETURNS>void </RETURNS>
2100 GHookList *hook_list,GHook *hook
2101 </FUNCTION>
2102 <FUNCTION>
2103 <NAME>g_hook_destroy</NAME>
2104 <RETURNS>gboolean </RETURNS>
2105 GHookList *hook_list,guint hook_id
2106 </FUNCTION>
2107 <FUNCTION>
2108 <NAME>g_hook_destroy_link</NAME>
2109 <RETURNS>void </RETURNS>
2110 GHookList *hook_list,GHook *hook
2111 </FUNCTION>
2112 <FUNCTION>
2113 <NAME>g_hook_prepend</NAME>
2114 <RETURNS>void </RETURNS>
2115 GHookList *hook_list,GHook *hook
2116 </FUNCTION>
2117 <FUNCTION>
2118 <NAME>g_hook_insert_before</NAME>
2119 <RETURNS>void </RETURNS>
2120 GHookList *hook_list,GHook *sibling,GHook *hook
2121 </FUNCTION>
2122 <FUNCTION>
2123 <NAME>g_hook_insert_sorted</NAME>
2124 <RETURNS>void </RETURNS>
2125 GHookList *hook_list,GHook *hook,GHookCompareFunc func
2126 </FUNCTION>
2127 <FUNCTION>
2128 <NAME>g_hook_get</NAME>
2129 <RETURNS>GHook *</RETURNS>
2130 GHookList *hook_list,guint hook_id
2131 </FUNCTION>
2132 <FUNCTION>
2133 <NAME>g_hook_find</NAME>
2134 <RETURNS>GHook *</RETURNS>
2135 GHookList *hook_list,gboolean need_valids,GHookFindFunc func,gpointer data
2136 </FUNCTION>
2137 <FUNCTION>
2138 <NAME>g_hook_find_data</NAME>
2139 <RETURNS>GHook *</RETURNS>
2140 GHookList *hook_list,gboolean need_valids,gpointer data
2141 </FUNCTION>
2142 <FUNCTION>
2143 <NAME>g_hook_find_func</NAME>
2144 <RETURNS>GHook *</RETURNS>
2145 GHookList *hook_list,gboolean need_valids,gpointer func
2146 </FUNCTION>
2147 <FUNCTION>
2148 <NAME>g_hook_find_func_data</NAME>
2149 <RETURNS>GHook *</RETURNS>
2150 GHookList *hook_list,gboolean need_valids,gpointer func,gpointer data
2151 </FUNCTION>
2152 <FUNCTION>
2153 <NAME>g_hook_first_valid</NAME>
2154 <RETURNS>GHook *</RETURNS>
2155 GHookList *hook_list,gboolean may_be_in_call
2156 </FUNCTION>
2157 <FUNCTION>
2158 <NAME>g_hook_next_valid</NAME>
2159 <RETURNS>GHook *</RETURNS>
2160 GHookList *hook_list,GHook *hook,gboolean may_be_in_call
2161 </FUNCTION>
2162 <FUNCTION>
2163 <NAME>g_hook_compare_ids</NAME>
2164 <RETURNS>gint </RETURNS>
2165 GHook *new_hook,GHook *sibling
2166 </FUNCTION>
2167 <MACRO>
2168 <NAME>g_hook_append</NAME>
2169 #define g_hook_append( hook_list, hook ) \
2170 g_hook_insert_before ((hook_list), NULL, (hook))
2171 </MACRO>
2172 <FUNCTION>
2173 <NAME>g_hook_list_invoke</NAME>
2174 <RETURNS>void </RETURNS>
2175 GHookList *hook_list,gboolean may_recurse
2176 </FUNCTION>
2177 <FUNCTION>
2178 <NAME>g_hook_list_invoke_check</NAME>
2179 <RETURNS>void </RETURNS>
2180 GHookList *hook_list,gboolean may_recurse
2181 </FUNCTION>
2182 <FUNCTION>
2183 <NAME>g_hook_list_marshal</NAME>
2184 <RETURNS>void </RETURNS>
2185 GHookList *hook_list,gboolean may_recurse,GHookMarshaller marshaller,gpointer data
2186 </FUNCTION>
2187 <FUNCTION>
2188 <NAME>g_hook_list_marshal_check</NAME>
2189 <RETURNS>void </RETURNS>
2190 GHookList *hook_list,gboolean may_recurse,GHookCheckMarshaller marshaller,gpointer data
2191 </FUNCTION>
2192 <FUNCTION>
2193 <NAME>g_on_error_query</NAME>
2194 <RETURNS>void </RETURNS>
2195 const gchar *prg_name
2196 </FUNCTION>
2197 <FUNCTION>
2198 <NAME>g_on_error_stack_trace</NAME>
2199 <RETURNS>void </RETURNS>
2200 const gchar *prg_name
2201 </FUNCTION>
2202 <VARIABLE>
2203 <NAME>g_log_domain_glib</NAME>
2204 extern const gchar *g_log_domain_glib;
2205 </VARIABLE>
2206 <FUNCTION>
2207 <NAME>g_log_set_handler</NAME>
2208 <RETURNS>guint </RETURNS>
2209 const gchar *log_domain,GLogLevelFlags log_levels,GLogFunc log_func,gpointer user_data
2210 </FUNCTION>
2211 <FUNCTION>
2212 <NAME>g_log_remove_handler</NAME>
2213 <RETURNS>void </RETURNS>
2214 const gchar *log_domain,guint handler_id
2215 </FUNCTION>
2216 <FUNCTION>
2217 <NAME>g_log_default_handler</NAME>
2218 <RETURNS>void </RETURNS>
2219 const gchar *log_domain,GLogLevelFlags log_level,const gchar *message,gpointer unused_data
2220 </FUNCTION>
2221 <FUNCTION>
2222 <NAME>g_log</NAME>
2223 <RETURNS>void </RETURNS>
2224 const gchar *log_domain,GLogLevelFlags log_level,const gchar *format,...
2225 </FUNCTION>
2226 <FUNCTION>
2227 <NAME>g_logv</NAME>
2228 <RETURNS>void </RETURNS>
2229 const gchar *log_domain,GLogLevelFlags log_level,const gchar *format,va_list args
2230 </FUNCTION>
2231 <FUNCTION>
2232 <NAME>g_log_set_fatal_mask</NAME>
2233 <RETURNS>GLogLevelFlags </RETURNS>
2234 const gchar *log_domain,GLogLevelFlags fatal_mask
2235 </FUNCTION>
2236 <FUNCTION>
2237 <NAME>g_log_set_always_fatal</NAME>
2238 <RETURNS>GLogLevelFlags </RETURNS>
2239 GLogLevelFlags fatal_mask
2240 </FUNCTION>
2241 <MACRO>
2242 <NAME>G_LOG_DOMAIN</NAME>
2243 #define G_LOG_DOMAIN ((gchar*) 0)
2244 </MACRO>
2245 <MACRO>
2246 <NAME>g_error</NAME>
2247 #define g_error(...) g_log (G_LOG_DOMAIN, \
2248 G_LOG_LEVEL_ERROR, \
2249 __VA_ARGS__)
2250 </MACRO>
2251 <MACRO>
2252 <NAME>g_message</NAME>
2253 #define g_message(...) g_log (G_LOG_DOMAIN, \
2254 G_LOG_LEVEL_MESSAGE, \
2255 __VA_ARGS__)
2256 </MACRO>
2257 <MACRO>
2258 <NAME>g_critical</NAME>
2259 #define g_critical(...) g_log (G_LOG_DOMAIN, \
2260 G_LOG_LEVEL_CRITICAL, \
2261 __VA_ARGS__)
2262 </MACRO>
2263 <MACRO>
2264 <NAME>g_warning</NAME>
2265 #define g_warning(...) g_log (G_LOG_DOMAIN, \
2266 G_LOG_LEVEL_WARNING, \
2267 __VA_ARGS__)
2268 </MACRO>
2269 <MACRO>
2270 <NAME>g_error</NAME>
2271 #define g_error(format...) g_log (G_LOG_DOMAIN, \
2272 G_LOG_LEVEL_ERROR, \
2273 format)
2274 </MACRO>
2275 <MACRO>
2276 <NAME>g_message</NAME>
2277 #define g_message(format...) g_log (G_LOG_DOMAIN, \
2278 G_LOG_LEVEL_MESSAGE, \
2279 format)
2280 </MACRO>
2281 <MACRO>
2282 <NAME>g_critical</NAME>
2283 #define g_critical(format...) g_log (G_LOG_DOMAIN, \
2284 G_LOG_LEVEL_CRITICAL, \
2285 format)
2286 </MACRO>
2287 <MACRO>
2288 <NAME>g_warning</NAME>
2289 #define g_warning(format...) g_log (G_LOG_DOMAIN, \
2290 G_LOG_LEVEL_WARNING, \
2291 format)
2292 </MACRO>
2293 <USER_FUNCTION>
2294 <NAME>GPrintFunc</NAME>
2295 <RETURNS>void </RETURNS>
2296 const gchar *string
2297 </USER_FUNCTION>
2298 <FUNCTION>
2299 <NAME>g_print</NAME>
2300 <RETURNS>void </RETURNS>
2301 const gchar *format,...
2302 </FUNCTION>
2303 <FUNCTION>
2304 <NAME>g_set_print_handler</NAME>
2305 <RETURNS>GPrintFunc </RETURNS>
2306 GPrintFunc func
2307 </FUNCTION>
2308 <FUNCTION>
2309 <NAME>g_printerr</NAME>
2310 <RETURNS>void </RETURNS>
2311 const gchar *format,...
2312 </FUNCTION>
2313 <FUNCTION>
2314 <NAME>g_set_printerr_handler</NAME>
2315 <RETURNS>GPrintFunc </RETURNS>
2316 GPrintFunc func
2317 </FUNCTION>
2318 <USER_FUNCTION>
2319 <NAME>GErrorFunc</NAME>
2320 <RETURNS>void </RETURNS>
2321 const gchar *str
2322 </USER_FUNCTION>
2323 <USER_FUNCTION>
2324 <NAME>GWarningFunc</NAME>
2325 <RETURNS>void </RETURNS>
2326 const gchar *str
2327 </USER_FUNCTION>
2328 <FUNCTION>
2329 <NAME>g_set_error_handler</NAME>
2330 <RETURNS>GErrorFunc </RETURNS>
2331 GErrorFunc func
2332 </FUNCTION>
2333 <FUNCTION>
2334 <NAME>g_set_warning_handler</NAME>
2335 <RETURNS>GWarningFunc </RETURNS>
2336 GWarningFunc func
2337 </FUNCTION>
2338 <FUNCTION>
2339 <NAME>g_set_message_handler</NAME>
2340 <RETURNS>GPrintFunc </RETURNS>
2341 GPrintFunc func
2342 </FUNCTION>
2343 <MACRO>
2344 <NAME>g_malloc</NAME>
2345 #define g_malloc(size) ((gpointer) MALLOC (size))
2346 </MACRO>
2347 <MACRO>
2348 <NAME>g_malloc0</NAME>
2349 #define g_malloc0(size) ((gpointer) CALLOC (char, size))
2350 </MACRO>
2351 <MACRO>
2352 <NAME>g_realloc</NAME>
2353 #define g_realloc(mem,size) ((gpointer) REALLOC (mem, char, size))
2354 </MACRO>
2355 <MACRO>
2356 <NAME>g_free</NAME>
2357 #define g_free(mem) FREE (mem)
2358 </MACRO>
2359 <FUNCTION>
2360 <NAME>g_malloc</NAME>
2361 <RETURNS>gpointer </RETURNS>
2362 gulong size
2363 </FUNCTION>
2364 <FUNCTION>
2365 <NAME>g_malloc0</NAME>
2366 <RETURNS>gpointer </RETURNS>
2367 gulong size
2368 </FUNCTION>
2369 <FUNCTION>
2370 <NAME>g_realloc</NAME>
2371 <RETURNS>gpointer </RETURNS>
2372 gpointer mem,gulong size
2373 </FUNCTION>
2374 <FUNCTION>
2375 <NAME>g_free</NAME>
2376 <RETURNS>void </RETURNS>
2377 gpointer mem
2378 </FUNCTION>
2379 <FUNCTION>
2380 <NAME>g_mem_profile</NAME>
2381 <RETURNS>void </RETURNS>
2382 void
2383 </FUNCTION>
2384 <FUNCTION>
2385 <NAME>g_mem_check</NAME>
2386 <RETURNS>void </RETURNS>
2387 gpointer mem
2388 </FUNCTION>
2389 <FUNCTION>
2390 <NAME>g_allocator_new</NAME>
2391 <RETURNS>GAllocator *</RETURNS>
2392 const gchar *name,guint n_preallocs
2393 </FUNCTION>
2394 <FUNCTION>
2395 <NAME>g_allocator_free</NAME>
2396 <RETURNS>void </RETURNS>
2397 GAllocator *allocator
2398 </FUNCTION>
2399 <MACRO>
2400 <NAME>G_ALLOCATOR_LIST</NAME>
2401 #define G_ALLOCATOR_LIST (1)
2402 </MACRO>
2403 <MACRO>
2404 <NAME>G_ALLOCATOR_SLIST</NAME>
2405 #define G_ALLOCATOR_SLIST (2)
2406 </MACRO>
2407 <MACRO>
2408 <NAME>G_ALLOCATOR_NODE</NAME>
2409 #define G_ALLOCATOR_NODE (3)
2410 </MACRO>
2411 <MACRO>
2412 <NAME>G_ALLOC_ONLY</NAME>
2413 #define G_ALLOC_ONLY 1
2414 </MACRO>
2415 <MACRO>
2416 <NAME>G_ALLOC_AND_FREE</NAME>
2417 #define G_ALLOC_AND_FREE 2
2418 </MACRO>
2419 <FUNCTION>
2420 <NAME>g_mem_chunk_new</NAME>
2421 <RETURNS>GMemChunk *</RETURNS>
2422 gchar *name,gint atom_size,gulong area_size,gint type
2423 </FUNCTION>
2424 <FUNCTION>
2425 <NAME>g_mem_chunk_destroy</NAME>
2426 <RETURNS>void </RETURNS>
2427 GMemChunk *mem_chunk
2428 </FUNCTION>
2429 <FUNCTION>
2430 <NAME>g_mem_chunk_alloc</NAME>
2431 <RETURNS>gpointer </RETURNS>
2432 GMemChunk *mem_chunk
2433 </FUNCTION>
2434 <FUNCTION>
2435 <NAME>g_mem_chunk_alloc0</NAME>
2436 <RETURNS>gpointer </RETURNS>
2437 GMemChunk *mem_chunk
2438 </FUNCTION>
2439 <FUNCTION>
2440 <NAME>g_mem_chunk_free</NAME>
2441 <RETURNS>void </RETURNS>
2442 GMemChunk *mem_chunk,gpointer mem
2443 </FUNCTION>
2444 <FUNCTION>
2445 <NAME>g_mem_chunk_clean</NAME>
2446 <RETURNS>void </RETURNS>
2447 GMemChunk *mem_chunk
2448 </FUNCTION>
2449 <FUNCTION>
2450 <NAME>g_mem_chunk_reset</NAME>
2451 <RETURNS>void </RETURNS>
2452 GMemChunk *mem_chunk
2453 </FUNCTION>
2454 <FUNCTION>
2455 <NAME>g_mem_chunk_print</NAME>
2456 <RETURNS>void </RETURNS>
2457 GMemChunk *mem_chunk
2458 </FUNCTION>
2459 <FUNCTION>
2460 <NAME>g_mem_chunk_info</NAME>
2461 <RETURNS>void </RETURNS>
2462 void
2463 </FUNCTION>
2464 <FUNCTION>
2465 <NAME>g_blow_chunks</NAME>
2466 <RETURNS>void </RETURNS>
2467 void
2468 </FUNCTION>
2469 <MACRO>
2470 <NAME>G_MICROSEC</NAME>
2471 #define G_MICROSEC 1000000
2472 </MACRO>
2473 <FUNCTION>
2474 <NAME>g_timer_new</NAME>
2475 <RETURNS>GTimer *</RETURNS>
2476 void
2477 </FUNCTION>
2478 <FUNCTION>
2479 <NAME>g_timer_destroy</NAME>
2480 <RETURNS>void </RETURNS>
2481 GTimer *timer
2482 </FUNCTION>
2483 <FUNCTION>
2484 <NAME>g_timer_start</NAME>
2485 <RETURNS>void </RETURNS>
2486 GTimer *timer
2487 </FUNCTION>
2488 <FUNCTION>
2489 <NAME>g_timer_stop</NAME>
2490 <RETURNS>void </RETURNS>
2491 GTimer *timer
2492 </FUNCTION>
2493 <FUNCTION>
2494 <NAME>g_timer_reset</NAME>
2495 <RETURNS>void </RETURNS>
2496 GTimer *timer
2497 </FUNCTION>
2498 <FUNCTION>
2499 <NAME>g_timer_elapsed</NAME>
2500 <RETURNS>gdouble </RETURNS>
2501 GTimer *timer,gulong *microseconds
2502 </FUNCTION>
2503 <FUNCTION>
2504 <NAME>g_usleep</NAME>
2505 <RETURNS>void </RETURNS>
2506 gulong microseconds
2507 </FUNCTION>
2508 <MACRO>
2509 <NAME>G_STR_DELIMITERS</NAME>
2510 #define G_STR_DELIMITERS "_-|> <."
2511 </MACRO>
2512 <FUNCTION>
2513 <NAME>g_strdelimit</NAME>
2514 <RETURNS>gchar *</RETURNS>
2515 gchar *string,const gchar *delimiters,gchar new_delimiter
2516 </FUNCTION>
2517 <FUNCTION>
2518 <NAME>g_strcanon</NAME>
2519 <RETURNS>gchar *</RETURNS>
2520 gchar *string,const gchar *valid_chars,gchar subsitutor
2521 </FUNCTION>
2522 <FUNCTION>
2523 <NAME>g_strtod</NAME>
2524 <RETURNS>gdouble </RETURNS>
2525 const gchar *nptr,gchar **endptr
2526 </FUNCTION>
2527 <FUNCTION>
2528 <NAME>g_strerror</NAME>
2529 <RETURNS>gchar *</RETURNS>
2530 gint errnum
2531 </FUNCTION>
2532 <FUNCTION>
2533 <NAME>g_strsignal</NAME>
2534 <RETURNS>gchar *</RETURNS>
2535 gint signum
2536 </FUNCTION>
2537 <FUNCTION>
2538 <NAME>g_strcasecmp</NAME>
2539 <RETURNS>gint </RETURNS>
2540 const gchar *s1,const gchar *s2
2541 </FUNCTION>
2542 <FUNCTION>
2543 <NAME>g_strncasecmp</NAME>
2544 <RETURNS>gint </RETURNS>
2545 const gchar *s1,const gchar *s2,guint n
2546 </FUNCTION>
2547 <FUNCTION>
2548 <NAME>g_strdown</NAME>
2549 <RETURNS>gchar *</RETURNS>
2550 gchar *string
2551 </FUNCTION>
2552 <FUNCTION>
2553 <NAME>g_strup</NAME>
2554 <RETURNS>gchar *</RETURNS>
2555 gchar *string
2556 </FUNCTION>
2557 <FUNCTION>
2558 <NAME>g_strreverse</NAME>
2559 <RETURNS>gchar *</RETURNS>
2560 gchar *string
2561 </FUNCTION>
2562 <FUNCTION>
2563 <NAME>g_strlcpy</NAME>
2564 <RETURNS>gsize </RETURNS>
2565 gchar *dest,const gchar *src,gsize dest_size
2566 </FUNCTION>
2567 <FUNCTION>
2568 <NAME>g_strlcat</NAME>
2569 <RETURNS>gsize </RETURNS>
2570 gchar *dest,const gchar *src,gsize dest_size
2571 </FUNCTION>
2572 <FUNCTION>
2573 <NAME>g_strchug</NAME>
2574 <RETURNS>gchar *</RETURNS>
2575 gchar *string
2576 </FUNCTION>
2577 <FUNCTION>
2578 <NAME>g_strchomp</NAME>
2579 <RETURNS>gchar *</RETURNS>
2580 gchar *string
2581 </FUNCTION>
2582 <MACRO>
2583 <NAME>g_strstrip</NAME>
2584 #define g_strstrip( string ) g_strchomp (g_strchug (string))
2585 </MACRO>
2586 <FUNCTION>
2587 <NAME>g_strdup</NAME>
2588 <RETURNS>gchar *</RETURNS>
2589 const gchar *str
2590 </FUNCTION>
2591 <FUNCTION>
2592 <NAME>g_strdup_printf</NAME>
2593 <RETURNS>gchar *</RETURNS>
2594 const gchar *format,...
2595 </FUNCTION>
2596 <FUNCTION>
2597 <NAME>g_strdup_vprintf</NAME>
2598 <RETURNS>gchar *</RETURNS>
2599 const gchar *format,va_list args
2600 </FUNCTION>
2601 <FUNCTION>
2602 <NAME>g_strndup</NAME>
2603 <RETURNS>gchar *</RETURNS>
2604 const gchar *str,guint n
2605 </FUNCTION>
2606 <FUNCTION>
2607 <NAME>g_strnfill</NAME>
2608 <RETURNS>gchar *</RETURNS>
2609 guint length,gchar fill_char
2610 </FUNCTION>
2611 <FUNCTION>
2612 <NAME>g_strconcat</NAME>
2613 <RETURNS>gchar *</RETURNS>
2614 const gchar *string1,...
2615 </FUNCTION>
2616 <FUNCTION>
2617 <NAME>g_strjoin</NAME>
2618 <RETURNS>gchar *</RETURNS>
2619 const gchar *separator,...
2620 </FUNCTION>
2621 <FUNCTION>
2622 <NAME>g_strcompress</NAME>
2623 <RETURNS>gchar *</RETURNS>
2624 const gchar *source
2625 </FUNCTION>
2626 <FUNCTION>
2627 <NAME>g_filename_to_utf8</NAME>
2628 <RETURNS>gchar *</RETURNS>
2629 const gchar *opsysstring
2630 </FUNCTION>
2631 <FUNCTION>
2632 <NAME>g_filename_from_utf8</NAME>
2633 <RETURNS>gchar *</RETURNS>
2634 const gchar *utf8string
2635 </FUNCTION>
2636 <FUNCTION>
2637 <NAME>g_strescape</NAME>
2638 <RETURNS>gchar *</RETURNS>
2639 const gchar *source,const gchar *exceptions
2640 </FUNCTION>
2641 <FUNCTION>
2642 <NAME>g_memdup</NAME>
2643 <RETURNS>gpointer </RETURNS>
2644 gconstpointer mem,guint byte_size
2645 </FUNCTION>
2646 <FUNCTION>
2647 <NAME>g_strsplit</NAME>
2648 <RETURNS>gchar **</RETURNS>
2649 const gchar *string,const gchar *delimiter,gint max_tokens
2650 </FUNCTION>
2651 <FUNCTION>
2652 <NAME>g_strjoinv</NAME>
2653 <RETURNS>gchar *</RETURNS>
2654 const gchar *separator,gchar **str_array
2655 </FUNCTION>
2656 <FUNCTION>
2657 <NAME>g_strfreev</NAME>
2658 <RETURNS>void </RETURNS>
2659 gchar **str_array
2660 </FUNCTION>
2661 <FUNCTION>
2662 <NAME>g_printf_string_upper_bound</NAME>
2663 <RETURNS>guint </RETURNS>
2664 const gchar* format,va_list args
2665 </FUNCTION>
2666 <FUNCTION>
2667 <NAME>g_get_user_name</NAME>
2668 <RETURNS>gchar *</RETURNS>
2669 void
2670 </FUNCTION>
2671 <FUNCTION>
2672 <NAME>g_get_real_name</NAME>
2673 <RETURNS>gchar *</RETURNS>
2674 void
2675 </FUNCTION>
2676 <FUNCTION>
2677 <NAME>g_get_home_dir</NAME>
2678 <RETURNS>gchar *</RETURNS>
2679 void
2680 </FUNCTION>
2681 <FUNCTION>
2682 <NAME>g_get_tmp_dir</NAME>
2683 <RETURNS>gchar *</RETURNS>
2684 void
2685 </FUNCTION>
2686 <FUNCTION>
2687 <NAME>g_get_prgname</NAME>
2688 <RETURNS>gchar *</RETURNS>
2689 void
2690 </FUNCTION>
2691 <FUNCTION>
2692 <NAME>g_set_prgname</NAME>
2693 <RETURNS>void </RETURNS>
2694 const gchar *prgname
2695 </FUNCTION>
2696 <FUNCTION>
2697 <NAME>g_parse_debug_string</NAME>
2698 <RETURNS>guint </RETURNS>
2699 const gchar *string,GDebugKey *keys,guint nkeys
2700 </FUNCTION>
2701 <FUNCTION>
2702 <NAME>g_snprintf</NAME>
2703 <RETURNS>gint </RETURNS>
2704 gchar *string,gulong n,gchar const *format,...
2705 </FUNCTION>
2706 <FUNCTION>
2707 <NAME>g_vsnprintf</NAME>
2708 <RETURNS>gint </RETURNS>
2709 gchar *string,gulong n,gchar const *format,va_list args
2710 </FUNCTION>
2711 <FUNCTION>
2712 <NAME>g_path_is_absolute</NAME>
2713 <RETURNS>gboolean </RETURNS>
2714 const gchar *file_name
2715 </FUNCTION>
2716 <FUNCTION>
2717 <NAME>g_path_skip_root</NAME>
2718 <RETURNS>gchar *</RETURNS>
2719 gchar *file_name
2720 </FUNCTION>
2721 <FUNCTION>
2722 <NAME>g_basename</NAME>
2723 <RETURNS>gchar *</RETURNS>
2724 const gchar *file_name
2725 </FUNCTION>
2726 <FUNCTION>
2727 <NAME>g_dirname</NAME>
2728 <RETURNS>gchar *</RETURNS>
2729 const gchar *file_name
2730 </FUNCTION>
2731 <FUNCTION>
2732 <NAME>g_get_current_dir</NAME>
2733 <RETURNS>gchar *</RETURNS>
2734 void
2735 </FUNCTION>
2736 <FUNCTION>
2737 <NAME>g_path_get_basename</NAME>
2738 <RETURNS>gchar *</RETURNS>
2739 const gchar *file_name
2740 </FUNCTION>
2741 <FUNCTION>
2742 <NAME>g_path_get_dirname</NAME>
2743 <RETURNS>gchar *</RETURNS>
2744 const gchar *file_name
2745 </FUNCTION>
2746 <FUNCTION>
2747 <NAME>g_getenv</NAME>
2748 <RETURNS>gchar *</RETURNS>
2749 const gchar *variable
2750 </FUNCTION>
2751 <FUNCTION>
2752 <NAME>g_atexit</NAME>
2753 <RETURNS>void </RETURNS>
2754 GVoidFunc func
2755 </FUNCTION>
2756 <FUNCTION>
2757 <NAME>g_bit_nth_lsf</NAME>
2758 <RETURNS>gint </RETURNS>
2759 guint32 mask,gint nth_bit
2760 </FUNCTION>
2761 <FUNCTION>
2762 <NAME>g_bit_nth_msf</NAME>
2763 <RETURNS>gint </RETURNS>
2764 guint32 mask,gint nth_bit
2765 </FUNCTION>
2766 <FUNCTION>
2767 <NAME>g_bit_storage</NAME>
2768 <RETURNS>guint </RETURNS>
2769 guint number
2770 </FUNCTION>
2771 <FUNCTION>
2772 <NAME>g_trash_stack_push</NAME>
2773 <RETURNS>void </RETURNS>
2774 GTrashStack **stack_p,gpointer data_p
2775 </FUNCTION>
2776 <FUNCTION>
2777 <NAME>g_trash_stack_pop</NAME>
2778 <RETURNS>gpointer </RETURNS>
2779 GTrashStack **stack_p
2780 </FUNCTION>
2781 <FUNCTION>
2782 <NAME>g_trash_stack_peek</NAME>
2783 <RETURNS>gpointer </RETURNS>
2784 GTrashStack **stack_p
2785 </FUNCTION>
2786 <FUNCTION>
2787 <NAME>g_trash_stack_height</NAME>
2788 <RETURNS>guint </RETURNS>
2789 GTrashStack **stack_p
2790 </FUNCTION>
2791 <FUNCTION>
2792 <NAME>g_string_chunk_new</NAME>
2793 <RETURNS>GStringChunk *</RETURNS>
2794 gint size
2795 </FUNCTION>
2796 <FUNCTION>
2797 <NAME>g_string_chunk_free</NAME>
2798 <RETURNS>void </RETURNS>
2799 GStringChunk *chunk
2800 </FUNCTION>
2801 <FUNCTION>
2802 <NAME>g_string_chunk_insert</NAME>
2803 <RETURNS>gchar *</RETURNS>
2804 GStringChunk *chunk,const gchar *string
2805 </FUNCTION>
2806 <FUNCTION>
2807 <NAME>g_string_chunk_insert_const</NAME>
2808 <RETURNS>gchar *</RETURNS>
2809 GStringChunk *chunk,const gchar *string
2810 </FUNCTION>
2811 <FUNCTION>
2812 <NAME>g_string_new</NAME>
2813 <RETURNS>GString *</RETURNS>
2814 const gchar *init
2815 </FUNCTION>
2816 <FUNCTION>
2817 <NAME>g_string_sized_new</NAME>
2818 <RETURNS>GString *</RETURNS>
2819 guint dfl_size
2820 </FUNCTION>
2821 <FUNCTION>
2822 <NAME>g_string_free</NAME>
2823 <RETURNS>gchar *</RETURNS>
2824 GString *string,gboolean free_segment
2825 </FUNCTION>
2826 <FUNCTION>
2827 <NAME>g_string_equal</NAME>
2828 <RETURNS>gboolean </RETURNS>
2829 const GString *v,const GString *v2
2830 </FUNCTION>
2831 <FUNCTION>
2832 <NAME>g_string_hash</NAME>
2833 <RETURNS>guint </RETURNS>
2834 const GString *str
2835 </FUNCTION>
2836 <FUNCTION>
2837 <NAME>g_string_assign</NAME>
2838 <RETURNS>GString *</RETURNS>
2839 GString *string,const gchar *rval
2840 </FUNCTION>
2841 <FUNCTION>
2842 <NAME>g_string_truncate</NAME>
2843 <RETURNS>GString *</RETURNS>
2844 GString *string,guint len
2845 </FUNCTION>
2846 <FUNCTION>
2847 <NAME>g_string_insert_len</NAME>
2848 <RETURNS>GString *</RETURNS>
2849 GString *string,gint pos,const gchar *val,gint len
2850 </FUNCTION>
2851 <FUNCTION>
2852 <NAME>g_string_append</NAME>
2853 <RETURNS>GString *</RETURNS>
2854 GString *string,const gchar *val
2855 </FUNCTION>
2856 <FUNCTION>
2857 <NAME>g_string_append_len</NAME>
2858 <RETURNS>GString *</RETURNS>
2859 GString *string,const gchar *val,gint len
2860 </FUNCTION>
2861 <FUNCTION>
2862 <NAME>g_string_append_c</NAME>
2863 <RETURNS>GString *</RETURNS>
2864 GString *string,gchar c
2865 </FUNCTION>
2866 <FUNCTION>
2867 <NAME>g_string_prepend</NAME>
2868 <RETURNS>GString *</RETURNS>
2869 GString *string,const gchar *val
2870 </FUNCTION>
2871 <FUNCTION>
2872 <NAME>g_string_prepend_c</NAME>
2873 <RETURNS>GString *</RETURNS>
2874 GString *string,gchar c
2875 </FUNCTION>
2876 <FUNCTION>
2877 <NAME>g_string_prepend_len</NAME>
2878 <RETURNS>GString *</RETURNS>
2879 GString *string,const gchar *val,gint len
2880 </FUNCTION>
2881 <FUNCTION>
2882 <NAME>g_string_insert</NAME>
2883 <RETURNS>GString *</RETURNS>
2884 GString *string,gint pos,const gchar *val
2885 </FUNCTION>
2886 <FUNCTION>
2887 <NAME>g_string_insert_c</NAME>
2888 <RETURNS>GString *</RETURNS>
2889 GString *string,gint pos,gchar c
2890 </FUNCTION>
2891 <FUNCTION>
2892 <NAME>g_string_erase</NAME>
2893 <RETURNS>GString *</RETURNS>
2894 GString *string,gint pos,gint len
2895 </FUNCTION>
2896 <FUNCTION>
2897 <NAME>g_string_down</NAME>
2898 <RETURNS>GString *</RETURNS>
2899 GString *string
2900 </FUNCTION>
2901 <FUNCTION>
2902 <NAME>g_string_up</NAME>
2903 <RETURNS>GString *</RETURNS>
2904 GString *string
2905 </FUNCTION>
2906 <FUNCTION>
2907 <NAME>g_string_sprintf</NAME>
2908 <RETURNS>void </RETURNS>
2909 GString *string,const gchar *format,...
2910 </FUNCTION>
2911 <FUNCTION>
2912 <NAME>g_string_sprintfa</NAME>
2913 <RETURNS>void </RETURNS>
2914 GString *string,const gchar *format,...
2915 </FUNCTION>
2916 <MACRO>
2917 <NAME>g_array_append_val</NAME>
2918 #define g_array_append_val(a,v) g_array_append_vals (a, &v, 1)
2919 </MACRO>
2920 <MACRO>
2921 <NAME>g_array_prepend_val</NAME>
2922 #define g_array_prepend_val(a,v) g_array_prepend_vals (a, &v, 1)
2923 </MACRO>
2924 <MACRO>
2925 <NAME>g_array_insert_val</NAME>
2926 #define g_array_insert_val(a,i,v) g_array_insert_vals (a, i, &v, 1)
2927 </MACRO>
2928 <MACRO>
2929 <NAME>g_array_index</NAME>
2930 #define g_array_index(a,t,i) (((t*) (a)->data) [(i)])
2931 </MACRO>
2932 <FUNCTION>
2933 <NAME>g_array_new</NAME>
2934 <RETURNS>GArray *</RETURNS>
2935 gboolean zero_terminated,gboolean clear,guint element_size
2936 </FUNCTION>
2937 <FUNCTION>
2938 <NAME>g_array_sized_new</NAME>
2939 <RETURNS>GArray *</RETURNS>
2940 gboolean zero_terminated,gboolean clear,guint element_size,guint reserved_size
2941 </FUNCTION>
2942 <FUNCTION>
2943 <NAME>g_array_free</NAME>
2944 <RETURNS>gchar *</RETURNS>
2945 GArray *array,gboolean free_segment
2946 </FUNCTION>
2947 <FUNCTION>
2948 <NAME>g_array_append_vals</NAME>
2949 <RETURNS>GArray *</RETURNS>
2950 GArray *array,gconstpointer data,guint len
2951 </FUNCTION>
2952 <FUNCTION>
2953 <NAME>g_array_prepend_vals</NAME>
2954 <RETURNS>GArray *</RETURNS>
2955 GArray *array,gconstpointer data,guint len
2956 </FUNCTION>
2957 <FUNCTION>
2958 <NAME>g_array_insert_vals</NAME>
2959 <RETURNS>GArray *</RETURNS>
2960 GArray *array,guint index,gconstpointer data,guint len
2961 </FUNCTION>
2962 <FUNCTION>
2963 <NAME>g_array_set_size</NAME>
2964 <RETURNS>GArray *</RETURNS>
2965 GArray *array,guint length
2966 </FUNCTION>
2967 <FUNCTION>
2968 <NAME>g_array_remove_index</NAME>
2969 <RETURNS>GArray *</RETURNS>
2970 GArray *array,guint index
2971 </FUNCTION>
2972 <FUNCTION>
2973 <NAME>g_array_remove_index_fast</NAME>
2974 <RETURNS>GArray *</RETURNS>
2975 GArray *array,guint index
2976 </FUNCTION>
2977 <MACRO>
2978 <NAME>g_ptr_array_index</NAME>
2979 #define g_ptr_array_index(array,index) (array->pdata)[index]
2980 </MACRO>
2981 <FUNCTION>
2982 <NAME>g_ptr_array_new</NAME>
2983 <RETURNS>GPtrArray *</RETURNS>
2984 void
2985 </FUNCTION>
2986 <FUNCTION>
2987 <NAME>g_ptr_array_sized_new</NAME>
2988 <RETURNS>GPtrArray *</RETURNS>
2989 guint reserved_size
2990 </FUNCTION>
2991 <FUNCTION>
2992 <NAME>g_ptr_array_free</NAME>
2993 <RETURNS>gpointer *</RETURNS>
2994 GPtrArray *array,gboolean free_seg
2995 </FUNCTION>
2996 <FUNCTION>
2997 <NAME>g_ptr_array_set_size</NAME>
2998 <RETURNS>void </RETURNS>
2999 GPtrArray *array,gint length
3000 </FUNCTION>
3001 <FUNCTION>
3002 <NAME>g_ptr_array_remove_index</NAME>
3003 <RETURNS>gpointer </RETURNS>
3004 GPtrArray *array,guint index
3005 </FUNCTION>
3006 <FUNCTION>
3007 <NAME>g_ptr_array_remove_index_fast</NAME>
3008 <RETURNS>gpointer </RETURNS>
3009 GPtrArray *array,guint index
3010 </FUNCTION>
3011 <FUNCTION>
3012 <NAME>g_ptr_array_remove</NAME>
3013 <RETURNS>gboolean </RETURNS>
3014 GPtrArray *array,gpointer data
3015 </FUNCTION>
3016 <FUNCTION>
3017 <NAME>g_ptr_array_remove_fast</NAME>
3018 <RETURNS>gboolean </RETURNS>
3019 GPtrArray *array,gpointer data
3020 </FUNCTION>
3021 <FUNCTION>
3022 <NAME>g_ptr_array_add</NAME>
3023 <RETURNS>void </RETURNS>
3024 GPtrArray *array,gpointer data
3025 </FUNCTION>
3026 <FUNCTION>
3027 <NAME>g_byte_array_new</NAME>
3028 <RETURNS>GByteArray *</RETURNS>
3029 void
3030 </FUNCTION>
3031 <FUNCTION>
3032 <NAME>g_byte_array_sized_new</NAME>
3033 <RETURNS>GByteArray *</RETURNS>
3034 guint reserved_size
3035 </FUNCTION>
3036 <FUNCTION>
3037 <NAME>g_byte_array_free</NAME>
3038 <RETURNS>guint8 *</RETURNS>
3039 GByteArray *array,gboolean free_segment
3040 </FUNCTION>
3041 <FUNCTION>
3042 <NAME>g_byte_array_append</NAME>
3043 <RETURNS>GByteArray *</RETURNS>
3044 GByteArray *array,const guint8 *data,guint len
3045 </FUNCTION>
3046 <FUNCTION>
3047 <NAME>g_byte_array_prepend</NAME>
3048 <RETURNS>GByteArray *</RETURNS>
3049 GByteArray *array,const guint8 *data,guint len
3050 </FUNCTION>
3051 <FUNCTION>
3052 <NAME>g_byte_array_set_size</NAME>
3053 <RETURNS>GByteArray *</RETURNS>
3054 GByteArray *array,guint length
3055 </FUNCTION>
3056 <FUNCTION>
3057 <NAME>g_byte_array_remove_index</NAME>
3058 <RETURNS>GByteArray *</RETURNS>
3059 GByteArray *array,guint index
3060 </FUNCTION>
3061 <FUNCTION>
3062 <NAME>g_byte_array_remove_index_fast</NAME>
3063 <RETURNS>GByteArray *</RETURNS>
3064 GByteArray *array,guint index
3065 </FUNCTION>
3066 <FUNCTION>
3067 <NAME>g_str_equal</NAME>
3068 <RETURNS>gboolean </RETURNS>
3069 gconstpointer v,gconstpointer v2
3070 </FUNCTION>
3071 <FUNCTION>
3072 <NAME>g_str_hash</NAME>
3073 <RETURNS>guint </RETURNS>
3074 gconstpointer v
3075 </FUNCTION>
3076 <FUNCTION>
3077 <NAME>g_int_equal</NAME>
3078 <RETURNS>gint </RETURNS>
3079 gconstpointer v,gconstpointer v2
3080 </FUNCTION>
3081 <FUNCTION>
3082 <NAME>g_int_hash</NAME>
3083 <RETURNS>guint </RETURNS>
3084 gconstpointer v
3085 </FUNCTION>
3086 <FUNCTION>
3087 <NAME>g_direct_hash</NAME>
3088 <RETURNS>guint </RETURNS>
3089 gconstpointer v
3090 </FUNCTION>
3091 <FUNCTION>
3092 <NAME>g_direct_equal</NAME>
3093 <RETURNS>gint </RETURNS>
3094 gconstpointer v,gconstpointer v2
3095 </FUNCTION>
3096 <FUNCTION>
3097 <NAME>g_quark_try_string</NAME>
3098 <RETURNS>GQuark </RETURNS>
3099 const gchar *string
3100 </FUNCTION>
3101 <FUNCTION>
3102 <NAME>g_quark_from_static_string</NAME>
3103 <RETURNS>GQuark </RETURNS>
3104 const gchar *string
3105 </FUNCTION>
3106 <FUNCTION>
3107 <NAME>g_quark_from_string</NAME>
3108 <RETURNS>GQuark </RETURNS>
3109 const gchar *string
3110 </FUNCTION>
3111 <FUNCTION>
3112 <NAME>g_quark_to_string</NAME>
3113 <RETURNS>gchar *</RETURNS>
3114 GQuark quark
3115 </FUNCTION>
3116 <FUNCTION>
3117 <NAME>g_datalist_init</NAME>
3118 <RETURNS>void </RETURNS>
3119 GData **datalist
3120 </FUNCTION>
3121 <FUNCTION>
3122 <NAME>g_datalist_clear</NAME>
3123 <RETURNS>void </RETURNS>
3124 GData **datalist
3125 </FUNCTION>
3126 <FUNCTION>
3127 <NAME>g_datalist_id_get_data</NAME>
3128 <RETURNS>gpointer </RETURNS>
3129 GData **datalist,GQuark key_id
3130 </FUNCTION>
3131 <FUNCTION>
3132 <NAME>g_datalist_id_set_data_full</NAME>
3133 <RETURNS>void </RETURNS>
3134 GData **datalist,GQuark key_id,gpointer data,GDestroyNotify destroy_func
3135 </FUNCTION>
3136 <FUNCTION>
3137 <NAME>g_datalist_id_remove_no_notify</NAME>
3138 <RETURNS>gpointer </RETURNS>
3139 GData **datalist,GQuark key_id
3140 </FUNCTION>
3141 <FUNCTION>
3142 <NAME>g_datalist_foreach</NAME>
3143 <RETURNS>void </RETURNS>
3144 GData **datalist,GDataForeachFunc func,gpointer user_data
3145 </FUNCTION>
3146 <MACRO>
3147 <NAME>g_datalist_id_set_data</NAME>
3148 #define g_datalist_id_set_data(dl, q, d) \
3149 g_datalist_id_set_data_full ((dl), (q), (d), NULL)
3150 </MACRO>
3151 <MACRO>
3152 <NAME>g_datalist_id_remove_data</NAME>
3153 #define g_datalist_id_remove_data(dl, q) \
3154 g_datalist_id_set_data ((dl), (q), NULL)
3155 </MACRO>
3156 <MACRO>
3157 <NAME>g_datalist_get_data</NAME>
3158 #define g_datalist_get_data(dl, k) \
3159 (g_datalist_id_get_data ((dl), g_quark_try_string (k)))
3160 </MACRO>
3161 <MACRO>
3162 <NAME>g_datalist_set_data_full</NAME>
3163 #define g_datalist_set_data_full(dl, k, d, f) \
3164 g_datalist_id_set_data_full ((dl), g_quark_from_string (k), (d), (f))
3165 </MACRO>
3166 <MACRO>
3167 <NAME>g_datalist_remove_no_notify</NAME>
3168 #define g_datalist_remove_no_notify(dl, k) \
3169 g_datalist_id_remove_no_notify ((dl), g_quark_try_string (k))
3170 </MACRO>
3171 <MACRO>
3172 <NAME>g_datalist_set_data</NAME>
3173 #define g_datalist_set_data(dl, k, d) \
3174 g_datalist_set_data_full ((dl), (k), (d), NULL)
3175 </MACRO>
3176 <MACRO>
3177 <NAME>g_datalist_remove_data</NAME>
3178 #define g_datalist_remove_data(dl, k) \
3179 g_datalist_id_set_data ((dl), g_quark_try_string (k), NULL)
3180 </MACRO>
3181 <FUNCTION>
3182 <NAME>g_dataset_destroy</NAME>
3183 <RETURNS>void </RETURNS>
3184 gconstpointer dataset_location
3185 </FUNCTION>
3186 <FUNCTION>
3187 <NAME>g_dataset_id_get_data</NAME>
3188 <RETURNS>gpointer </RETURNS>
3189 gconstpointer dataset_location,GQuark key_id
3190 </FUNCTION>
3191 <FUNCTION>
3192 <NAME>g_dataset_id_set_data_full</NAME>
3193 <RETURNS>void </RETURNS>
3194 gconstpointer dataset_location,GQuark key_id,gpointer data,GDestroyNotify destroy_func
3195 </FUNCTION>
3196 <FUNCTION>
3197 <NAME>g_dataset_id_remove_no_notify</NAME>
3198 <RETURNS>gpointer </RETURNS>
3199 gconstpointer dataset_location,GQuark key_id
3200 </FUNCTION>
3201 <FUNCTION>
3202 <NAME>g_dataset_foreach</NAME>
3203 <RETURNS>void </RETURNS>
3204 gconstpointer dataset_location,GDataForeachFunc func,gpointer user_data
3205 </FUNCTION>
3206 <MACRO>
3207 <NAME>g_dataset_id_set_data</NAME>
3208 #define g_dataset_id_set_data(l, k, d) \
3209 g_dataset_id_set_data_full ((l), (k), (d), NULL)
3210 </MACRO>
3211 <MACRO>
3212 <NAME>g_dataset_id_remove_data</NAME>
3213 #define g_dataset_id_remove_data(l, k) \
3214 g_dataset_id_set_data ((l), (k), NULL)
3215 </MACRO>
3216 <MACRO>
3217 <NAME>g_dataset_get_data</NAME>
3218 #define g_dataset_get_data(l, k) \
3219 (g_dataset_id_get_data ((l), g_quark_try_string (k)))
3220 </MACRO>
3221 <MACRO>
3222 <NAME>g_dataset_set_data_full</NAME>
3223 #define g_dataset_set_data_full(l, k, d, f) \
3224 g_dataset_id_set_data_full ((l), g_quark_from_string (k), (d), (f))
3225 </MACRO>
3226 <MACRO>
3227 <NAME>g_dataset_remove_no_notify</NAME>
3228 #define g_dataset_remove_no_notify(l, k) \
3229 g_dataset_id_remove_no_notify ((l), g_quark_try_string (k))
3230 </MACRO>
3231 <MACRO>
3232 <NAME>g_dataset_set_data</NAME>
3233 #define g_dataset_set_data(l, k, d) \
3234 g_dataset_set_data_full ((l), (k), (d), NULL)
3235 </MACRO>
3236 <MACRO>
3237 <NAME>g_dataset_remove_data</NAME>
3238 #define g_dataset_remove_data(l, k) \
3239 g_dataset_id_set_data ((l), g_quark_try_string (k), NULL)
3240 </MACRO>
3241 <MACRO>
3242 <NAME>G_CSET_A_2_Z</NAME>
3243 #define G_CSET_A_2_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
3244 </MACRO>
3245 <MACRO>
3246 <NAME>G_CSET_a_2_z</NAME>
3247 #define G_CSET_a_2_z "abcdefghijklmnopqrstuvwxyz"
3248 </MACRO>
3249 <MACRO>
3250 <NAME>G_CSET_DIGITS</NAME>
3251 #define G_CSET_DIGITS "0123456789"
3252 </MACRO>
3253 <MACRO>
3254 <NAME>G_CSET_LATINC</NAME>
3255 #define G_CSET_LATINC "\300\301\302\303\304\305\306"\
3256 "\307\310\311\312\313\314\315\316\317\320"\
3257 "\321\322\323\324\325\326"\
3258 "\330\331\332\333\334\335\336"
3259 </MACRO>
3260 <MACRO>
3261 <NAME>G_CSET_LATINS</NAME>
3262 #define G_CSET_LATINS "\337\340\341\342\343\344\345\346"\
3263 "\347\350\351\352\353\354\355\356\357\360"\
3264 "\361\362\363\364\365\366"\
3265 "\370\371\372\373\374\375\376\377"
3266 </MACRO>
3267 <ENUM>
3268 <NAME>GErrorType</NAME>
3269 typedef enum
3270 {
3271 G_ERR_UNKNOWN,
3272 G_ERR_UNEXP_EOF,
3273 G_ERR_UNEXP_EOF_IN_STRING,
3274 G_ERR_UNEXP_EOF_IN_COMMENT,
3275 G_ERR_NON_DIGIT_IN_CONST,
3276 G_ERR_DIGIT_RADIX,
3277 G_ERR_FLOAT_RADIX,
3278 G_ERR_FLOAT_MALFORMED
3279 } GErrorType;
3280 </ENUM>
3281 <ENUM>
3282 <NAME>GTokenType</NAME>
3283 typedef enum
3284 {
3285 G_TOKEN_EOF = 0,
3287 G_TOKEN_LEFT_PAREN = '(',
3288 G_TOKEN_RIGHT_PAREN = ')',
3289 G_TOKEN_LEFT_CURLY = '{',
3290 G_TOKEN_RIGHT_CURLY = '}',
3291 G_TOKEN_LEFT_BRACE = '[',
3292 G_TOKEN_RIGHT_BRACE = ']',
3293 G_TOKEN_EQUAL_SIGN = '=',
3294 G_TOKEN_COMMA = ',',
3296 G_TOKEN_NONE = 256,
3298 G_TOKEN_ERROR,
3300 G_TOKEN_CHAR,
3301 G_TOKEN_BINARY,
3302 G_TOKEN_OCTAL,
3303 G_TOKEN_INT,
3304 G_TOKEN_HEX,
3305 G_TOKEN_FLOAT,
3306 G_TOKEN_STRING,
3308 G_TOKEN_SYMBOL,
3309 G_TOKEN_IDENTIFIER,
3310 G_TOKEN_IDENTIFIER_NULL,
3312 G_TOKEN_COMMENT_SINGLE,
3313 G_TOKEN_COMMENT_MULTI,
3314 G_TOKEN_LAST
3315 } GTokenType;
3316 </ENUM>
3317 <UNION>
3318 <NAME>GTokenValue</NAME>
3319 union GTokenValue
3320 {
3321 gpointer v_symbol;
3322 gchar *v_identifier;
3323 gulong v_binary;
3324 gulong v_octal;
3325 gulong v_int;
3326 gdouble v_float;
3327 gulong v_hex;
3328 gchar *v_string;
3329 gchar *v_comment;
3330 guchar v_char;
3331 guint v_error;
3332 };
3333 </UNION>
3334 <STRUCT>
3335 <NAME>GScannerConfig</NAME>
3336 struct GScannerConfig
3337 {
3338 /* Character sets
3339 */
3340 gchar *cset_skip_characters; /* default: " \t\n" */
3341 gchar *cset_identifier_first;
3342 gchar *cset_identifier_nth;
3343 gchar *cpair_comment_single; /* default: "#\n" */
3345 /* Should symbol lookup work case sensitive?
3346 */
3347 guint case_sensitive : 1;
3349 /* Boolean values to be adjusted "on the fly"
3350 * to configure scanning behaviour.
3351 */
3352 guint skip_comment_multi : 1; /* C like comment */
3353 guint skip_comment_single : 1; /* single line comment */
3354 guint scan_comment_multi : 1; /* scan multi line comments? */
3355 guint scan_identifier : 1;
3356 guint scan_identifier_1char : 1;
3357 guint scan_identifier_NULL : 1;
3358 guint scan_symbols : 1;
3359 guint scan_binary : 1;
3360 guint scan_octal : 1;
3361 guint scan_float : 1;
3362 guint scan_hex : 1; /* `0x0ff0' */
3363 guint scan_hex_dollar : 1; /* `$0ff0' */
3364 guint scan_string_sq : 1; /* string: 'anything' */
3365 guint scan_string_dq : 1; /* string: "\\-escapes!\n" */
3366 guint numbers_2_int : 1; /* bin, octal, hex => int */
3367 guint int_2_float : 1; /* int => G_TOKEN_FLOAT? */
3368 guint identifier_2_string : 1;
3369 guint char_2_token : 1; /* return G_TOKEN_CHAR? */
3370 guint symbol_2_token : 1;
3371 guint scope_0_fallback : 1; /* try scope 0 on lookups? */
3372 };
3373 </STRUCT>
3374 <STRUCT>
3375 <NAME>GScanner</NAME>
3376 struct GScanner
3377 {
3378 /* unused fields */
3379 gpointer user_data;
3380 guint max_parse_errors;
3382 /* g_scanner_error() increments this field */
3383 guint parse_errors;
3385 /* name of input stream, featured by the default message handler */
3386 const gchar *input_name;
3388 /* data pointer for derived structures */
3389 gpointer derived_data;
3391 /* link into the scanner configuration */
3392 GScannerConfig *config;
3394 /* fields filled in after g_scanner_get_next_token() */
3395 GTokenType token;
3396 GTokenValue value;
3397 guint line;
3398 guint position;
3400 /* fields filled in after g_scanner_peek_next_token() */
3401 GTokenType next_token;
3402 GTokenValue next_value;
3403 guint next_line;
3404 guint next_position;
3406 /* to be considered private */
3407 GHashTable *symbol_table;
3408 gint input_fd;
3409 const gchar *text;
3410 const gchar *text_end;
3411 gchar *buffer;
3412 guint scope_id;
3414 /* handler function for _warn and _error */
3415 GScannerMsgFunc msg_handler;
3416 };
3417 </STRUCT>
3418 <FUNCTION>
3419 <NAME>g_scanner_new</NAME>
3420 <RETURNS>GScanner *</RETURNS>
3421 GScannerConfig *config_templ
3422 </FUNCTION>
3423 <FUNCTION>
3424 <NAME>g_scanner_destroy</NAME>
3425 <RETURNS>void </RETURNS>
3426 GScanner *scanner
3427 </FUNCTION>
3428 <FUNCTION>
3429 <NAME>g_scanner_input_file</NAME>
3430 <RETURNS>void </RETURNS>
3431 GScanner *scanner,gint input_fd
3432 </FUNCTION>
3433 <FUNCTION>
3434 <NAME>g_scanner_sync_file_offset</NAME>
3435 <RETURNS>void </RETURNS>
3436 GScanner *scanner
3437 </FUNCTION>
3438 <FUNCTION>
3439 <NAME>g_scanner_input_text</NAME>
3440 <RETURNS>void </RETURNS>
3441 GScanner *scanner,const gchar *text,guint text_len
3442 </FUNCTION>
3443 <FUNCTION>
3444 <NAME>g_scanner_get_next_token</NAME>
3445 <RETURNS>GTokenType </RETURNS>
3446 GScanner *scanner
3447 </FUNCTION>
3448 <FUNCTION>
3449 <NAME>g_scanner_peek_next_token</NAME>
3450 <RETURNS>GTokenType </RETURNS>
3451 GScanner *scanner
3452 </FUNCTION>
3453 <FUNCTION>
3454 <NAME>g_scanner_cur_token</NAME>
3455 <RETURNS>GTokenType </RETURNS>
3456 GScanner *scanner
3457 </FUNCTION>
3458 <FUNCTION>
3459 <NAME>g_scanner_cur_value</NAME>
3460 <RETURNS>GTokenValue </RETURNS>
3461 GScanner *scanner
3462 </FUNCTION>
3463 <FUNCTION>
3464 <NAME>g_scanner_cur_line</NAME>
3465 <RETURNS>guint </RETURNS>
3466 GScanner *scanner
3467 </FUNCTION>
3468 <FUNCTION>
3469 <NAME>g_scanner_cur_position</NAME>
3470 <RETURNS>guint </RETURNS>
3471 GScanner *scanner
3472 </FUNCTION>
3473 <FUNCTION>
3474 <NAME>g_scanner_eof</NAME>
3475 <RETURNS>gboolean </RETURNS>
3476 GScanner *scanner
3477 </FUNCTION>
3478 <FUNCTION>
3479 <NAME>g_scanner_set_scope</NAME>
3480 <RETURNS>guint </RETURNS>
3481 GScanner *scanner,guint scope_id
3482 </FUNCTION>
3483 <FUNCTION>
3484 <NAME>g_scanner_scope_add_symbol</NAME>
3485 <RETURNS>void </RETURNS>
3486 GScanner *scanner,guint scope_id,const gchar *symbol,gpointer value
3487 </FUNCTION>
3488 <FUNCTION>
3489 <NAME>g_scanner_scope_remove_symbol</NAME>
3490 <RETURNS>void </RETURNS>
3491 GScanner *scanner,guint scope_id,const gchar *symbol
3492 </FUNCTION>
3493 <FUNCTION>
3494 <NAME>g_scanner_scope_lookup_symbol</NAME>
3495 <RETURNS>gpointer </RETURNS>
3496 GScanner *scanner,guint scope_id,const gchar *symbol
3497 </FUNCTION>
3498 <FUNCTION>
3499 <NAME>g_scanner_scope_foreach_symbol</NAME>
3500 <RETURNS>void </RETURNS>
3501 GScanner *scanner,guint scope_id,GHFunc func,gpointer user_data
3502 </FUNCTION>
3503 <FUNCTION>
3504 <NAME>g_scanner_lookup_symbol</NAME>
3505 <RETURNS>gpointer </RETURNS>
3506 GScanner *scanner,const gchar *symbol
3507 </FUNCTION>
3508 <FUNCTION>
3509 <NAME>g_scanner_unexp_token</NAME>
3510 <RETURNS>void </RETURNS>
3511 GScanner *scanner,GTokenType expected_token,const gchar *identifier_spec,const gchar *symbol_spec,const gchar *symbol_name,const gchar *message,gint is_error
3512 </FUNCTION>
3513 <FUNCTION>
3514 <NAME>g_scanner_error</NAME>
3515 <RETURNS>void </RETURNS>
3516 GScanner *scanner,const gchar *format,...
3517 </FUNCTION>
3518 <FUNCTION>
3519 <NAME>g_scanner_warn</NAME>
3520 <RETURNS>void </RETURNS>
3521 GScanner *scanner,const gchar *format,...
3522 </FUNCTION>
3523 <FUNCTION>
3524 <NAME>g_scanner_stat_mode</NAME>
3525 <RETURNS>gint </RETURNS>
3526 const gchar *filename
3527 </FUNCTION>
3528 <MACRO>
3529 <NAME>g_scanner_add_symbol</NAME>
3530 #define g_scanner_add_symbol( scanner, symbol, value ) G_STMT_START { \
3531 g_scanner_scope_add_symbol ((scanner), 0, (symbol), (value)); \
3532 } G_STMT_END
3533 </MACRO>
3534 <MACRO>
3535 <NAME>g_scanner_remove_symbol</NAME>
3536 #define g_scanner_remove_symbol( scanner, symbol ) G_STMT_START { \
3537 g_scanner_scope_remove_symbol ((scanner), 0, (symbol)); \
3538 } G_STMT_END
3539 </MACRO>
3540 <MACRO>
3541 <NAME>g_scanner_foreach_symbol</NAME>
3542 #define g_scanner_foreach_symbol( scanner, func, data ) G_STMT_START { \
3543 g_scanner_scope_foreach_symbol ((scanner), 0, (func), (data)); \
3544 } G_STMT_END
3545 </MACRO>
3546 <FUNCTION>
3547 <NAME>g_scanner_freeze_symbol_table</NAME>
3548 <RETURNS>void </RETURNS>
3549 GScanner *scanner
3550 </FUNCTION>
3551 <FUNCTION>
3552 <NAME>g_scanner_thaw_symbol_table</NAME>
3553 <RETURNS>void </RETURNS>
3554 GScanner *scanner
3555 </FUNCTION>
3556 <STRUCT>
3557 <NAME>GCompletion</NAME>
3558 struct GCompletion
3559 {
3560 GList* items;
3561 GCompletionFunc func;
3563 gchar* prefix;
3564 GList* cache;
3565 };
3566 </STRUCT>
3567 <FUNCTION>
3568 <NAME>g_completion_new</NAME>
3569 <RETURNS>GCompletion *</RETURNS>
3570 GCompletionFunc func
3571 </FUNCTION>
3572 <FUNCTION>
3573 <NAME>g_completion_add_items</NAME>
3574 <RETURNS>void </RETURNS>
3575 GCompletion* cmp,GList* items
3576 </FUNCTION>
3577 <FUNCTION>
3578 <NAME>g_completion_remove_items</NAME>
3579 <RETURNS>void </RETURNS>
3580 GCompletion* cmp,GList* items
3581 </FUNCTION>
3582 <FUNCTION>
3583 <NAME>g_completion_clear_items</NAME>
3584 <RETURNS>void </RETURNS>
3585 GCompletion* cmp
3586 </FUNCTION>
3587 <FUNCTION>
3588 <NAME>g_completion_complete</NAME>
3589 <RETURNS>GList *</RETURNS>
3590 GCompletion* cmp,gchar* prefix,gchar** new_prefix
3591 </FUNCTION>
3592 <FUNCTION>
3593 <NAME>g_completion_free</NAME>
3594 <RETURNS>void </RETURNS>
3595 GCompletion* cmp
3596 </FUNCTION>
3597 <TYPEDEF>
3598 <NAME>GDateYear</NAME>
3599 typedef guint16 GDateYear;
3600 </TYPEDEF>
3601 <TYPEDEF>
3602 <NAME>GDateDay</NAME>
3603 typedef guint8 GDateDay; /* day of the month */
3604 </TYPEDEF>
3605 <STRUCT>
3606 <NAME>GDate</NAME>
3607 </STRUCT>
3608 <ENUM>
3609 <NAME>GDateDMY</NAME>
3610 typedef enum
3611 {
3612 G_DATE_DAY = 0,
3613 G_DATE_MONTH = 1,
3614 G_DATE_YEAR = 2
3615 } GDateDMY;
3616 </ENUM>
3617 <ENUM>
3618 <NAME>GDateWeekday</NAME>
3619 typedef enum
3620 {
3621 G_DATE_BAD_WEEKDAY = 0,
3622 G_DATE_MONDAY = 1,
3623 G_DATE_TUESDAY = 2,
3624 G_DATE_WEDNESDAY = 3,
3625 G_DATE_THURSDAY = 4,
3626 G_DATE_FRIDAY = 5,
3627 G_DATE_SATURDAY = 6,
3628 G_DATE_SUNDAY = 7
3629 } GDateWeekday;
3630 </ENUM>
3631 <ENUM>
3632 <NAME>GDateMonth</NAME>
3633 typedef enum
3634 {
3635 G_DATE_BAD_MONTH = 0,
3636 G_DATE_JANUARY = 1,
3637 G_DATE_FEBRUARY = 2,
3638 G_DATE_MARCH = 3,
3639 G_DATE_APRIL = 4,
3640 G_DATE_MAY = 5,
3641 G_DATE_JUNE = 6,
3642 G_DATE_JULY = 7,
3643 G_DATE_AUGUST = 8,
3644 G_DATE_SEPTEMBER = 9,
3645 G_DATE_OCTOBER = 10,
3646 G_DATE_NOVEMBER = 11,
3647 G_DATE_DECEMBER = 12
3648 } GDateMonth;
3649 </ENUM>
3650 <MACRO>
3651 <NAME>G_DATE_BAD_JULIAN</NAME>
3652 #define G_DATE_BAD_JULIAN 0U
3653 </MACRO>
3654 <MACRO>
3655 <NAME>G_DATE_BAD_DAY</NAME>
3656 #define G_DATE_BAD_DAY 0U
3657 </MACRO>
3658 <MACRO>
3659 <NAME>G_DATE_BAD_YEAR</NAME>
3660 #define G_DATE_BAD_YEAR 0U
3661 </MACRO>
3662 <STRUCT>
3663 <NAME>GDate</NAME>
3664 struct GDate
3665 {
3666 guint julian_days : 32; /* julian days representation - we use a
3667 * bitfield hoping that 64 bit platforms
3668 * will pack this whole struct in one big
3669 * int
3670 */
3672 guint julian : 1; /* julian is valid */
3673 guint dmy : 1; /* dmy is valid */
3675 /* DMY representation */
3676 guint day : 6;
3677 guint month : 4;
3678 guint year : 16;
3679 };
3680 </STRUCT>
3681 <FUNCTION>
3682 <NAME>g_date_new</NAME>
3683 <RETURNS>GDate *</RETURNS>
3684 void
3685 </FUNCTION>
3686 <FUNCTION>
3687 <NAME>g_date_new_dmy</NAME>
3688 <RETURNS>GDate *</RETURNS>
3689 GDateDay day,GDateMonth month,GDateYear year
3690 </FUNCTION>
3691 <FUNCTION>
3692 <NAME>g_date_new_julian</NAME>
3693 <RETURNS>GDate *</RETURNS>
3694 guint32 julian_day
3695 </FUNCTION>
3696 <FUNCTION>
3697 <NAME>g_date_free</NAME>
3698 <RETURNS>void </RETURNS>
3699 GDate *date
3700 </FUNCTION>
3701 <FUNCTION>
3702 <NAME>g_date_valid</NAME>
3703 <RETURNS>gboolean </RETURNS>
3704 GDate *date
3705 </FUNCTION>
3706 <FUNCTION>
3707 <NAME>g_date_valid_day</NAME>
3708 <RETURNS>gboolean </RETURNS>
3709 GDateDay day
3710 </FUNCTION>
3711 <FUNCTION>
3712 <NAME>g_date_valid_month</NAME>
3713 <RETURNS>gboolean </RETURNS>
3714 GDateMonth month
3715 </FUNCTION>
3716 <FUNCTION>
3717 <NAME>g_date_valid_year</NAME>
3718 <RETURNS>gboolean </RETURNS>
3719 GDateYear year
3720 </FUNCTION>
3721 <FUNCTION>
3722 <NAME>g_date_valid_weekday</NAME>
3723 <RETURNS>gboolean </RETURNS>
3724 GDateWeekday weekday
3725 </FUNCTION>
3726 <FUNCTION>
3727 <NAME>g_date_valid_julian</NAME>
3728 <RETURNS>gboolean </RETURNS>
3729 guint32 julian_date
3730 </FUNCTION>
3731 <FUNCTION>
3732 <NAME>g_date_valid_dmy</NAME>
3733 <RETURNS>gboolean </RETURNS>
3734 GDateDay day,GDateMonth month,GDateYear year
3735 </FUNCTION>
3736 <FUNCTION>
3737 <NAME>g_date_weekday</NAME>
3738 <RETURNS>GDateWeekday </RETURNS>
3739 GDate *date
3740 </FUNCTION>
3741 <FUNCTION>
3742 <NAME>g_date_month</NAME>
3743 <RETURNS>GDateMonth </RETURNS>
3744 GDate *date
3745 </FUNCTION>
3746 <FUNCTION>
3747 <NAME>g_date_year</NAME>
3748 <RETURNS>GDateYear </RETURNS>
3749 GDate *date
3750 </FUNCTION>
3751 <FUNCTION>
3752 <NAME>g_date_day</NAME>
3753 <RETURNS>GDateDay </RETURNS>
3754 GDate *date
3755 </FUNCTION>
3756 <FUNCTION>
3757 <NAME>g_date_julian</NAME>
3758 <RETURNS>guint32 </RETURNS>
3759 GDate *date
3760 </FUNCTION>
3761 <FUNCTION>
3762 <NAME>g_date_day_of_year</NAME>
3763 <RETURNS>guint </RETURNS>
3764 GDate *date
3765 </FUNCTION>
3766 <FUNCTION>
3767 <NAME>g_date_monday_week_of_year</NAME>
3768 <RETURNS>guint </RETURNS>
3769 GDate *date
3770 </FUNCTION>
3771 <FUNCTION>
3772 <NAME>g_date_sunday_week_of_year</NAME>
3773 <RETURNS>guint </RETURNS>
3774 GDate *date
3775 </FUNCTION>
3776 <FUNCTION>
3777 <NAME>g_date_clear</NAME>
3778 <RETURNS>void </RETURNS>
3779 GDate *date,guint n_dates
3780 </FUNCTION>
3781 <FUNCTION>
3782 <NAME>g_date_set_parse</NAME>
3783 <RETURNS>void </RETURNS>
3784 GDate *date,const gchar *str
3785 </FUNCTION>
3786 <FUNCTION>
3787 <NAME>g_date_set_time</NAME>
3788 <RETURNS>void </RETURNS>
3789 GDate *date,GTime time
3790 </FUNCTION>
3791 <FUNCTION>
3792 <NAME>g_date_set_month</NAME>
3793 <RETURNS>void </RETURNS>
3794 GDate *date,GDateMonth month
3795 </FUNCTION>
3796 <FUNCTION>
3797 <NAME>g_date_set_day</NAME>
3798 <RETURNS>void </RETURNS>
3799 GDate *date,GDateDay day
3800 </FUNCTION>
3801 <FUNCTION>
3802 <NAME>g_date_set_year</NAME>
3803 <RETURNS>void </RETURNS>
3804 GDate *date,GDateYear year
3805 </FUNCTION>
3806 <FUNCTION>
3807 <NAME>g_date_set_dmy</NAME>
3808 <RETURNS>void </RETURNS>
3809 GDate *date,GDateDay day,GDateMonth month,GDateYear y
3810 </FUNCTION>
3811 <FUNCTION>
3812 <NAME>g_date_set_julian</NAME>
3813 <RETURNS>void </RETURNS>
3814 GDate *date,guint32 julian_date
3815 </FUNCTION>
3816 <FUNCTION>
3817 <NAME>g_date_is_first_of_month</NAME>
3818 <RETURNS>gboolean </RETURNS>
3819 GDate *date
3820 </FUNCTION>
3821 <FUNCTION>
3822 <NAME>g_date_is_last_of_month</NAME>
3823 <RETURNS>gboolean </RETURNS>
3824 GDate *date
3825 </FUNCTION>
3826 <FUNCTION>
3827 <NAME>g_date_add_days</NAME>
3828 <RETURNS>void </RETURNS>
3829 GDate *date,guint n_days
3830 </FUNCTION>
3831 <FUNCTION>
3832 <NAME>g_date_subtract_days</NAME>
3833 <RETURNS>void </RETURNS>
3834 GDate *date,guint n_days
3835 </FUNCTION>
3836 <FUNCTION>
3837 <NAME>g_date_add_months</NAME>
3838 <RETURNS>void </RETURNS>
3839 GDate *date,guint n_months
3840 </FUNCTION>
3841 <FUNCTION>
3842 <NAME>g_date_subtract_months</NAME>
3843 <RETURNS>void </RETURNS>
3844 GDate *date,guint n_months
3845 </FUNCTION>
3846 <FUNCTION>
3847 <NAME>g_date_add_years</NAME>
3848 <RETURNS>void </RETURNS>
3849 GDate *date,guint n_years
3850 </FUNCTION>
3851 <FUNCTION>
3852 <NAME>g_date_subtract_years</NAME>
3853 <RETURNS>void </RETURNS>
3854 GDate *date,guint n_years
3855 </FUNCTION>
3856 <FUNCTION>
3857 <NAME>g_date_is_leap_year</NAME>
3858 <RETURNS>gboolean </RETURNS>
3859 GDateYear year
3860 </FUNCTION>
3861 <FUNCTION>
3862 <NAME>g_date_days_in_month</NAME>
3863 <RETURNS>guint8 </RETURNS>
3864 GDateMonth month,GDateYear year
3865 </FUNCTION>
3866 <FUNCTION>
3867 <NAME>g_date_monday_weeks_in_year</NAME>
3868 <RETURNS>guint8 </RETURNS>
3869 GDateYear year
3870 </FUNCTION>
3871 <FUNCTION>
3872 <NAME>g_date_sunday_weeks_in_year</NAME>
3873 <RETURNS>guint8 </RETURNS>
3874 GDateYear year
3875 </FUNCTION>
3876 <FUNCTION>
3877 <NAME>g_date_compare</NAME>
3878 <RETURNS>gint </RETURNS>
3879 GDate *lhs,GDate *rhs
3880 </FUNCTION>
3881 <FUNCTION>
3882 <NAME>g_date_to_struct_tm</NAME>
3883 <RETURNS>void </RETURNS>
3884 GDate *date,struct tm *tm
3885 </FUNCTION>
3886 <FUNCTION>
3887 <NAME>g_date_strftime</NAME>
3888 <RETURNS>gsize </RETURNS>
3889 gchar *s,gsize slen,const gchar *format,GDate *date
3890 </FUNCTION>
3891 <FUNCTION>
3892 <NAME>g_relation_new</NAME>
3893 <RETURNS>GRelation *</RETURNS>
3894 gint fields
3895 </FUNCTION>
3896 <FUNCTION>
3897 <NAME>g_relation_destroy</NAME>
3898 <RETURNS>void </RETURNS>
3899 GRelation *relation
3900 </FUNCTION>
3901 <FUNCTION>
3902 <NAME>g_relation_index</NAME>
3903 <RETURNS>void </RETURNS>
3904 GRelation *relation,gint field,GHashFunc hash_func,GCompareFunc key_compare_func
3905 </FUNCTION>
3906 <FUNCTION>
3907 <NAME>g_relation_insert</NAME>
3908 <RETURNS>void </RETURNS>
3909 GRelation *relation,...
3910 </FUNCTION>
3911 <FUNCTION>
3912 <NAME>g_relation_delete</NAME>
3913 <RETURNS>gint </RETURNS>
3914 GRelation *relation,gconstpointer key,gint field
3915 </FUNCTION>
3916 <FUNCTION>
3917 <NAME>g_relation_select</NAME>
3918 <RETURNS>GTuples *</RETURNS>
3919 GRelation *relation,gconstpointer key,gint field
3920 </FUNCTION>
3921 <FUNCTION>
3922 <NAME>g_relation_count</NAME>
3923 <RETURNS>gint </RETURNS>
3924 GRelation *relation,gconstpointer key,gint field
3925 </FUNCTION>
3926 <FUNCTION>
3927 <NAME>g_relation_exists</NAME>
3928 <RETURNS>gboolean </RETURNS>
3929 GRelation *relation,...
3930 </FUNCTION>
3931 <FUNCTION>
3932 <NAME>g_relation_print</NAME>
3933 <RETURNS>void </RETURNS>
3934 GRelation *relation
3935 </FUNCTION>
3936 <FUNCTION>
3937 <NAME>g_tuples_destroy</NAME>
3938 <RETURNS>void </RETURNS>
3939 GTuples *tuples
3940 </FUNCTION>
3941 <FUNCTION>
3942 <NAME>g_tuples_index</NAME>
3943 <RETURNS>gpointer </RETURNS>
3944 GTuples *tuples,gint index,gint field
3945 </FUNCTION>
3946 <FUNCTION>
3947 <NAME>g_rand_new_with_seed</NAME>
3948 <RETURNS>GRand *</RETURNS>
3949 guint32 seed
3950 </FUNCTION>
3951 <FUNCTION>
3952 <NAME>g_rand_new</NAME>
3953 <RETURNS>GRand *</RETURNS>
3954 void
3955 </FUNCTION>
3956 <FUNCTION>
3957 <NAME>g_rand_free</NAME>
3958 <RETURNS>void </RETURNS>
3959 GRand *rand
3960 </FUNCTION>
3961 <FUNCTION>
3962 <NAME>g_rand_set_seed</NAME>
3963 <RETURNS>void </RETURNS>
3964 GRand *rand,guint32 seed
3965 </FUNCTION>
3966 <FUNCTION>
3967 <NAME>g_rand_int</NAME>
3968 <RETURNS>guint32 </RETURNS>
3969 GRand *rand
3970 </FUNCTION>
3971 <FUNCTION>
3972 <NAME>g_rand_int_range</NAME>
3973 <RETURNS>gint32 </RETURNS>
3974 GRand *rand,gint32 min,gint32 max
3975 </FUNCTION>
3976 <FUNCTION>
3977 <NAME>g_rand_double</NAME>
3978 <RETURNS>gdouble </RETURNS>
3979 GRand *rand
3980 </FUNCTION>
3981 <FUNCTION>
3982 <NAME>g_rand_double_range</NAME>
3983 <RETURNS>gdouble </RETURNS>
3984 GRand *rand,gdouble min,gdouble max
3985 </FUNCTION>
3986 <FUNCTION>
3987 <NAME>g_random_set_seed</NAME>
3988 <RETURNS>void </RETURNS>
3989 guint32 seed
3990 </FUNCTION>
3991 <FUNCTION>
3992 <NAME>g_random_int</NAME>
3993 <RETURNS>guint32 </RETURNS>
3994 void
3995 </FUNCTION>
3996 <FUNCTION>
3997 <NAME>g_random_int_range</NAME>
3998 <RETURNS>gint32 </RETURNS>
3999 gint32 min,gint32 max
4000 </FUNCTION>
4001 <FUNCTION>
4002 <NAME>g_random_double</NAME>
4003 <RETURNS>gdouble </RETURNS>
4004 void
4005 </FUNCTION>
4006 <FUNCTION>
4007 <NAME>g_random_double_range</NAME>
4008 <RETURNS>gdouble </RETURNS>
4009 gdouble min,gdouble max
4010 </FUNCTION>
4011 <FUNCTION>
4012 <NAME>g_spaced_primes_closest</NAME>
4013 <RETURNS>guint </RETURNS>
4014 guint num
4015 </FUNCTION>
4016 <STRUCT>
4017 <NAME>GIOFuncs</NAME>
4018 </STRUCT>
4019 <ENUM>
4020 <NAME>GIOError</NAME>
4021 typedef enum
4022 {
4023 G_IO_ERROR_NONE,
4024 G_IO_ERROR_AGAIN,
4025 G_IO_ERROR_INVAL,
4026 G_IO_ERROR_UNKNOWN
4027 } GIOError;
4028 </ENUM>
4029 <ENUM>
4030 <NAME>GSeekType</NAME>
4031 typedef enum
4032 {
4033 G_SEEK_CUR,
4034 G_SEEK_SET,
4035 G_SEEK_END
4036 } GSeekType;
4037 </ENUM>
4038 <ENUM>
4039 <NAME>GIOCondition</NAME>
4040 typedef enum
4041 {
4042 G_IO_IN GLIB_SYSDEF_POLLIN,
4043 G_IO_OUT GLIB_SYSDEF_POLLOUT,
4044 G_IO_PRI GLIB_SYSDEF_POLLPRI,
4045 G_IO_ERR GLIB_SYSDEF_POLLERR,
4046 G_IO_HUP GLIB_SYSDEF_POLLHUP,
4047 G_IO_NVAL GLIB_SYSDEF_POLLNVAL
4048 } GIOCondition;
4049 </ENUM>
4050 <STRUCT>
4051 <NAME>GIOChannel</NAME>
4052 struct GIOChannel
4053 {
4054 guint channel_flags;
4055 guint ref_count;
4056 GIOFuncs *funcs;
4057 };
4058 </STRUCT>
4059 <USER_FUNCTION>
4060 <NAME>GIOFunc</NAME>
4061 <RETURNS>gboolean </RETURNS>
4062 GIOChannel *source,
4063 GIOCondition condition,
4064 gpointer data
4065 </USER_FUNCTION>
4066 <STRUCT>
4067 <NAME>GIOFuncs</NAME>
4068 struct GIOFuncs
4069 {
4070 GIOError (*io_read) (GIOChannel *channel,
4071 gchar *buf,
4072 guint count,
4073 guint *bytes_read);
4074 GIOError (*io_write) (GIOChannel *channel,
4075 gchar *buf,
4076 guint count,
4077 guint *bytes_written);
4078 GIOError (*io_seek) (GIOChannel *channel,
4079 gint offset,
4080 GSeekType type);
4081 void (*io_close) (GIOChannel *channel);
4082 guint (*io_add_watch) (GIOChannel *channel,
4083 gint priority,
4084 GIOCondition condition,
4085 GIOFunc func,
4086 gpointer user_data,
4087 GDestroyNotify notify);
4088 void (*io_free) (GIOChannel *channel);
4089 };
4090 </STRUCT>
4091 <FUNCTION>
4092 <NAME>g_io_channel_init</NAME>
4093 <RETURNS>void </RETURNS>
4094 GIOChannel *channel
4095 </FUNCTION>
4096 <FUNCTION>
4097 <NAME>g_io_channel_ref</NAME>
4098 <RETURNS>void </RETURNS>
4099 GIOChannel *channel
4100 </FUNCTION>
4101 <FUNCTION>
4102 <NAME>g_io_channel_unref</NAME>
4103 <RETURNS>void </RETURNS>
4104 GIOChannel *channel
4105 </FUNCTION>
4106 <FUNCTION>
4107 <NAME>g_io_channel_read</NAME>
4108 <RETURNS>GIOError </RETURNS>
4109 GIOChannel *channel,gchar *buf,guint count,guint *bytes_read
4110 </FUNCTION>
4111 <FUNCTION>
4112 <NAME>g_io_channel_write</NAME>
4113 <RETURNS>GIOError </RETURNS>
4114 GIOChannel *channel,gchar *buf,guint count,guint *bytes_written
4115 </FUNCTION>
4116 <FUNCTION>
4117 <NAME>g_io_channel_seek</NAME>
4118 <RETURNS>GIOError </RETURNS>
4119 GIOChannel *channel,gint offset,GSeekType type
4120 </FUNCTION>
4121 <FUNCTION>
4122 <NAME>g_io_channel_close</NAME>
4123 <RETURNS>void </RETURNS>
4124 GIOChannel *channel
4125 </FUNCTION>
4126 <FUNCTION>
4127 <NAME>g_io_add_watch_full</NAME>
4128 <RETURNS>guint </RETURNS>
4129 GIOChannel *channel,gint priority,GIOCondition condition,GIOFunc func,gpointer user_data,GDestroyNotify notify
4130 </FUNCTION>
4131 <FUNCTION>
4132 <NAME>g_io_add_watch</NAME>
4133 <RETURNS>guint </RETURNS>
4134 GIOChannel *channel,GIOCondition condition,GIOFunc func,gpointer user_data
4135 </FUNCTION>
4136 <STRUCT>
4137 <NAME>GTimeVal</NAME>
4138 </STRUCT>
4139 <STRUCT>
4140 <NAME>GSourceFuncs</NAME>
4141 </STRUCT>
4142 <STRUCT>
4143 <NAME>GMainLoop</NAME>
4144 </STRUCT>
4145 <STRUCT>
4146 <NAME>GTimeVal</NAME>
4147 struct GTimeVal
4148 {
4149 glong tv_sec;
4150 glong tv_usec;
4151 };
4152 </STRUCT>
4153 <STRUCT>
4154 <NAME>GSourceFuncs</NAME>
4155 struct GSourceFuncs
4156 {
4157 gboolean (*prepare) (gpointer source_data,
4158 GTimeVal *current_time,
4159 gint *timeout,
4160 gpointer user_data);
4161 gboolean (*check) (gpointer source_data,
4162 GTimeVal *current_time,
4163 gpointer user_data);
4164 gboolean (*dispatch) (gpointer source_data,
4165 GTimeVal *dispatch_time,
4166 gpointer user_data);
4167 GDestroyNotify destroy;
4168 };
4169 </STRUCT>
4170 <MACRO>
4171 <NAME>G_PRIORITY_HIGH</NAME>
4172 #define G_PRIORITY_HIGH -100
4173 </MACRO>
4174 <MACRO>
4175 <NAME>G_PRIORITY_DEFAULT</NAME>
4176 #define G_PRIORITY_DEFAULT 0
4177 </MACRO>
4178 <MACRO>
4179 <NAME>G_PRIORITY_HIGH_IDLE</NAME>
4180 #define G_PRIORITY_HIGH_IDLE 100
4181 </MACRO>
4182 <MACRO>
4183 <NAME>G_PRIORITY_DEFAULT_IDLE</NAME>
4184 #define G_PRIORITY_DEFAULT_IDLE 200
4185 </MACRO>
4186 <MACRO>
4187 <NAME>G_PRIORITY_LOW</NAME>
4188 #define G_PRIORITY_LOW 300
4189 </MACRO>
4190 <USER_FUNCTION>
4191 <NAME>GSourceFunc</NAME>
4192 <RETURNS>gboolean </RETURNS>
4193 gpointer data
4194 </USER_FUNCTION>
4195 <FUNCTION>
4196 <NAME>g_source_add</NAME>
4197 <RETURNS>guint </RETURNS>
4198 gint priority,gboolean can_recurse,GSourceFuncs *funcs,gpointer source_data,gpointer user_data,GDestroyNotify notify
4199 </FUNCTION>
4200 <FUNCTION>
4201 <NAME>g_source_remove</NAME>
4202 <RETURNS>gboolean </RETURNS>
4203 guint tag
4204 </FUNCTION>
4205 <FUNCTION>
4206 <NAME>g_source_remove_by_user_data</NAME>
4207 <RETURNS>gboolean </RETURNS>
4208 gpointer user_data
4209 </FUNCTION>
4210 <FUNCTION>
4211 <NAME>g_source_remove_by_source_data</NAME>
4212 <RETURNS>gboolean </RETURNS>
4213 gpointer source_data
4214 </FUNCTION>
4215 <FUNCTION>
4216 <NAME>g_source_remove_by_funcs_user_data</NAME>
4217 <RETURNS>gboolean </RETURNS>
4218 GSourceFuncs *funcs,gpointer user_data
4219 </FUNCTION>
4220 <FUNCTION>
4221 <NAME>g_get_current_time</NAME>
4222 <RETURNS>void </RETURNS>
4223 GTimeVal *result
4224 </FUNCTION>
4225 <FUNCTION>
4226 <NAME>g_main_new</NAME>
4227 <RETURNS>GMainLoop *</RETURNS>
4228 gboolean is_running
4229 </FUNCTION>
4230 <FUNCTION>
4231 <NAME>g_main_run</NAME>
4232 <RETURNS>void </RETURNS>
4233 GMainLoop *loop
4234 </FUNCTION>
4235 <FUNCTION>
4236 <NAME>g_main_quit</NAME>
4237 <RETURNS>void </RETURNS>
4238 GMainLoop *loop
4239 </FUNCTION>
4240 <FUNCTION>
4241 <NAME>g_main_destroy</NAME>
4242 <RETURNS>void </RETURNS>
4243 GMainLoop *loop
4244 </FUNCTION>
4245 <FUNCTION>
4246 <NAME>g_main_is_running</NAME>
4247 <RETURNS>gboolean </RETURNS>
4248 GMainLoop *loop
4249 </FUNCTION>
4250 <FUNCTION>
4251 <NAME>g_main_iteration</NAME>
4252 <RETURNS>gboolean </RETURNS>
4253 gboolean may_block
4254 </FUNCTION>
4255 <FUNCTION>
4256 <NAME>g_main_pending</NAME>
4257 <RETURNS>gboolean </RETURNS>
4258 void
4259 </FUNCTION>
4260 <FUNCTION>
4261 <NAME>g_timeout_add_full</NAME>
4262 <RETURNS>guint </RETURNS>
4263 gint priority,guint interval,GSourceFunc function,gpointer data,GDestroyNotify notify
4264 </FUNCTION>
4265 <FUNCTION>
4266 <NAME>g_timeout_add</NAME>
4267 <RETURNS>guint </RETURNS>
4268 guint interval,GSourceFunc function,gpointer data
4269 </FUNCTION>
4270 <FUNCTION>
4271 <NAME>g_idle_add</NAME>
4272 <RETURNS>guint </RETURNS>
4273 GSourceFunc function,gpointer data
4274 </FUNCTION>
4275 <FUNCTION>
4276 <NAME>g_idle_add_full</NAME>
4277 <RETURNS>guint </RETURNS>
4278 gint priority,GSourceFunc function,gpointer data,GDestroyNotify destroy
4279 </FUNCTION>
4280 <FUNCTION>
4281 <NAME>g_idle_remove_by_data</NAME>
4282 <RETURNS>gboolean </RETURNS>
4283 gpointer data
4284 </FUNCTION>
4285 <STRUCT>
4286 <NAME>GPollFD</NAME>
4287 </STRUCT>
4288 <USER_FUNCTION>
4289 <NAME>GPollFunc</NAME>
4290 <RETURNS>gint </RETURNS>
4291 GPollFD *ufds,
4292 guint nfsd,
4293 gint timeout
4294 </USER_FUNCTION>
4295 <STRUCT>
4296 <NAME>GPollFD</NAME>
4297 struct GPollFD
4298 {
4299 gint fd;
4300 gushort events;
4301 gushort revents;
4302 };
4303 </STRUCT>
4304 <FUNCTION>
4305 <NAME>g_main_add_poll</NAME>
4306 <RETURNS>void </RETURNS>
4307 GPollFD *fd,gint priority
4308 </FUNCTION>
4309 <FUNCTION>
4310 <NAME>g_main_remove_poll</NAME>
4311 <RETURNS>void </RETURNS>
4312 GPollFD *fd
4313 </FUNCTION>
4314 <FUNCTION>
4315 <NAME>g_main_set_poll_func</NAME>
4316 <RETURNS>void </RETURNS>
4317 GPollFunc func
4318 </FUNCTION>
4319 <FUNCTION>
4320 <NAME>g_main_win32_get_poll_func</NAME>
4321 <RETURNS>GPollFunc </RETURNS>
4322 void
4323 </FUNCTION>
4324 <FUNCTION>
4325 <NAME>g_io_channel_unix_new</NAME>
4326 <RETURNS>GIOChannel *</RETURNS>
4327 int fd
4328 </FUNCTION>
4329 <FUNCTION>
4330 <NAME>g_io_channel_unix_get_fd</NAME>
4331 <RETURNS>gint </RETURNS>
4332 GIOChannel *channel
4333 </FUNCTION>
4334 <MACRO>
4335 <NAME>G_WIN32_MSG_HANDLE</NAME>
4336 #define G_WIN32_MSG_HANDLE 19981206
4337 </MACRO>
4338 <FUNCTION>
4339 <NAME>g_io_channel_win32_make_pollfd</NAME>
4340 <RETURNS>void </RETURNS>
4341 GIOChannel *channel,GIOCondition condition,GPollFD *fd
4342 </FUNCTION>
4343 <FUNCTION>
4344 <NAME>g_io_channel_win32_poll</NAME>
4345 <RETURNS>gint </RETURNS>
4346 GPollFD *fds,gint n_fds,gint timeout
4347 </FUNCTION>
4348 <FUNCTION>
4349 <NAME>g_main_poll_win32_msg_add</NAME>
4350 <RETURNS>void </RETURNS>
4351 gint priority,GPollFD *fd,guint hwnd
4352 </FUNCTION>
4353 <FUNCTION>
4354 <NAME>g_io_channel_win32_new_messages</NAME>
4355 <RETURNS>GIOChannel *</RETURNS>
4356 guint hwnd
4357 </FUNCTION>
4358 <FUNCTION>
4359 <NAME>g_io_channel_win32_new_fd</NAME>
4360 <RETURNS>GIOChannel *</RETURNS>
4361 int fd
4362 </FUNCTION>
4363 <FUNCTION>
4364 <NAME>g_io_channel_win32_get_fd</NAME>
4365 <RETURNS>gint </RETURNS>
4366 GIOChannel *channel
4367 </FUNCTION>
4368 <FUNCTION>
4369 <NAME>g_io_channel_win32_new_stream_socket</NAME>
4370 <RETURNS>GIOChannel *</RETURNS>
4371 int socket
4372 </FUNCTION>
4373 <MACRO>
4374 <NAME>MAXPATHLEN</NAME>
4375 # define MAXPATHLEN 1024
4376 </MACRO>
4377 <TYPEDEF>
4378 <NAME>pid_t</NAME>
4379 typedef int pid_t;
4380 </TYPEDEF>
4381 <MACRO>
4382 <NAME>pipe</NAME>
4383 #define pipe(phandles) _pipe (phandles, 4096, _O_BINARY)
4384 </MACRO>
4385 <MACRO>
4386 <NAME>ftruncate</NAME>
4387 # define ftruncate(fd, size) g_win32_ftruncate (fd, size)
4388 </MACRO>
4389 <MACRO>
4390 <NAME>opendir</NAME>
4391 # define opendir g_win32_opendir
4392 </MACRO>
4393 <MACRO>
4394 <NAME>readdir</NAME>
4395 # define readdir g_win32_readdir
4396 </MACRO>
4397 <MACRO>
4398 <NAME>rewinddir</NAME>
4399 # define rewinddir g_win32_rewinddir
4400 </MACRO>
4401 <MACRO>
4402 <NAME>closedir</NAME>
4403 # define closedir g_win32_closedir
4404 </MACRO>
4405 <MACRO>
4406 <NAME>NAME_MAX</NAME>
4407 # define NAME_MAX 255
4408 </MACRO>
4409 <FUNCTION>
4410 <NAME>g_win32_ftruncate</NAME>
4411 <RETURNS>int </RETURNS>
4412 gint f,guint size
4413 </FUNCTION>
4414 <FUNCTION>
4415 <NAME>g_win32_opendir</NAME>
4416 <RETURNS>DIR *</RETURNS>
4417 const gchar *dirname
4418 </FUNCTION>
4419 <FUNCTION>
4420 <NAME>g_win32_rewinddir</NAME>
4421 <RETURNS>void </RETURNS>
4422 DIR *dir
4423 </FUNCTION>
4424 <FUNCTION>
4425 <NAME>g_win32_closedir</NAME>
4426 <RETURNS>gint </RETURNS>
4427 DIR *dir
4428 </FUNCTION>
4429 <FUNCTION>
4430 <NAME>g_win32_getlocale</NAME>
4431 <RETURNS>gchar *</RETURNS>
4432 void
4433 </FUNCTION>
4434 <FUNCTION>
4435 <NAME>g_win32_error_message</NAME>
4436 <RETURNS>gchar *</RETURNS>
4437 gint error
4438 </FUNCTION>
4439 <FUNCTION>
4440 <NAME>g_thread_error_quark</NAME>
4441 <RETURNS>GQuark </RETURNS>
4443 </FUNCTION>
4444 <MACRO>
4445 <NAME>G_THREAD_ERROR</NAME>
4446 #define G_THREAD_ERROR g_thread_error_quark()
4447 </MACRO>
4448 <ENUM>
4449 <NAME>GThreadError</NAME>
4450 typedef enum
4451 {
4452 G_THREAD_ERROR_AGAIN /* Resource temporarily unavailable */
4453 } GThreadError;
4454 </ENUM>
4455 <USER_FUNCTION>
4456 <NAME>GThreadFunc</NAME>
4457 <RETURNS>void </RETURNS>
4458 gpointer value
4459 </USER_FUNCTION>
4460 <ENUM>
4461 <NAME>GThreadPriority</NAME>
4462 typedef enum
4463 {
4464 G_THREAD_PRIORITY_LOW,
4465 G_THREAD_PRIORITY_NORMAL,
4466 G_THREAD_PRIORITY_HIGH,
4467 G_THREAD_PRIORITY_URGENT
4468 } GThreadPriority;
4469 </ENUM>
4470 <STRUCT>
4471 <NAME>GThread</NAME>
4472 </STRUCT>
4473 <STRUCT>
4474 <NAME>GThread</NAME>
4475 struct GThread
4476 {
4477 GThreadPriority priority;
4478 gboolean bound;
4479 gboolean joinable;
4480 };
4481 </STRUCT>
4482 <STRUCT>
4483 <NAME>GMutex</NAME>
4484 </STRUCT>
4485 <STRUCT>
4486 <NAME>GCond</NAME>
4487 </STRUCT>
4488 <STRUCT>
4489 <NAME>GPrivate</NAME>
4490 </STRUCT>
4491 <STRUCT>
4492 <NAME>GStaticPrivate</NAME>
4493 </STRUCT>
4494 <STRUCT>
4495 <NAME>GAsyncQueue</NAME>
4496 </STRUCT>
4497 <STRUCT>
4498 <NAME>GThreadPool</NAME>
4499 </STRUCT>
4500 <STRUCT>
4501 <NAME>GThreadFunctions</NAME>
4502 </STRUCT>
4503 <STRUCT>
4504 <NAME>GThreadFunctions</NAME>
4505 struct GThreadFunctions
4506 {
4507 GMutex* (*mutex_new) (void);
4508 void (*mutex_lock) (GMutex *mutex);
4509 gboolean (*mutex_trylock) (GMutex *mutex);
4510 void (*mutex_unlock) (GMutex *mutex);
4511 void (*mutex_free) (GMutex *mutex);
4512 GCond* (*cond_new) (void);
4513 void (*cond_signal) (GCond *cond);
4514 void (*cond_broadcast) (GCond *cond);
4515 void (*cond_wait) (GCond *cond,
4516 GMutex *mutex);
4517 gboolean (*cond_timed_wait) (GCond *cond,
4518 GMutex *mutex,
4519 GTimeVal *end_time);
4520 void (*cond_free) (GCond *cond);
4521 GPrivate* (*private_new) (GDestroyNotify destructor);
4522 gpointer (*private_get) (GPrivate *private_key);
4523 void (*private_set) (GPrivate *private_key,
4524 gpointer data);
4525 void (*thread_create) (GThreadFunc thread_func,
4526 gpointer arg,
4527 gulong stack_size,
4528 gboolean joinable,
4529 gboolean bound,
4530 GThreadPriority priority,
4531 gpointer thread,
4532 GError **error);
4533 void (*thread_yield) (void);
4534 void (*thread_join) (gpointer thread);
4535 void (*thread_exit) (void);
4536 void (*thread_set_priority)(gpointer thread,
4537 GThreadPriority priority);
4538 void (*thread_self) (gpointer thread);
4539 };
4540 </STRUCT>
4541 <FUNCTION>
4542 <NAME>g_thread_init</NAME>
4543 <RETURNS>void </RETURNS>
4544 GThreadFunctions *vtable
4545 </FUNCTION>
4546 <FUNCTION>
4547 <NAME>g_static_mutex_get_mutex_impl</NAME>
4548 <RETURNS>GMutex *</RETURNS>
4549 GMutex **mutex
4550 </FUNCTION>
4551 <MACRO>
4552 <NAME>G_THREAD_UF</NAME>
4553 #define G_THREAD_UF(name, arglist) \
4554 (*g_thread_functions_for_glib_use . name) arglist
4555 </MACRO>
4556 <MACRO>
4557 <NAME>G_THREAD_CF</NAME>
4558 #define G_THREAD_CF(name, fail, arg) \
4559 (g_thread_supported () ? G_THREAD_UF (name, arg) : (fail))
4560 </MACRO>
4561 <MACRO>
4562 <NAME>g_thread_supported</NAME>
4563 #define g_thread_supported() (g_threads_got_initialized)
4564 </MACRO>
4565 <MACRO>
4566 <NAME>g_mutex_new</NAME>
4567 #define g_mutex_new() G_THREAD_UF (mutex_new, ())
4568 </MACRO>
4569 <MACRO>
4570 <NAME>g_mutex_lock</NAME>
4571 #define g_mutex_lock(mutex) G_THREAD_CF (mutex_lock, (void)0, (mutex))
4572 </MACRO>
4573 <MACRO>
4574 <NAME>g_mutex_trylock</NAME>
4575 #define g_mutex_trylock(mutex) G_THREAD_CF (mutex_trylock, TRUE, (mutex))
4576 </MACRO>
4577 <MACRO>
4578 <NAME>g_mutex_unlock</NAME>
4579 #define g_mutex_unlock(mutex) G_THREAD_CF (mutex_unlock, (void)0, (mutex))
4580 </MACRO>
4581 <MACRO>
4582 <NAME>g_mutex_free</NAME>
4583 #define g_mutex_free(mutex) G_THREAD_CF (mutex_free, (void)0, (mutex))
4584 </MACRO>
4585 <MACRO>
4586 <NAME>g_cond_new</NAME>
4587 #define g_cond_new() G_THREAD_UF (cond_new, ())
4588 </MACRO>
4589 <MACRO>
4590 <NAME>g_cond_signal</NAME>
4591 #define g_cond_signal(cond) G_THREAD_CF (cond_signal, (void)0, (cond))
4592 </MACRO>
4593 <MACRO>
4594 <NAME>g_cond_broadcast</NAME>
4595 #define g_cond_broadcast(cond) G_THREAD_CF (cond_broadcast, (void)0, (cond))
4596 </MACRO>
4597 <MACRO>
4598 <NAME>g_cond_wait</NAME>
4599 #define g_cond_wait(cond, mutex) G_THREAD_CF (cond_wait, (void)0, (cond, \
4600 mutex))
4601 </MACRO>
4602 <MACRO>
4603 <NAME>g_cond_free</NAME>
4604 #define g_cond_free(cond) G_THREAD_CF (cond_free, (void)0, (cond))
4605 </MACRO>
4606 <MACRO>
4607 <NAME>g_cond_timed_wait</NAME>
4608 #define g_cond_timed_wait(cond, mutex, abs_time) G_THREAD_CF (cond_timed_wait, \
4609 TRUE, \
4610 (cond, mutex, \
4611 abs_time))
4612 </MACRO>
4613 <MACRO>
4614 <NAME>g_private_new</NAME>
4615 #define g_private_new(destructor) G_THREAD_UF (private_new, (destructor))
4616 </MACRO>
4617 <MACRO>
4618 <NAME>g_private_get</NAME>
4619 #define g_private_get(private_key) G_THREAD_CF (private_get, \
4620 ((gpointer)private_key), \
4621 (private_key))
4622 </MACRO>
4623 <MACRO>
4624 <NAME>g_private_set</NAME>
4625 #define g_private_set(private_key, value) G_THREAD_CF (private_set, \
4626 (void) (private_key = \
4627 (GPrivate*) (value)), \
4628 (private_key, value))
4629 </MACRO>
4630 <MACRO>
4631 <NAME>g_thread_yield</NAME>
4632 #define g_thread_yield() G_THREAD_CF (thread_yield, (void)0, ())
4633 </MACRO>
4634 <MACRO>
4635 <NAME>g_thread_exit</NAME>
4636 #define g_thread_exit() G_THREAD_CF (thread_exit, (void)0, ())
4637 </MACRO>
4638 <FUNCTION>
4639 <NAME>g_thread_create</NAME>
4640 <RETURNS>GThread *</RETURNS>
4641 GThreadFunc thread_func,gpointer arg,gulong stack_size,gboolean joinable,gboolean bound,GThreadPriority priority,GError **error
4642 </FUNCTION>
4643 <FUNCTION>
4644 <NAME>g_thread_self</NAME>
4645 <RETURNS>GThread *</RETURNS>
4647 </FUNCTION>
4648 <FUNCTION>
4649 <NAME>g_thread_join</NAME>
4650 <RETURNS>void </RETURNS>
4651 GThread *thread
4652 </FUNCTION>
4653 <FUNCTION>
4654 <NAME>g_thread_set_priority</NAME>
4655 <RETURNS>void </RETURNS>
4656 GThread *thread,GThreadPriority priority
4657 </FUNCTION>
4658 <MACRO>
4659 <NAME>g_static_mutex_lock</NAME>
4660 #define g_static_mutex_lock(mutex) \
4661 g_mutex_lock (g_static_mutex_get_mutex (mutex))
4662 </MACRO>
4663 <MACRO>
4664 <NAME>g_static_mutex_trylock</NAME>
4665 #define g_static_mutex_trylock(mutex) \
4666 g_mutex_trylock (g_static_mutex_get_mutex (mutex))
4667 </MACRO>
4668 <MACRO>
4669 <NAME>g_static_mutex_unlock</NAME>
4670 #define g_static_mutex_unlock(mutex) \
4671 g_mutex_unlock (g_static_mutex_get_mutex (mutex))
4672 </MACRO>
4673 <STRUCT>
4674 <NAME>GStaticPrivate</NAME>
4675 struct GStaticPrivate
4676 {
4677 guint index;
4678 };
4679 </STRUCT>
4680 <MACRO>
4681 <NAME>G_STATIC_PRIVATE_INIT</NAME>
4682 #define G_STATIC_PRIVATE_INIT { 0 }
4683 </MACRO>
4684 <FUNCTION>
4685 <NAME>g_static_private_get</NAME>
4686 <RETURNS>gpointer </RETURNS>
4687 GStaticPrivate *private_key
4688 </FUNCTION>
4689 <FUNCTION>
4690 <NAME>g_static_private_set</NAME>
4691 <RETURNS>void </RETURNS>
4692 GStaticPrivate *private_key,gpointer data,GDestroyNotify notify
4693 </FUNCTION>
4694 <FUNCTION>
4695 <NAME>g_static_private_get_for_thread</NAME>
4696 <RETURNS>gpointer </RETURNS>
4697 GStaticPrivate *private_key,GThread *thread
4698 </FUNCTION>
4699 <FUNCTION>
4700 <NAME>g_static_private_set_for_thread</NAME>
4701 <RETURNS>void </RETURNS>
4702 GStaticPrivate *private_key,GThread *thread,gpointer data,GDestroyNotify notify
4703 </FUNCTION>
4704 <STRUCT>
4705 <NAME>GStaticRecMutex</NAME>
4706 </STRUCT>
4707 <STRUCT>
4708 <NAME>GStaticRecMutex</NAME>
4709 struct GStaticRecMutex
4710 {
4711 GStaticMutex mutex;
4712 unsigned int depth;
4713 GSystemThread owner;
4714 };
4715 </STRUCT>
4716 <MACRO>
4717 <NAME>G_STATIC_REC_MUTEX_INIT</NAME>
4718 #define G_STATIC_REC_MUTEX_INIT { G_STATIC_MUTEX_INIT }
4719 </MACRO>
4720 <FUNCTION>
4721 <NAME>g_static_rec_mutex_lock</NAME>
4722 <RETURNS>void </RETURNS>
4723 GStaticRecMutex *mutex
4724 </FUNCTION>
4725 <FUNCTION>
4726 <NAME>g_static_rec_mutex_trylock</NAME>
4727 <RETURNS>gboolean </RETURNS>
4728 GStaticRecMutex *mutex
4729 </FUNCTION>
4730 <FUNCTION>
4731 <NAME>g_static_rec_mutex_unlock</NAME>
4732 <RETURNS>void </RETURNS>
4733 GStaticRecMutex *mutex
4734 </FUNCTION>
4735 <FUNCTION>
4736 <NAME>g_static_rec_mutex_lock_full</NAME>
4737 <RETURNS>void </RETURNS>
4738 GStaticRecMutex *mutex,guint depth
4739 </FUNCTION>
4740 <FUNCTION>
4741 <NAME>g_static_rec_mutex_unlock_full</NAME>
4742 <RETURNS>guint </RETURNS>
4743 GStaticRecMutex *mutex
4744 </FUNCTION>
4745 <STRUCT>
4746 <NAME>GStaticRWLock</NAME>
4747 </STRUCT>
4748 <STRUCT>
4749 <NAME>GStaticRWLock</NAME>
4750 struct GStaticRWLock
4751 {
4752 GStaticMutex mutex;
4753 GCond *read_cond;
4754 GCond *write_cond;
4755 guint read_counter;
4756 gboolean write;
4757 guint want_to_write;
4758 };
4759 </STRUCT>
4760 <MACRO>
4761 <NAME>G_STATIC_RW_LOCK_INIT</NAME>
4762 #define G_STATIC_RW_LOCK_INIT { G_STATIC_MUTEX_INIT, NULL, NULL, 0, FALSE, FALSE }
4763 </MACRO>
4764 <FUNCTION>
4765 <NAME>g_static_rw_lock_reader_lock</NAME>
4766 <RETURNS>void </RETURNS>
4767 GStaticRWLock* lock
4768 </FUNCTION>
4769 <FUNCTION>
4770 <NAME>g_static_rw_lock_reader_trylock</NAME>
4771 <RETURNS>gboolean </RETURNS>
4772 GStaticRWLock* lock
4773 </FUNCTION>
4774 <FUNCTION>
4775 <NAME>g_static_rw_lock_reader_unlock</NAME>
4776 <RETURNS>void </RETURNS>
4777 GStaticRWLock* lock
4778 </FUNCTION>
4779 <FUNCTION>
4780 <NAME>g_static_rw_lock_writer_lock</NAME>
4781 <RETURNS>void </RETURNS>
4782 GStaticRWLock* lock
4783 </FUNCTION>
4784 <FUNCTION>
4785 <NAME>g_static_rw_lock_writer_trylock</NAME>
4786 <RETURNS>gboolean </RETURNS>
4787 GStaticRWLock* lock
4788 </FUNCTION>
4789 <FUNCTION>
4790 <NAME>g_static_rw_lock_writer_unlock</NAME>
4791 <RETURNS>void </RETURNS>
4792 GStaticRWLock* lock
4793 </FUNCTION>
4794 <FUNCTION>
4795 <NAME>g_static_rw_lock_free</NAME>
4796 <RETURNS>void </RETURNS>
4797 GStaticRWLock* lock
4798 </FUNCTION>
4799 <FUNCTION>
4800 <NAME>glib_dummy_decl</NAME>
4801 <RETURNS>void </RETURNS>
4802 void
4803 </FUNCTION>
4804 <MACRO>
4805 <NAME>G_LOCK_NAME</NAME>
4806 #define G_LOCK_NAME(name) g__ ## name ## _lock
4807 </MACRO>
4808 <MACRO>
4809 <NAME>G_LOCK_DEFINE_STATIC</NAME>
4810 # define G_LOCK_DEFINE_STATIC(name) static G_LOCK_DEFINE (name)
4811 </MACRO>
4812 <MACRO>
4813 <NAME>G_LOCK_DEFINE</NAME>
4814 # define G_LOCK_DEFINE(name) \
4815 GStaticMutex G_LOCK_NAME (name) = G_STATIC_MUTEX_INIT
4816 </MACRO>
4817 <MACRO>
4818 <NAME>G_LOCK_EXTERN</NAME>
4819 # define G_LOCK_EXTERN(name) extern GStaticMutex G_LOCK_NAME (name)
4820 </MACRO>
4821 <MACRO>
4822 <NAME>G_LOCK</NAME>
4823 # define G_LOCK(name) G_STMT_START{ \
4824 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
4825 "file %s: line %d (%s): locking: %s ", \
4826 __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \
4827 #name); \
4828 g_static_mutex_lock (&G_LOCK_NAME (name)); \
4829 }G_STMT_END
4830 </MACRO>
4831 <MACRO>
4832 <NAME>G_UNLOCK</NAME>
4833 # define G_UNLOCK(name) G_STMT_START{ \
4834 g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
4835 "file %s: line %d (%s): unlocking: %s ", \
4836 __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \
4837 #name); \
4838 g_static_mutex_unlock (&G_LOCK_NAME (name)); \
4839 }G_STMT_END
4840 </MACRO>
4841 <MACRO>
4842 <NAME>G_TRYLOCK</NAME>
4843 # define G_TRYLOCK(name) \
4844 (g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, \
4845 "file %s: line %d (%s): try locking: %s ", \
4846 __FILE__, __LINE__, G_GNUC_PRETTY_FUNCTION, \
4847 #name), g_static_mutex_trylock (&G_LOCK_NAME (name)))
4848 </MACRO>
4849 <MACRO>
4850 <NAME>G_LOCK</NAME>
4851 # define G_LOCK(name) g_static_mutex_lock (&G_LOCK_NAME (name))
4852 </MACRO>
4853 <MACRO>
4854 <NAME>G_UNLOCK</NAME>
4855 # define G_UNLOCK(name) g_static_mutex_unlock (&G_LOCK_NAME (name))
4856 </MACRO>
4857 <MACRO>
4858 <NAME>G_TRYLOCK</NAME>
4859 # define G_TRYLOCK(name) g_static_mutex_trylock (&G_LOCK_NAME (name))
4860 </MACRO>
4861 <MACRO>
4862 <NAME>G_LOCK_DEFINE_STATIC</NAME>
4863 # define G_LOCK_DEFINE_STATIC(name) extern void glib_dummy_decl (void)
4864 </MACRO>
4865 <MACRO>
4866 <NAME>G_LOCK_DEFINE</NAME>
4867 # define G_LOCK_DEFINE(name) extern void glib_dummy_decl (void)
4868 </MACRO>
4869 <MACRO>
4870 <NAME>G_LOCK_EXTERN</NAME>
4871 # define G_LOCK_EXTERN(name) extern void glib_dummy_decl (void)
4872 </MACRO>
4873 <MACRO>
4874 <NAME>G_LOCK</NAME>
4875 # define G_LOCK(name)
4876 </MACRO>
4877 <MACRO>
4878 <NAME>G_UNLOCK</NAME>
4879 # define G_UNLOCK(name)
4880 </MACRO>
4881 <MACRO>
4882 <NAME>G_TRYLOCK</NAME>
4883 # define G_TRYLOCK(name) (TRUE)
4884 </MACRO>
4885 <FUNCTION>
4886 <NAME>g_async_queue_new</NAME>
4887 <RETURNS>GAsyncQueue *</RETURNS>
4888 void
4889 </FUNCTION>
4890 <FUNCTION>
4891 <NAME>g_async_queue_lock</NAME>
4892 <RETURNS>void </RETURNS>
4893 GAsyncQueue *queue
4894 </FUNCTION>
4895 <FUNCTION>
4896 <NAME>g_async_queue_unlock</NAME>
4897 <RETURNS>void </RETURNS>
4898 GAsyncQueue *queue
4899 </FUNCTION>
4900 <FUNCTION>
4901 <NAME>g_async_queue_ref</NAME>
4902 <RETURNS>void </RETURNS>
4903 GAsyncQueue *queue
4904 </FUNCTION>
4905 <FUNCTION>
4906 <NAME>g_async_queue_ref_unlocked</NAME>
4907 <RETURNS>void </RETURNS>
4908 GAsyncQueue *queue
4909 </FUNCTION>
4910 <FUNCTION>
4911 <NAME>g_async_queue_unref</NAME>
4912 <RETURNS>void </RETURNS>
4913 GAsyncQueue *queue
4914 </FUNCTION>
4915 <FUNCTION>
4916 <NAME>g_async_queue_unref_and_unlock</NAME>
4917 <RETURNS>void </RETURNS>
4918 GAsyncQueue *queue
4919 </FUNCTION>
4920 <FUNCTION>
4921 <NAME>g_async_queue_push</NAME>
4922 <RETURNS>void </RETURNS>
4923 GAsyncQueue *queue,gpointer data
4924 </FUNCTION>
4925 <FUNCTION>
4926 <NAME>g_async_queue_push_unlocked</NAME>
4927 <RETURNS>void </RETURNS>
4928 GAsyncQueue *queue,gpointer data
4929 </FUNCTION>
4930 <FUNCTION>
4931 <NAME>g_async_queue_pop</NAME>
4932 <RETURNS>gpointer </RETURNS>
4933 GAsyncQueue *queue
4934 </FUNCTION>
4935 <FUNCTION>
4936 <NAME>g_async_queue_pop_unlocked</NAME>
4937 <RETURNS>gpointer </RETURNS>
4938 GAsyncQueue *queue
4939 </FUNCTION>
4940 <FUNCTION>
4941 <NAME>g_async_queue_try_pop</NAME>
4942 <RETURNS>gpointer </RETURNS>
4943 GAsyncQueue *queue
4944 </FUNCTION>
4945 <FUNCTION>
4946 <NAME>g_async_queue_try_pop_unlocked</NAME>
4947 <RETURNS>gpointer </RETURNS>
4948 GAsyncQueue *queue
4949 </FUNCTION>
4950 <FUNCTION>
4951 <NAME>g_async_queue_timed_pop</NAME>
4952 <RETURNS>gpointer </RETURNS>
4953 GAsyncQueue *queue,GTimeVal *end_time
4954 </FUNCTION>
4955 <FUNCTION>
4956 <NAME>g_async_queue_timed_pop_unlocked</NAME>
4957 <RETURNS>gpointer </RETURNS>
4958 GAsyncQueue *queue,GTimeVal *end_time
4959 </FUNCTION>
4960 <FUNCTION>
4961 <NAME>g_async_queue_length</NAME>
4962 <RETURNS>gint </RETURNS>
4963 GAsyncQueue *queue
4964 </FUNCTION>
4965 <FUNCTION>
4966 <NAME>g_async_queue_length_unlocked</NAME>
4967 <RETURNS>gint </RETURNS>
4968 GAsyncQueue *queue
4969 </FUNCTION>
4970 <STRUCT>
4971 <NAME>GThreadPool</NAME>
4972 struct GThreadPool
4973 {
4974 GFunc thread_func;
4975 gulong stack_size;
4976 gboolean bound;
4977 GThreadPriority priority;
4978 gboolean exclusive;
4979 gpointer user_data;
4980 };
4981 </STRUCT>
4982 <FUNCTION>
4983 <NAME>g_thread_pool_new</NAME>
4984 <RETURNS>GThreadPool *</RETURNS>
4985 GFunc thread_func,gint max_threads,gulong stack_size,gboolean bound,GThreadPriority priority,gboolean exclusive,gpointer user_data,GError **error
4986 </FUNCTION>
4987 <FUNCTION>
4988 <NAME>g_thread_pool_push</NAME>
4989 <RETURNS>void </RETURNS>
4990 GThreadPool *pool,gpointer data,GError **error
4991 </FUNCTION>
4992 <FUNCTION>
4993 <NAME>g_thread_pool_set_max_threads</NAME>
4994 <RETURNS>void </RETURNS>
4995 GThreadPool *pool,gint max_threads,GError **error
4996 </FUNCTION>
4997 <FUNCTION>
4998 <NAME>g_thread_pool_get_max_threads</NAME>
4999 <RETURNS>gint </RETURNS>
5000 GThreadPool *pool
5001 </FUNCTION>
5002 <FUNCTION>
5003 <NAME>g_thread_pool_get_num_threads</NAME>
5004 <RETURNS>guint </RETURNS>
5005 GThreadPool *pool
5006 </FUNCTION>
5007 <FUNCTION>
5008 <NAME>g_thread_pool_unprocessed</NAME>
5009 <RETURNS>guint </RETURNS>
5010 GThreadPool *pool
5011 </FUNCTION>
5012 <FUNCTION>
5013 <NAME>g_thread_pool_free</NAME>
5014 <RETURNS>void </RETURNS>
5015 GThreadPool *pool,gboolean immediate,gboolean wait
5016 </FUNCTION>
5017 <FUNCTION>
5018 <NAME>g_thread_pool_set_max_unused_threads</NAME>
5019 <RETURNS>void </RETURNS>
5020 gint max_threads
5021 </FUNCTION>
5022 <FUNCTION>
5023 <NAME>g_thread_pool_get_max_unused_threads</NAME>
5024 <RETURNS>gint </RETURNS>
5025 void
5026 </FUNCTION>
5027 <FUNCTION>
5028 <NAME>g_thread_pool_get_num_unused_threads</NAME>
5029 <RETURNS>guint </RETURNS>
5030 void
5031 </FUNCTION>
5032 <FUNCTION>
5033 <NAME>g_thread_pool_stop_unused_threads</NAME>
5034 <RETURNS>void </RETURNS>
5035 void
5036 </FUNCTION>
5037 <TYPEDEF>
5038 <NAME>gunichar</NAME>
5039 typedef guint32 gunichar;
5040 </TYPEDEF>
5041 <TYPEDEF>
5042 <NAME>gunichar2</NAME>
5043 typedef guint16 gunichar2;
5044 </TYPEDEF>
5045 <ENUM>
5046 <NAME>GUnicodeType</NAME>
5047 typedef enum {
5048 G_UNICODE_CONTROL,
5049 G_UNICODE_FORMAT,
5050 G_UNICODE_UNASSIGNED,
5051 G_UNICODE_PRIVATE_USE,
5052 G_UNICODE_SURROGATE,
5053 G_UNICODE_LOWERCASE_LETTER,
5054 G_UNICODE_MODIFIER_LETTER,
5055 G_UNICODE_OTHER_LETTER,
5056 G_UNICODE_TITLECASE_LETTER,
5057 G_UNICODE_UPPERCASE_LETTER,
5058 G_UNICODE_COMBINING_MARK,
5059 G_UNICODE_ENCLOSING_MARK,
5060 G_UNICODE_NON_SPACING_MARK,
5061 G_UNICODE_DECIMAL_NUMBER,
5062 G_UNICODE_LETTER_NUMBER,
5063 G_UNICODE_OTHER_NUMBER,
5064 G_UNICODE_CONNECT_PUNCTUATION,
5065 G_UNICODE_DASH_PUNCTUATION,
5066 G_UNICODE_CLOSE_PUNCTUATION,
5067 G_UNICODE_FINAL_PUNCTUATION,
5068 G_UNICODE_INITIAL_PUNCTUATION,
5069 G_UNICODE_OTHER_PUNCTUATION,
5070 G_UNICODE_OPEN_PUNCTUATION,
5071 G_UNICODE_CURRENCY_SYMBOL,
5072 G_UNICODE_MODIFIER_SYMBOL,
5073 G_UNICODE_MATH_SYMBOL,
5074 G_UNICODE_OTHER_SYMBOL,
5075 G_UNICODE_LINE_SEPARATOR,
5076 G_UNICODE_PARAGRAPH_SEPARATOR,
5077 G_UNICODE_SPACE_SEPARATOR
5078 } GUnicodeType;
5079 </ENUM>
5080 <FUNCTION>
5081 <NAME>g_get_charset</NAME>
5082 <RETURNS>gboolean </RETURNS>
5083 char **charset
5084 </FUNCTION>
5085 <FUNCTION>
5086 <NAME>g_unichar_isalnum</NAME>
5087 <RETURNS>gboolean </RETURNS>
5088 gunichar c
5089 </FUNCTION>
5090 <FUNCTION>
5091 <NAME>g_unichar_isalpha</NAME>
5092 <RETURNS>gboolean </RETURNS>
5093 gunichar c
5094 </FUNCTION>
5095 <FUNCTION>
5096 <NAME>g_unichar_iscntrl</NAME>
5097 <RETURNS>gboolean </RETURNS>
5098 gunichar c
5099 </FUNCTION>
5100 <FUNCTION>
5101 <NAME>g_unichar_isdigit</NAME>
5102 <RETURNS>gboolean </RETURNS>
5103 gunichar c
5104 </FUNCTION>
5105 <FUNCTION>
5106 <NAME>g_unichar_isgraph</NAME>
5107 <RETURNS>gboolean </RETURNS>
5108 gunichar c
5109 </FUNCTION>
5110 <FUNCTION>
5111 <NAME>g_unichar_islower</NAME>
5112 <RETURNS>gboolean </RETURNS>
5113 gunichar c
5114 </FUNCTION>
5115 <FUNCTION>
5116 <NAME>g_unichar_isprint</NAME>
5117 <RETURNS>gboolean </RETURNS>
5118 gunichar c
5119 </FUNCTION>
5120 <FUNCTION>
5121 <NAME>g_unichar_ispunct</NAME>
5122 <RETURNS>gboolean </RETURNS>
5123 gunichar c
5124 </FUNCTION>
5125 <FUNCTION>
5126 <NAME>g_unichar_isspace</NAME>
5127 <RETURNS>gboolean </RETURNS>
5128 gunichar c
5129 </FUNCTION>
5130 <FUNCTION>
5131 <NAME>g_unichar_isupper</NAME>
5132 <RETURNS>gboolean </RETURNS>
5133 gunichar c
5134 </FUNCTION>
5135 <FUNCTION>
5136 <NAME>g_unichar_isxdigit</NAME>
5137 <RETURNS>gboolean </RETURNS>
5138 gunichar c
5139 </FUNCTION>
5140 <FUNCTION>
5141 <NAME>g_unichar_istitle</NAME>
5142 <RETURNS>gboolean </RETURNS>
5143 gunichar c
5144 </FUNCTION>
5145 <FUNCTION>
5146 <NAME>g_unichar_isdefined</NAME>
5147 <RETURNS>gboolean </RETURNS>
5148 gunichar c
5149 </FUNCTION>
5150 <FUNCTION>
5151 <NAME>g_unichar_iswide</NAME>
5152 <RETURNS>gboolean </RETURNS>
5153 gunichar c
5154 </FUNCTION>
5155 <FUNCTION>
5156 <NAME>g_unichar_toupper</NAME>
5157 <RETURNS>gunichar </RETURNS>
5158 gunichar c
5159 </FUNCTION>
5160 <FUNCTION>
5161 <NAME>g_unichar_tolower</NAME>
5162 <RETURNS>gunichar </RETURNS>
5163 gunichar c
5164 </FUNCTION>
5165 <FUNCTION>
5166 <NAME>g_unichar_totitle</NAME>
5167 <RETURNS>gunichar </RETURNS>
5168 gunichar c
5169 </FUNCTION>
5170 <FUNCTION>
5171 <NAME>g_unichar_digit_value</NAME>
5172 <RETURNS>gint </RETURNS>
5173 gunichar c
5174 </FUNCTION>
5175 <FUNCTION>
5176 <NAME>g_unichar_xdigit_value</NAME>
5177 <RETURNS>gint </RETURNS>
5178 gunichar c
5179 </FUNCTION>
5180 <FUNCTION>
5181 <NAME>g_unichar_type</NAME>
5182 <RETURNS>GUnicodeType </RETURNS>
5183 gunichar c
5184 </FUNCTION>
5185 <FUNCTION>
5186 <NAME>g_unicode_canonical_ordering</NAME>
5187 <RETURNS>void </RETURNS>
5188 gunichar *string,size_t len
5189 </FUNCTION>
5190 <FUNCTION>
5191 <NAME>g_unicode_canonical_decomposition</NAME>
5192 <RETURNS>gunichar *</RETURNS>
5193 gunichar ch,size_t *result_len
5194 </FUNCTION>
5195 <MACRO>
5196 <NAME>GLIB_VAR</NAME>
5197 # define GLIB_VAR __declspec(dllexport)
5198 </MACRO>
5199 <MACRO>
5200 <NAME>GLIB_VAR</NAME>
5201 # define GLIB_VAR extern __declspec(dllimport)
5202 </MACRO>
5203 <MACRO>
5204 <NAME>GLIB_VAR</NAME>
5205 # define GLIB_VAR extern
5206 </MACRO>
5207 <MACRO>
5208 <NAME>g_utf8_next_char</NAME>
5209 #define g_utf8_next_char(p) (char *)((p) + g_utf8_skip[*(guchar *)(p)])
5210 </MACRO>
5211 <FUNCTION>
5212 <NAME>g_utf8_get_char</NAME>
5213 <RETURNS>gunichar </RETURNS>
5214 const gchar *p
5215 </FUNCTION>
5216 <FUNCTION>
5217 <NAME>g_utf8_offset_to_pointer</NAME>
5218 <RETURNS>gchar *</RETURNS>
5219 const gchar *str,gint offset
5220 </FUNCTION>
5221 <FUNCTION>
5222 <NAME>g_utf8_pointer_to_offset</NAME>
5223 <RETURNS>gint </RETURNS>
5224 const gchar *str,const gchar *pos
5225 </FUNCTION>
5226 <FUNCTION>
5227 <NAME>g_utf8_prev_char</NAME>
5228 <RETURNS>gchar *</RETURNS>
5229 const gchar *p
5230 </FUNCTION>
5231 <FUNCTION>
5232 <NAME>g_utf8_find_next_char</NAME>
5233 <RETURNS>gchar *</RETURNS>
5234 const gchar *p,const gchar *bound
5235 </FUNCTION>
5236 <FUNCTION>
5237 <NAME>g_utf8_find_prev_char</NAME>
5238 <RETURNS>gchar *</RETURNS>
5239 const gchar *str,const gchar *p
5240 </FUNCTION>
5241 <FUNCTION>
5242 <NAME>g_utf8_strlen</NAME>
5243 <RETURNS>gint </RETURNS>
5244 const gchar *p,gint max
5245 </FUNCTION>
5246 <FUNCTION>
5247 <NAME>g_utf8_strncpy</NAME>
5248 <RETURNS>gchar *</RETURNS>
5249 gchar *dest,const gchar *src,size_t n
5250 </FUNCTION>
5251 <FUNCTION>
5252 <NAME>g_utf8_strchr</NAME>
5253 <RETURNS>gchar *</RETURNS>
5254 const gchar *p,gunichar ch
5255 </FUNCTION>
5256 <FUNCTION>
5257 <NAME>g_utf8_strrchr</NAME>
5258 <RETURNS>gchar *</RETURNS>
5259 const gchar *p,gunichar ch
5260 </FUNCTION>
5261 <FUNCTION>
5262 <NAME>g_utf8_to_utf16</NAME>
5263 <RETURNS>gunichar2 *</RETURNS>
5264 const gchar *str,gint len
5265 </FUNCTION>
5266 <FUNCTION>
5267 <NAME>g_utf8_to_ucs4</NAME>
5268 <RETURNS>gunichar *</RETURNS>
5269 const gchar *str,gint len
5270 </FUNCTION>
5271 <FUNCTION>
5272 <NAME>g_utf16_to_ucs4</NAME>
5273 <RETURNS>gunichar *</RETURNS>
5274 const gunichar2 *str,gint len
5275 </FUNCTION>
5276 <FUNCTION>
5277 <NAME>g_utf16_to_utf8</NAME>
5278 <RETURNS>gchar *</RETURNS>
5279 const gunichar2 *str,gint len
5280 </FUNCTION>
5281 <FUNCTION>
5282 <NAME>g_ucs4_to_utf16</NAME>
5283 <RETURNS>gunichar *</RETURNS>
5284 const gunichar *str,gint len
5285 </FUNCTION>
5286 <FUNCTION>
5287 <NAME>g_ucs4_to_utf8</NAME>
5288 <RETURNS>gchar *</RETURNS>
5289 const gunichar *str,gint len
5290 </FUNCTION>
5291 <FUNCTION>
5292 <NAME>g_unichar_to_utf8</NAME>
5293 <RETURNS>gint </RETURNS>
5294 gunichar c,char *outbuf
5295 </FUNCTION>
5296 <MACRO>
5297 <NAME>GLIB_HAVE_SYS_POLL_H</NAME>
5298 #define GLIB_HAVE_SYS_POLL_H
5299 </MACRO>
5300 <MACRO>
5301 <NAME>G_MINFLOAT</NAME>
5302 #define G_MINFLOAT FLT_MIN
5303 </MACRO>
5304 <MACRO>
5305 <NAME>G_MAXFLOAT</NAME>
5306 #define G_MAXFLOAT FLT_MAX
5307 </MACRO>
5308 <MACRO>
5309 <NAME>G_MINDOUBLE</NAME>
5310 #define G_MINDOUBLE DBL_MIN
5311 </MACRO>
5312 <MACRO>
5313 <NAME>G_MAXDOUBLE</NAME>
5314 #define G_MAXDOUBLE DBL_MAX
5315 </MACRO>
5316 <MACRO>
5317 <NAME>G_MINSHORT</NAME>
5318 #define G_MINSHORT SHRT_MIN
5319 </MACRO>
5320 <MACRO>
5321 <NAME>G_MAXSHORT</NAME>
5322 #define G_MAXSHORT SHRT_MAX
5323 </MACRO>
5324 <MACRO>
5325 <NAME>G_MAXUSHORT</NAME>
5326 #define G_MAXUSHORT USHRT_MAX
5327 </MACRO>
5328 <MACRO>
5329 <NAME>G_MININT</NAME>
5330 #define G_MININT INT_MIN
5331 </MACRO>
5332 <MACRO>
5333 <NAME>G_MAXINT</NAME>
5334 #define G_MAXINT INT_MAX
5335 </MACRO>
5336 <MACRO>
5337 <NAME>G_MAXUINT</NAME>
5338 #define G_MAXUINT UINT_MAX
5339 </MACRO>
5340 <MACRO>
5341 <NAME>G_MINLONG</NAME>
5342 #define G_MINLONG LONG_MIN
5343 </MACRO>
5344 <MACRO>
5345 <NAME>G_MAXLONG</NAME>
5346 #define G_MAXLONG LONG_MAX
5347 </MACRO>
5348 <MACRO>
5349 <NAME>G_MAXULONG</NAME>
5350 #define G_MAXULONG ULONG_MAX
5351 </MACRO>
5352 <TYPEDEF>
5353 <NAME>gint8</NAME>
5354 typedef signed char gint8;
5355 </TYPEDEF>
5356 <TYPEDEF>
5357 <NAME>guint8</NAME>
5358 typedef unsigned char guint8;
5359 </TYPEDEF>
5360 <TYPEDEF>
5361 <NAME>gint16</NAME>
5362 typedef signed short gint16;
5363 </TYPEDEF>
5364 <TYPEDEF>
5365 <NAME>guint16</NAME>
5366 typedef unsigned short guint16;
5367 </TYPEDEF>
5368 <MACRO>
5369 <NAME>G_GINT16_FORMAT</NAME>
5370 #define G_GINT16_FORMAT "hi"
5371 </MACRO>
5372 <MACRO>
5373 <NAME>G_GUINT16_FORMAT</NAME>
5374 #define G_GUINT16_FORMAT "hu"
5375 </MACRO>
5376 <TYPEDEF>
5377 <NAME>gint32</NAME>
5378 typedef signed int gint32;
5379 </TYPEDEF>
5380 <TYPEDEF>
5381 <NAME>guint32</NAME>
5382 typedef unsigned int guint32;
5383 </TYPEDEF>
5384 <MACRO>
5385 <NAME>G_GINT32_FORMAT</NAME>
5386 #define G_GINT32_FORMAT "i"
5387 </MACRO>
5388 <MACRO>
5389 <NAME>G_GUINT32_FORMAT</NAME>
5390 #define G_GUINT32_FORMAT "u"
5391 </MACRO>
5392 <MACRO>
5393 <NAME>G_HAVE_GINT64</NAME>
5394 #define G_HAVE_GINT64 1
5395 </MACRO>
5396 <TYPEDEF>
5397 <NAME>gint64</NAME>
5398 G_GNUC_EXTENSION typedef signed long long gint64;
5399 </TYPEDEF>
5400 <TYPEDEF>
5401 <NAME>guint64</NAME>
5402 G_GNUC_EXTENSION typedef unsigned long long guint64;
5403 </TYPEDEF>
5404 <MACRO>
5405 <NAME>G_GINT64_FORMAT</NAME>
5406 #define G_GINT64_FORMAT "lli"
5407 </MACRO>
5408 <MACRO>
5409 <NAME>G_GUINT64_FORMAT</NAME>
5410 #define G_GUINT64_FORMAT "llu"
5411 </MACRO>
5412 <MACRO>
5413 <NAME>G_GINT64_CONSTANT</NAME>
5414 #define G_GINT64_CONSTANT(val) (G_GNUC_EXTENSION (val##LL))
5415 </MACRO>
5416 <TYPEDEF>
5417 <NAME>gssize</NAME>
5418 typedef gint32 gssize;
5419 </TYPEDEF>
5420 <TYPEDEF>
5421 <NAME>gsize</NAME>
5422 typedef guint32 gsize;
5423 </TYPEDEF>
5424 <MACRO>
5425 <NAME>GPOINTER_TO_INT</NAME>
5426 #define GPOINTER_TO_INT(p) ((gint) (p))
5427 </MACRO>
5428 <MACRO>
5429 <NAME>GPOINTER_TO_UINT</NAME>
5430 #define GPOINTER_TO_UINT(p) ((guint) (p))
5431 </MACRO>
5432 <MACRO>
5433 <NAME>GINT_TO_POINTER</NAME>
5434 #define GINT_TO_POINTER(i) ((gpointer) (i))
5435 </MACRO>
5436 <MACRO>
5437 <NAME>GUINT_TO_POINTER</NAME>
5438 #define GUINT_TO_POINTER(u) ((gpointer) (u))
5439 </MACRO>
5440 <MACRO>
5441 <NAME>g_ATEXIT</NAME>
5442 # define g_ATEXIT(proc) (!atexit (proc))
5443 </MACRO>
5444 <MACRO>
5445 <NAME>g_ATEXIT</NAME>
5446 # define g_ATEXIT(proc) (atexit (proc))
5447 </MACRO>
5448 <MACRO>
5449 <NAME>g_memmove</NAME>
5450 #define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END
5451 </MACRO>
5452 <MACRO>
5453 <NAME>GLIB_MAJOR_VERSION</NAME>
5454 #define GLIB_MAJOR_VERSION 1
5455 </MACRO>
5456 <MACRO>
5457 <NAME>GLIB_MINOR_VERSION</NAME>
5458 #define GLIB_MINOR_VERSION 3
5459 </MACRO>
5460 <MACRO>
5461 <NAME>GLIB_MICRO_VERSION</NAME>
5462 #define GLIB_MICRO_VERSION 1
5463 </MACRO>
5464 <MACRO>
5465 <NAME>G_OS_UNIX</NAME>
5466 #define G_OS_UNIX
5467 </MACRO>
5468 <MACRO>
5469 <NAME>G_VA_COPY</NAME>
5470 #define G_VA_COPY __va_copy
5471 </MACRO>
5472 <MACRO>
5473 <NAME>G_HAVE_INLINE</NAME>
5474 #define G_HAVE_INLINE 1
5475 </MACRO>
5476 <MACRO>
5477 <NAME>G_HAVE_INLINE</NAME>
5478 #define G_HAVE_INLINE 1
5479 </MACRO>
5480 <MACRO>
5481 <NAME>G_HAVE___INLINE</NAME>
5482 #define G_HAVE___INLINE 1
5483 </MACRO>
5484 <MACRO>
5485 <NAME>G_HAVE___INLINE__</NAME>
5486 #define G_HAVE___INLINE__ 1
5487 </MACRO>
5488 <MACRO>
5489 <NAME>G_THREADS_ENABLED</NAME>
5490 #define G_THREADS_ENABLED
5491 </MACRO>
5492 <MACRO>
5493 <NAME>G_THREADS_IMPL_POSIX</NAME>
5494 #define G_THREADS_IMPL_POSIX
5495 </MACRO>
5496 <STRUCT>
5497 <NAME>GStaticMutex</NAME>
5498 </STRUCT>
5499 <STRUCT>
5500 <NAME>GStaticMutex</NAME>
5501 struct GStaticMutex
5502 {
5503 struct _GMutex *runtime_mutex;
5504 union {
5505 char pad[24];
5506 double dummy_double;
5507 void *dummy_pointer;
5508 long dummy_long;
5509 } aligned_pad_u;
5510 };
5511 </STRUCT>
5512 <MACRO>
5513 <NAME>G_STATIC_MUTEX_INIT</NAME>
5514 #define G_STATIC_MUTEX_INIT { NULL, { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} } }
5515 </MACRO>
5516 <MACRO>
5517 <NAME>g_static_mutex_get_mutex</NAME>
5518 #define g_static_mutex_get_mutex(mutex) (g_thread_use_default_impl ? ((GMutex*) &((mutex)->aligned_pad_u)) : g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
5519 </MACRO>
5520 <UNION>
5521 <NAME>GSystemThread</NAME>
5522 union GSystemThread
5523 {
5524 char data[4];
5525 double dummy_double;
5526 void *dummy_pointer;
5527 long dummy_long;
5528 };
5529 </UNION>
5530 <MACRO>
5531 <NAME>GINT16_TO_LE</NAME>
5532 #define GINT16_TO_LE(val) ((gint16) (val))
5533 </MACRO>
5534 <MACRO>
5535 <NAME>GUINT16_TO_LE</NAME>
5536 #define GUINT16_TO_LE(val) ((guint16) (val))
5537 </MACRO>
5538 <MACRO>
5539 <NAME>GINT16_TO_BE</NAME>
5540 #define GINT16_TO_BE(val) ((gint16) GUINT16_SWAP_LE_BE (val))
5541 </MACRO>
5542 <MACRO>
5543 <NAME>GUINT16_TO_BE</NAME>
5544 #define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val))
5545 </MACRO>
5546 <MACRO>
5547 <NAME>GINT32_TO_LE</NAME>
5548 #define GINT32_TO_LE(val) ((gint32) (val))
5549 </MACRO>
5550 <MACRO>
5551 <NAME>GUINT32_TO_LE</NAME>
5552 #define GUINT32_TO_LE(val) ((guint32) (val))
5553 </MACRO>
5554 <MACRO>
5555 <NAME>GINT32_TO_BE</NAME>
5556 #define GINT32_TO_BE(val) ((gint32) GUINT32_SWAP_LE_BE (val))
5557 </MACRO>
5558 <MACRO>
5559 <NAME>GUINT32_TO_BE</NAME>
5560 #define GUINT32_TO_BE(val) (GUINT32_SWAP_LE_BE (val))
5561 </MACRO>
5562 <MACRO>
5563 <NAME>GINT64_TO_LE</NAME>
5564 #define GINT64_TO_LE(val) ((gint64) (val))
5565 </MACRO>
5566 <MACRO>
5567 <NAME>GUINT64_TO_LE</NAME>
5568 #define GUINT64_TO_LE(val) ((guint64) (val))
5569 </MACRO>
5570 <MACRO>
5571 <NAME>GINT64_TO_BE</NAME>
5572 #define GINT64_TO_BE(val) ((gint64) GUINT64_SWAP_LE_BE (val))
5573 </MACRO>
5574 <MACRO>
5575 <NAME>GUINT64_TO_BE</NAME>
5576 #define GUINT64_TO_BE(val) (GUINT64_SWAP_LE_BE (val))
5577 </MACRO>
5578 <MACRO>
5579 <NAME>GLONG_TO_LE</NAME>
5580 #define GLONG_TO_LE(val) ((glong) GINT32_TO_LE (val))
5581 </MACRO>
5582 <MACRO>
5583 <NAME>GULONG_TO_LE</NAME>
5584 #define GULONG_TO_LE(val) ((gulong) GUINT32_TO_LE (val))
5585 </MACRO>
5586 <MACRO>
5587 <NAME>GLONG_TO_BE</NAME>
5588 #define GLONG_TO_BE(val) ((glong) GINT32_TO_BE (val))
5589 </MACRO>
5590 <MACRO>
5591 <NAME>GULONG_TO_BE</NAME>
5592 #define GULONG_TO_BE(val) ((gulong) GUINT32_TO_BE (val))
5593 </MACRO>
5594 <MACRO>
5595 <NAME>GINT_TO_LE</NAME>
5596 #define GINT_TO_LE(val) ((gint) GINT32_TO_LE (val))
5597 </MACRO>
5598 <MACRO>
5599 <NAME>GUINT_TO_LE</NAME>
5600 #define GUINT_TO_LE(val) ((guint) GUINT32_TO_LE (val))
5601 </MACRO>
5602 <MACRO>
5603 <NAME>GINT_TO_BE</NAME>
5604 #define GINT_TO_BE(val) ((gint) GINT32_TO_BE (val))
5605 </MACRO>
5606 <MACRO>
5607 <NAME>GUINT_TO_BE</NAME>
5608 #define GUINT_TO_BE(val) ((guint) GUINT32_TO_BE (val))
5609 </MACRO>
5610 <MACRO>
5611 <NAME>G_BYTE_ORDER</NAME>
5612 #define G_BYTE_ORDER G_LITTLE_ENDIAN
5613 </MACRO>
5614 <MACRO>
5615 <NAME>GLIB_SYSDEF_POLLIN</NAME>
5616 #define GLIB_SYSDEF_POLLIN =1
5617 </MACRO>
5618 <MACRO>
5619 <NAME>GLIB_SYSDEF_POLLOUT</NAME>
5620 #define GLIB_SYSDEF_POLLOUT =4
5621 </MACRO>
5622 <MACRO>
5623 <NAME>GLIB_SYSDEF_POLLPRI</NAME>
5624 #define GLIB_SYSDEF_POLLPRI =2
5625 </MACRO>
5626 <MACRO>
5627 <NAME>GLIB_SYSDEF_POLLERR</NAME>
5628 #define GLIB_SYSDEF_POLLERR =8
5629 </MACRO>
5630 <MACRO>
5631 <NAME>GLIB_SYSDEF_POLLHUP</NAME>
5632 #define GLIB_SYSDEF_POLLHUP =16
5633 </MACRO>
5634 <MACRO>
5635 <NAME>GLIB_SYSDEF_POLLNVAL</NAME>
5636 #define GLIB_SYSDEF_POLLNVAL =32
5637 </MACRO>
5638 <VARIABLE>
5639 <NAME>g_log_domain_gmodule</NAME>
5640 extern const char *g_log_domain_gmodule;
5641 </VARIABLE>
5642 <MACRO>
5643 <NAME>G_MODULE_IMPORT</NAME>
5644 #define G_MODULE_IMPORT extern
5645 </MACRO>
5646 <MACRO>
5647 <NAME>G_MODULE_EXPORT</NAME>
5648 # define G_MODULE_EXPORT __declspec(dllexport)
5649 </MACRO>
5650 <MACRO>
5651 <NAME>G_MODULE_EXPORT</NAME>
5652 # define G_MODULE_EXPORT
5653 </MACRO>
5654 <ENUM>
5655 <NAME>GModuleFlags</NAME>
5656 typedef enum
5657 {
5658 G_MODULE_BIND_LAZY = 1 << 0,
5659 G_MODULE_BIND_MASK = 0x01
5660 } GModuleFlags;
5661 </ENUM>
5662 <STRUCT>
5663 <NAME>GModule</NAME>
5664 </STRUCT>
5665 <USER_FUNCTION>
5666 <NAME>GModuleCheckInit</NAME>
5667 <RETURNS>const gchar *</RETURNS>
5668 GModule *module
5669 </USER_FUNCTION>
5670 <USER_FUNCTION>
5671 <NAME>GModuleUnload</NAME>
5672 <RETURNS>void </RETURNS>
5673 GModule *module
5674 </USER_FUNCTION>
5675 <FUNCTION>
5676 <NAME>g_module_supported</NAME>
5677 <RETURNS>gboolean </RETURNS>
5678 void
5679 </FUNCTION>
5680 <FUNCTION>
5681 <NAME>g_module_open</NAME>
5682 <RETURNS>GModule *</RETURNS>
5683 const gchar *file_name,GModuleFlags flags
5684 </FUNCTION>
5685 <FUNCTION>
5686 <NAME>g_module_close</NAME>
5687 <RETURNS>gboolean </RETURNS>
5688 GModule *module
5689 </FUNCTION>
5690 <FUNCTION>
5691 <NAME>g_module_make_resident</NAME>
5692 <RETURNS>void </RETURNS>
5693 GModule *module
5694 </FUNCTION>
5695 <FUNCTION>
5696 <NAME>g_module_error</NAME>
5697 <RETURNS>gchar *</RETURNS>
5698 void
5699 </FUNCTION>
5700 <FUNCTION>
5701 <NAME>g_module_symbol</NAME>
5702 <RETURNS>gboolean </RETURNS>
5703 GModule *module,const gchar *symbol_name,gpointer *symbol
5704 </FUNCTION>
5705 <FUNCTION>
5706 <NAME>g_module_name</NAME>
5707 <RETURNS>gchar *</RETURNS>
5708 GModule *module
5709 </FUNCTION>
5710 <FUNCTION>
5711 <NAME>g_module_build_path</NAME>
5712 <RETURNS>gchar *</RETURNS>
5713 const gchar *directory,const gchar *module_name
5714 </FUNCTION>
5715 <MACRO>
5716 <NAME>G_TYPE_IS_ENUM</NAME>
5717 #define G_TYPE_IS_ENUM(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_ENUM)
5718 </MACRO>
5719 <MACRO>
5720 <NAME>G_ENUM_CLASS</NAME>
5721 #define G_ENUM_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_ENUM, GEnumClass))
5722 </MACRO>
5723 <MACRO>
5724 <NAME>G_IS_ENUM_CLASS</NAME>
5725 #define G_IS_ENUM_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_ENUM))
5726 </MACRO>
5727 <MACRO>
5728 <NAME>G_ENUM_CLASS_TYPE</NAME>
5729 #define G_ENUM_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class))
5730 </MACRO>
5731 <MACRO>
5732 <NAME>G_ENUM_CLASS_TYPE_NAME</NAME>
5733 #define G_ENUM_CLASS_TYPE_NAME(class) (g_type_name (G_ENUM_TYPE (class)))
5734 </MACRO>
5735 <MACRO>
5736 <NAME>G_TYPE_IS_FLAGS</NAME>
5737 #define G_TYPE_IS_FLAGS(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_FLAGS)
5738 </MACRO>
5739 <MACRO>
5740 <NAME>G_FLAGS_CLASS</NAME>
5741 #define G_FLAGS_CLASS(class) (G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_FLAGS, GFlagsClass))
5742 </MACRO>
5743 <MACRO>
5744 <NAME>G_IS_FLAGS_CLASS</NAME>
5745 #define G_IS_FLAGS_CLASS(class) (G_TYPE_CHECK_CLASS_TYPE ((class), G_TYPE_FLAGS))
5746 </MACRO>
5747 <MACRO>
5748 <NAME>G_FLAGS_CLASS_TYPE</NAME>
5749 #define G_FLAGS_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class))
5750 </MACRO>
5751 <MACRO>
5752 <NAME>G_FLAGS_CLASS_TYPE_NAME</NAME>
5753 #define G_FLAGS_CLASS_TYPE_NAME(class) (g_type_name (G_FLAGS_TYPE (class)))
5754 </MACRO>
5755 <MACRO>
5756 <NAME>G_IS_VALUE_ENUM</NAME>
5757 #define G_IS_VALUE_ENUM(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_ENUM))
5758 </MACRO>
5759 <MACRO>
5760 <NAME>G_IS_VALUE_FLAGS</NAME>
5761 #define G_IS_VALUE_FLAGS(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_FLAGS))
5762 </MACRO>
5763 <STRUCT>
5764 <NAME>GEnumClass</NAME>
5765 </STRUCT>
5766 <STRUCT>
5767 <NAME>GFlagsClass</NAME>
5768 </STRUCT>
5769 <STRUCT>
5770 <NAME>GEnumValue</NAME>
5771 </STRUCT>
5772 <STRUCT>
5773 <NAME>GFlagsValue</NAME>
5774 </STRUCT>
5775 <STRUCT>
5776 <NAME>GEnumValue</NAME>
5777 struct GEnumValue
5778 {
5779 gint value;
5780 gchar *value_name;
5781 gchar *value_nick;
5782 };
5783 </STRUCT>
5784 <STRUCT>
5785 <NAME>GFlagsValue</NAME>
5786 struct GFlagsValue
5787 {
5788 guint value;
5789 gchar *value_name;
5790 gchar *value_nick;
5791 };
5792 </STRUCT>
5793 <FUNCTION>
5794 <NAME>g_enum_get_value</NAME>
5795 <RETURNS>GEnumValue *</RETURNS>
5796 GEnumClass *enum_class,gint value
5797 </FUNCTION>
5798 <FUNCTION>
5799 <NAME>g_enum_get_value_by_name</NAME>
5800 <RETURNS>GEnumValue *</RETURNS>
5801 GEnumClass *enum_class,const gchar *name
5802 </FUNCTION>
5803 <FUNCTION>
5804 <NAME>g_enum_get_value_by_nick</NAME>
5805 <RETURNS>GEnumValue *</RETURNS>
5806 GEnumClass *enum_class,const gchar *nick
5807 </FUNCTION>
5808 <FUNCTION>
5809 <NAME>g_flags_get_first_value</NAME>
5810 <RETURNS>GFlagsValue *</RETURNS>
5811 GFlagsClass *flags_class,guint value
5812 </FUNCTION>
5813 <FUNCTION>
5814 <NAME>g_flags_get_value_by_name</NAME>
5815 <RETURNS>GFlagsValue *</RETURNS>
5816 GFlagsClass *flags_class,const gchar *name
5817 </FUNCTION>
5818 <FUNCTION>
5819 <NAME>g_flags_get_value_by_nick</NAME>
5820 <RETURNS>GFlagsValue *</RETURNS>
5821 GFlagsClass *flags_class,const gchar *nick
5822 </FUNCTION>
5823 <FUNCTION>
5824 <NAME>g_value_set_enum</NAME>
5825 <RETURNS>void </RETURNS>
5826 GValue *value,gint v_enum
5827 </FUNCTION>
5828 <FUNCTION>
5829 <NAME>g_value_get_enum</NAME>
5830 <RETURNS>gint </RETURNS>
5831 GValue *value
5832 </FUNCTION>
5833 <FUNCTION>
5834 <NAME>g_value_set_flags</NAME>
5835 <RETURNS>void </RETURNS>
5836 GValue *value,guint v_flags
5837 </FUNCTION>
5838 <FUNCTION>
5839 <NAME>g_value_get_flags</NAME>
5840 <RETURNS>guint </RETURNS>
5841 GValue *value
5842 </FUNCTION>
5843 <FUNCTION>
5844 <NAME>g_enum_register_static</NAME>
5845 <RETURNS>GType </RETURNS>
5846 const gchar *name,const GEnumValue *const_static_values
5847 </FUNCTION>
5848 <FUNCTION>
5849 <NAME>g_flags_register_static</NAME>
5850 <RETURNS>GType </RETURNS>
5851 const gchar *name,const GFlagsValue *const_static_values
5852 </FUNCTION>
5853 <FUNCTION>
5854 <NAME>g_enum_complete_type_info</NAME>
5855 <RETURNS>void </RETURNS>
5856 GType g_enum_type,GTypeInfo *info,const GEnumValue *const_values
5857 </FUNCTION>
5858 <FUNCTION>
5859 <NAME>g_flags_complete_type_info</NAME>
5860 <RETURNS>void </RETURNS>
5861 GType g_flags_type,GTypeInfo *info,const GFlagsValue *const_values
5862 </FUNCTION>
5863 <MACRO>
5864 <NAME>G_TYPE_IS_OBJECT</NAME>
5865 #define G_TYPE_IS_OBJECT(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_OBJECT)
5866 </MACRO>
5867 <MACRO>
5868 <NAME>G_OBJECT</NAME>
5869 #define G_OBJECT(object) (G_IS_OBJECT (object) ? ((GObject*) (object)) : \
5870 G_TYPE_CHECK_INSTANCE_CAST ((object), G_TYPE_OBJECT, GObject))
5871 </MACRO>
5872 <MACRO>
5873 <NAME>G_OBJECT_CLASS</NAME>
5874 #define G_OBJECT_CLASS(class) (G_IS_OBJECT_CLASS (class) ? ((GObjectClass*) (class)) : \
5875 G_TYPE_CHECK_CLASS_CAST ((class), G_TYPE_OBJECT, GObjectClass))
5876 </MACRO>
5877 <MACRO>
5878 <NAME>G_IS_OBJECT</NAME>
5879 #define G_IS_OBJECT(object) (((GObject*) (object)) != NULL && \
5880 G_IS_OBJECT_CLASS (((GTypeInstance*) (object))->g_class))
5881 </MACRO>
5882 <MACRO>
5883 <NAME>G_IS_OBJECT_CLASS</NAME>
5884 #define G_IS_OBJECT_CLASS(class) (((GTypeClass*) (class)) != NULL && \
5885 G_TYPE_IS_OBJECT (((GTypeClass*) (class))->g_type))
5886 </MACRO>
5887 <MACRO>
5888 <NAME>G_OBJECT_GET_CLASS</NAME>
5889 #define G_OBJECT_GET_CLASS(object) (G_TYPE_INSTANCE_GET_CLASS ((object), G_TYPE_OBJECT, GObjectClass))
5890 </MACRO>
5891 <MACRO>
5892 <NAME>G_OBJECT_TYPE</NAME>
5893 #define G_OBJECT_TYPE(object) (G_TYPE_FROM_INSTANCE (object))
5894 </MACRO>
5895 <MACRO>
5896 <NAME>G_OBJECT_TYPE_NAME</NAME>
5897 #define G_OBJECT_TYPE_NAME(object) (g_type_name (G_OBJECT_TYPE (object)))
5898 </MACRO>
5899 <MACRO>
5900 <NAME>G_OBJECT_CLASS_TYPE</NAME>
5901 #define G_OBJECT_CLASS_TYPE(class) (G_TYPE_FROM_CLASS (class))
5902 </MACRO>
5903 <MACRO>
5904 <NAME>G_OBJECT_CLASS_NAME</NAME>
5905 #define G_OBJECT_CLASS_NAME(class) (g_type_name (G_OBJECT_CLASS_TYPE (class)))
5906 </MACRO>
5907 <MACRO>
5908 <NAME>G_IS_VALUE_OBJECT</NAME>
5909 #define G_IS_VALUE_OBJECT(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_OBJECT))
5910 </MACRO>
5911 <MACRO>
5912 <NAME>G_NOTIFY_PRIORITY</NAME>
5913 #define G_NOTIFY_PRIORITY (G_PRIORITY_HIGH_IDLE + 20)
5914 </MACRO>
5915 <STRUCT>
5916 <NAME>GObject</NAME>
5917 </STRUCT>
5918 <STRUCT>
5919 <NAME>GObjectClass</NAME>
5920 </STRUCT>
5921 <USER_FUNCTION>
5922 <NAME>GObjectGetParamFunc</NAME>
5923 <RETURNS>void </RETURNS>
5924 GObject *object,
5925 guint param_id,
5926 GValue *value,
5927 GParamSpec *pspec,
5928 const gchar *trailer
5929 </USER_FUNCTION>
5930 <USER_FUNCTION>
5931 <NAME>GObjectSetParamFunc</NAME>
5932 <RETURNS>void </RETURNS>
5933 GObject *object,
5934 guint param_id,
5935 GValue *value,
5936 GParamSpec *pspec,
5937 const gchar *trailer
5938 </USER_FUNCTION>
5939 <USER_FUNCTION>
5940 <NAME>GObjectFinalizeFunc</NAME>
5941 <RETURNS>void </RETURNS>
5942 GObject *object
5943 </USER_FUNCTION>
5944 <STRUCT>
5945 <NAME>GObject</NAME>
5946 struct GObject
5947 {
5948 GTypeInstance g_type_instance;
5950 /*< private >*/
5951 guint ref_count;
5952 GData *qdata;
5953 };
5954 </STRUCT>
5955 <FUNCTION>
5956 <NAME>g_object_class_install_param</NAME>
5957 <RETURNS>void </RETURNS>
5958 GObjectClass *oclass,guint param_id,GParamSpec *pspec
5959 </FUNCTION>
5960 <FUNCTION>
5961 <NAME>g_object_class_find_param_spec</NAME>
5962 <RETURNS>GParamSpec *</RETURNS>
5963 GObjectClass *oclass,const gchar *param_name
5964 </FUNCTION>
5965 <FUNCTION>
5966 <NAME>g_object_new</NAME>
5967 <RETURNS>gpointer </RETURNS>
5968 GType object_type,const gchar *first_param_name,...
5969 </FUNCTION>
5970 <FUNCTION>
5971 <NAME>g_object_new_valist</NAME>
5972 <RETURNS>gpointer </RETURNS>
5973 GType object_type,const gchar *first_param_name,va_list var_args
5974 </FUNCTION>
5975 <FUNCTION>
5976 <NAME>g_object_set</NAME>
5977 <RETURNS>void </RETURNS>
5978 GObject *object,const gchar *first_param_name,...
5979 </FUNCTION>
5980 <FUNCTION>
5981 <NAME>g_object_get</NAME>
5982 <RETURNS>void </RETURNS>
5983 GObject *object,const gchar *first_param_name,...
5984 </FUNCTION>
5985 <FUNCTION>
5986 <NAME>g_object_set_valist</NAME>
5987 <RETURNS>void </RETURNS>
5988 GObject *object,const gchar *first_param_name,va_list var_args
5989 </FUNCTION>
5990 <FUNCTION>
5991 <NAME>g_object_get_valist</NAME>
5992 <RETURNS>void </RETURNS>
5993 GObject *object,const gchar *first_param_name,va_list var_args
5994 </FUNCTION>
5995 <FUNCTION>
5996 <NAME>g_object_set_param</NAME>
5997 <RETURNS>void </RETURNS>
5998 GObject *object,const gchar *param_name,const GValue *value
5999 </FUNCTION>
6000 <FUNCTION>
6001 <NAME>g_object_get_param</NAME>
6002 <RETURNS>void </RETURNS>
6003 GObject *object,const gchar *param_name,GValue *value
6004 </FUNCTION>
6005 <FUNCTION>
6006 <NAME>g_object_queue_param_changed</NAME>
6007 <RETURNS>void </RETURNS>
6008 GObject *object,const gchar *param_name
6009 </FUNCTION>
6010 <FUNCTION>
6011 <NAME>g_object_ref</NAME>
6012 <RETURNS>GObject *</RETURNS>
6013 GObject *object
6014 </FUNCTION>
6015 <FUNCTION>
6016 <NAME>g_object_unref</NAME>
6017 <RETURNS>void </RETURNS>
6018 GObject *object
6019 </FUNCTION>
6020 <FUNCTION>
6021 <NAME>g_object_get_qdata</NAME>
6022 <RETURNS>gpointer </RETURNS>
6023 GObject *object,GQuark quark
6024 </FUNCTION>
6025 <FUNCTION>
6026 <NAME>g_object_set_qdata</NAME>
6027 <RETURNS>void </RETURNS>
6028 GObject *object,GQuark quark,gpointer data
6029 </FUNCTION>
6030 <FUNCTION>
6031 <NAME>g_object_set_qdata_full</NAME>
6032 <RETURNS>void </RETURNS>
6033 GObject *object,GQuark quark,gpointer data,GDestroyNotify destroy
6034 </FUNCTION>
6035 <FUNCTION>
6036 <NAME>g_object_steal_qdata</NAME>
6037 <RETURNS>gpointer </RETURNS>
6038 GObject *object,GQuark quark
6039 </FUNCTION>
6040 <FUNCTION>
6041 <NAME>g_value_set_object</NAME>
6042 <RETURNS>void </RETURNS>
6043 GValue *value,GObject *v_object
6044 </FUNCTION>
6045 <FUNCTION>
6046 <NAME>g_value_get_object</NAME>
6047 <RETURNS>GObject *</RETURNS>
6048 GValue *value
6049 </FUNCTION>
6050 <FUNCTION>
6051 <NAME>g_value_dup_object</NAME>
6052 <RETURNS>GObject *</RETURNS>
6053 GValue *value
6054 </FUNCTION>
6055 <MACRO>
6056 <NAME>G_WARN_INVALID_PARAM_ID</NAME>
6057 #define G_WARN_INVALID_PARAM_ID(object, param_id, pspec) \
6058 G_STMT_START { \
6059 GObject *_object = (GObject*) (object); \
6060 GParamSpec *_pspec = (GParamSpec*) (pspec); \
6061 guint _param_id = (param_id); \
6062 g_warning ("%s: invalid parameter id %u for \"%s\" of type `%s' in `%s'", \
6063 G_STRLOC, \
6064 _param_id, \
6065 _pspec->name, \
6066 g_type_name (G_PARAM_SPEC_TYPE (_pspec)), \
6067 BSE_OBJECT_TYPE_NAME (_object)); \
6068 } G_STMT_END
6069 </MACRO>
6070 <MACRO>
6071 <NAME>G_TYPE_IS_PARAM</NAME>
6072 #define G_TYPE_IS_PARAM(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_PARAM)
6073 </MACRO>
6074 <MACRO>
6075 <NAME>G_PARAM_SPEC_TYPE</NAME>
6076 #define G_PARAM_SPEC_TYPE(pspec) (G_TYPE_FROM_INSTANCE (pspec))
6077 </MACRO>
6078 <MACRO>
6079 <NAME>G_PARAM_SPEC_TYPE_NAME</NAME>
6080 #define G_PARAM_SPEC_TYPE_NAME(pspec) (g_type_name (G_PARAM_SPEC_TYPE (pspec)))
6081 </MACRO>
6082 <MACRO>
6083 <NAME>G_PARAM_SPEC</NAME>
6084 #define G_PARAM_SPEC(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM, GParamSpec))
6085 </MACRO>
6086 <MACRO>
6087 <NAME>G_IS_PARAM_SPEC</NAME>
6088 #define G_IS_PARAM_SPEC(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM))
6089 </MACRO>
6090 <MACRO>
6091 <NAME>G_PARAM_SPEC_GET_CLASS</NAME>
6092 #define G_PARAM_SPEC_GET_CLASS(pspec) (G_TYPE_INSTANCE_GET_CLASS ((pspec), G_TYPE_PARAM, GParamSpecClass))
6093 </MACRO>
6094 <MACRO>
6095 <NAME>G_IS_PARAM_VALUE</NAME>
6096 #define G_IS_PARAM_VALUE(pspec, value) (g_type_is_a (G_VALUE_TYPE (value), G_PARAM_SPEC_VALUE_TYPE (pspec))) /* FIXME */
6097 </MACRO>
6098 <MACRO>
6099 <NAME>G_PARAM_SPEC_VALUE_TYPE</NAME>
6100 #define G_PARAM_SPEC_VALUE_TYPE(pspec) (G_PARAM_SPEC_GET_CLASS (pspec)->value_type)
6101 </MACRO>
6102 <ENUM>
6103 <NAME>GParamFlags</NAME>
6104 typedef enum
6105 {
6106 G_PARAM_READABLE = 1 << 0,
6107 G_PARAM_WRITABLE = 1 << 1,
6108 G_PARAM_MASK = 0x000f,
6109 /* bits in the range 0xfff0 are reserved for 3rd party usage */
6110 G_PARAM_USER_MASK = 0xfff0
6111 } GParamFlags;
6112 </ENUM>
6113 <STRUCT>
6114 <NAME>GParamSpecClass</NAME>
6115 </STRUCT>
6116 <STRUCT>
6117 <NAME>GParamSpec</NAME>
6118 </STRUCT>
6119 <STRUCT>
6120 <NAME>GParamSpec</NAME>
6121 struct GParamSpec
6122 {
6123 GTypeInstance g_instance;
6125 gchar *name;
6126 gchar *nick;
6127 gchar *blurb;
6128 GParamFlags flags;
6130 /*< private >*/
6131 GType owner_type;
6132 GData *qdata;
6133 guint ref_count;
6134 };
6135 </STRUCT>
6136 <FUNCTION>
6137 <NAME>g_param_spec_ref</NAME>
6138 <RETURNS>GParamSpec *</RETURNS>
6139 GParamSpec *pspec
6140 </FUNCTION>
6141 <FUNCTION>
6142 <NAME>g_param_spec_unref</NAME>
6143 <RETURNS>void </RETURNS>
6144 GParamSpec *pspec
6145 </FUNCTION>
6146 <FUNCTION>
6147 <NAME>g_param_spec_get_qdata</NAME>
6148 <RETURNS>gpointer </RETURNS>
6149 GParamSpec *pspec,GQuark quark
6150 </FUNCTION>
6151 <FUNCTION>
6152 <NAME>g_param_spec_set_qdata</NAME>
6153 <RETURNS>void </RETURNS>
6154 GParamSpec *pspec,GQuark quark,gpointer data
6155 </FUNCTION>
6156 <FUNCTION>
6157 <NAME>g_param_spec_set_qdata_full</NAME>
6158 <RETURNS>void </RETURNS>
6159 GParamSpec *pspec,GQuark quark,gpointer data,GDestroyNotify destroy
6160 </FUNCTION>
6161 <FUNCTION>
6162 <NAME>g_param_spec_steal_qdata</NAME>
6163 <RETURNS>gpointer </RETURNS>
6164 GParamSpec *pspec,GQuark quark
6165 </FUNCTION>
6166 <FUNCTION>
6167 <NAME>g_param_value_set_default</NAME>
6168 <RETURNS>void </RETURNS>
6169 GParamSpec *pspec,GValue *value
6170 </FUNCTION>
6171 <FUNCTION>
6172 <NAME>g_param_value_defaults</NAME>
6173 <RETURNS>gboolean </RETURNS>
6174 GParamSpec *pspec,GValue *value
6175 </FUNCTION>
6176 <FUNCTION>
6177 <NAME>g_param_value_validate</NAME>
6178 <RETURNS>gboolean </RETURNS>
6179 GParamSpec *pspec,GValue *value
6180 </FUNCTION>
6181 <FUNCTION>
6182 <NAME>g_param_values_cmp</NAME>
6183 <RETURNS>gint </RETURNS>
6184 GParamSpec *pspec,const GValue *value1,const GValue *value2
6185 </FUNCTION>
6186 <FUNCTION>
6187 <NAME>g_param_spec_internal</NAME>
6188 <RETURNS>gpointer </RETURNS>
6189 GType param_type,const gchar *name,const gchar *nick,const gchar *blurb,GParamFlags flags
6190 </FUNCTION>
6191 <FUNCTION>
6192 <NAME>g_param_spec_hash_table_new</NAME>
6193 <RETURNS>GHashTable *</RETURNS>
6194 void
6195 </FUNCTION>
6196 <FUNCTION>
6197 <NAME>g_param_spec_hash_table_insert</NAME>
6198 <RETURNS>void </RETURNS>
6199 GHashTable *hash_table,GParamSpec *pspec,GType owner_type
6200 </FUNCTION>
6201 <FUNCTION>
6202 <NAME>g_param_spec_hash_table_remove</NAME>
6203 <RETURNS>void </RETURNS>
6204 GHashTable *hash_table,GParamSpec *pspec
6205 </FUNCTION>
6206 <FUNCTION>
6207 <NAME>g_param_spec_hash_table_lookup</NAME>
6208 <RETURNS>GParamSpec *</RETURNS>
6209 GHashTable *hash_table,const gchar *param_name,GType owner_type,gboolean try_ancestors,const gchar **trailer
6210 </FUNCTION>
6211 <MACRO>
6212 <NAME>G_IS_PARAM_SPEC_CHAR</NAME>
6213 #define G_IS_PARAM_SPEC_CHAR(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_CHAR))
6214 </MACRO>
6215 <MACRO>
6216 <NAME>G_PARAM_SPEC_CHAR</NAME>
6217 #define G_PARAM_SPEC_CHAR(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_CHAR, GParamSpecChar))
6218 </MACRO>
6219 <MACRO>
6220 <NAME>G_IS_PARAM_SPEC_UCHAR</NAME>
6221 #define G_IS_PARAM_SPEC_UCHAR(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UCHAR))
6222 </MACRO>
6223 <MACRO>
6224 <NAME>G_PARAM_SPEC_UCHAR</NAME>
6225 #define G_PARAM_SPEC_UCHAR(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UCHAR, GParamSpecUChar))
6226 </MACRO>
6227 <MACRO>
6228 <NAME>G_IS_PARAM_SPEC_BOOLEAN</NAME>
6229 #define G_IS_PARAM_SPEC_BOOLEAN(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_BOOLEAN))
6230 </MACRO>
6231 <MACRO>
6232 <NAME>G_PARAM_SPEC_BOOLEAN</NAME>
6233 #define G_PARAM_SPEC_BOOLEAN(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_BOOLEAN, GParamSpecBoolean))
6234 </MACRO>
6235 <MACRO>
6236 <NAME>G_IS_PARAM_SPEC_INT</NAME>
6237 #define G_IS_PARAM_SPEC_INT(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_INT))
6238 </MACRO>
6239 <MACRO>
6240 <NAME>G_PARAM_SPEC_INT</NAME>
6241 #define G_PARAM_SPEC_INT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_INT, GParamSpecInt))
6242 </MACRO>
6243 <MACRO>
6244 <NAME>G_IS_PARAM_SPEC_UINT</NAME>
6245 #define G_IS_PARAM_SPEC_UINT(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_UINT))
6246 </MACRO>
6247 <MACRO>
6248 <NAME>G_PARAM_SPEC_UINT</NAME>
6249 #define G_PARAM_SPEC_UINT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_UINT, GParamSpecUInt))
6250 </MACRO>
6251 <MACRO>
6252 <NAME>G_IS_PARAM_SPEC_LONG</NAME>
6253 #define G_IS_PARAM_SPEC_LONG(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_LONG))
6254 </MACRO>
6255 <MACRO>
6256 <NAME>G_PARAM_SPEC_LONG</NAME>
6257 #define G_PARAM_SPEC_LONG(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_LONG, GParamSpecLong))
6258 </MACRO>
6259 <MACRO>
6260 <NAME>G_IS_PARAM_SPEC_ULONG</NAME>
6261 #define G_IS_PARAM_SPEC_ULONG(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_ULONG))
6262 </MACRO>
6263 <MACRO>
6264 <NAME>G_PARAM_SPEC_ULONG</NAME>
6265 #define G_PARAM_SPEC_ULONG(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_ULONG, GParamSpecULong))
6266 </MACRO>
6267 <MACRO>
6268 <NAME>G_IS_PARAM_SPEC_ENUM</NAME>
6269 #define G_IS_PARAM_SPEC_ENUM(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_ENUM))
6270 </MACRO>
6271 <MACRO>
6272 <NAME>G_PARAM_SPEC_ENUM</NAME>
6273 #define G_PARAM_SPEC_ENUM(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_ENUM, GParamSpecEnum))
6274 </MACRO>
6275 <MACRO>
6276 <NAME>G_IS_PARAM_SPEC_FLAGS</NAME>
6277 #define G_IS_PARAM_SPEC_FLAGS(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_FLAGS))
6278 </MACRO>
6279 <MACRO>
6280 <NAME>G_PARAM_SPEC_FLAGS</NAME>
6281 #define G_PARAM_SPEC_FLAGS(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_FLAGS, GParamSpecFlags))
6282 </MACRO>
6283 <MACRO>
6284 <NAME>G_IS_PARAM_SPEC_FLOAT</NAME>
6285 #define G_IS_PARAM_SPEC_FLOAT(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_FLOAT))
6286 </MACRO>
6287 <MACRO>
6288 <NAME>G_PARAM_SPEC_FLOAT</NAME>
6289 #define G_PARAM_SPEC_FLOAT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_FLOAT, GParamSpecFloat))
6290 </MACRO>
6291 <MACRO>
6292 <NAME>G_IS_PARAM_SPEC_DOUBLE</NAME>
6293 #define G_IS_PARAM_SPEC_DOUBLE(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_DOUBLE))
6294 </MACRO>
6295 <MACRO>
6296 <NAME>G_PARAM_SPEC_DOUBLE</NAME>
6297 #define G_PARAM_SPEC_DOUBLE(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_DOUBLE, GParamSpecDouble))
6298 </MACRO>
6299 <MACRO>
6300 <NAME>G_IS_PARAM_SPEC_STRING</NAME>
6301 #define G_IS_PARAM_SPEC_STRING(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_STRING))
6302 </MACRO>
6303 <MACRO>
6304 <NAME>G_PARAM_SPEC_STRING</NAME>
6305 #define G_PARAM_SPEC_STRING(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_STRING, GParamSpecString))
6306 </MACRO>
6307 <MACRO>
6308 <NAME>G_IS_PARAM_SPEC_OBJECT</NAME>
6309 #define G_IS_PARAM_SPEC_OBJECT(pspec) (G_TYPE_CHECK_INSTANCE_TYPE ((pspec), G_TYPE_PARAM_OBJECT))
6310 </MACRO>
6311 <MACRO>
6312 <NAME>G_PARAM_SPEC_OBJECT</NAME>
6313 #define G_PARAM_SPEC_OBJECT(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), G_TYPE_PARAM_OBJECT, GParamSpecObject))
6314 </MACRO>
6315 <STRUCT>
6316 <NAME>GParamSpecChar</NAME>
6317 </STRUCT>
6318 <STRUCT>
6319 <NAME>GParamSpecUChar</NAME>
6320 </STRUCT>
6321 <STRUCT>
6322 <NAME>GParamSpecBoolean</NAME>
6323 </STRUCT>
6324 <STRUCT>
6325 <NAME>GParamSpecInt</NAME>
6326 </STRUCT>
6327 <STRUCT>
6328 <NAME>GParamSpecUInt</NAME>
6329 </STRUCT>
6330 <STRUCT>
6331 <NAME>GParamSpecLong</NAME>
6332 </STRUCT>
6333 <STRUCT>
6334 <NAME>GParamSpecULong</NAME>
6335 </STRUCT>
6336 <STRUCT>
6337 <NAME>GParamSpecEnum</NAME>
6338 </STRUCT>
6339 <STRUCT>
6340 <NAME>GParamSpecFlags</NAME>
6341 </STRUCT>
6342 <STRUCT>
6343 <NAME>GParamSpecFloat</NAME>
6344 </STRUCT>
6345 <STRUCT>
6346 <NAME>GParamSpecDouble</NAME>
6347 </STRUCT>
6348 <STRUCT>
6349 <NAME>GParamSpecString</NAME>
6350 </STRUCT>
6351 <STRUCT>
6352 <NAME>GParamSpecObject</NAME>
6353 </STRUCT>
6354 <STRUCT>
6355 <NAME>GParamSpecChar</NAME>
6356 struct GParamSpecChar
6357 {
6358 GParamSpec parent_instance;
6360 gint8 minimum;
6361 gint8 maximum;
6362 gint8 default_value;
6363 };
6364 </STRUCT>
6365 <STRUCT>
6366 <NAME>GParamSpecUChar</NAME>
6367 struct GParamSpecUChar
6368 {
6369 GParamSpec parent_instance;
6371 guint8 minimum;
6372 guint8 maximum;
6373 guint8 default_value;
6374 };
6375 </STRUCT>
6376 <STRUCT>
6377 <NAME>GParamSpecBoolean</NAME>
6378 struct GParamSpecBoolean
6379 {
6380 GParamSpec parent_instance;
6382 gboolean default_value;
6383 };
6384 </STRUCT>
6385 <STRUCT>
6386 <NAME>GParamSpecInt</NAME>
6387 struct GParamSpecInt
6388 {
6389 GParamSpec parent_instance;
6391 gint minimum;
6392 gint maximum;
6393 gint default_value;
6394 };
6395 </STRUCT>
6396 <STRUCT>
6397 <NAME>GParamSpecUInt</NAME>
6398 struct GParamSpecUInt
6399 {
6400 GParamSpec parent_instance;
6402 guint minimum;
6403 guint maximum;
6404 guint default_value;
6405 };
6406 </STRUCT>
6407 <STRUCT>
6408 <NAME>GParamSpecLong</NAME>
6409 struct GParamSpecLong
6410 {
6411 GParamSpec parent_instance;
6413 glong minimum;
6414 glong maximum;
6415 glong default_value;
6416 };
6417 </STRUCT>
6418 <STRUCT>
6419 <NAME>GParamSpecULong</NAME>
6420 struct GParamSpecULong
6421 {
6422 GParamSpec parent_instance;
6424 gulong minimum;
6425 gulong maximum;
6426 gulong default_value;
6427 };
6428 </STRUCT>
6429 <STRUCT>
6430 <NAME>GParamSpecEnum</NAME>
6431 struct GParamSpecEnum
6432 {
6433 GParamSpec parent_instance;
6435 GEnumClass *enum_class;
6436 glong default_value;
6437 };
6438 </STRUCT>
6439 <STRUCT>
6440 <NAME>GParamSpecFlags</NAME>
6441 struct GParamSpecFlags
6442 {
6443 GParamSpec parent_instance;
6445 GFlagsClass *flags_class;
6446 gulong default_value;
6447 };
6448 </STRUCT>
6449 <STRUCT>
6450 <NAME>GParamSpecFloat</NAME>
6451 struct GParamSpecFloat
6452 {
6453 GParamSpec parent_instance;
6455 gfloat minimum;
6456 gfloat maximum;
6457 gfloat default_value;
6458 gfloat epsilon;
6459 };
6460 </STRUCT>
6461 <STRUCT>
6462 <NAME>GParamSpecDouble</NAME>
6463 struct GParamSpecDouble
6464 {
6465 GParamSpec parent_instance;
6467 gdouble minimum;
6468 gdouble maximum;
6469 gdouble default_value;
6470 gdouble epsilon;
6471 };
6472 </STRUCT>
6473 <STRUCT>
6474 <NAME>GParamSpecString</NAME>
6475 struct GParamSpecString
6476 {
6477 GParamSpec parent_instance;
6479 gchar *default_value;
6480 gchar *cset_first;
6481 gchar *cset_nth;
6482 gchar substitutor;
6483 guint null_fold_if_empty : 1;
6484 guint ensure_non_null : 1;
6485 };
6486 </STRUCT>
6487 <STRUCT>
6488 <NAME>GParamSpecObject</NAME>
6489 struct GParamSpecObject
6490 {
6491 GParamSpec parent_instance;
6493 GType object_type;
6494 };
6495 </STRUCT>
6496 <FUNCTION>
6497 <NAME>g_param_spec_char</NAME>
6498 <RETURNS>GParamSpec *</RETURNS>
6499 const gchar *name,const gchar *nick,const gchar *blurb,gint8 minimum,gint8 maximum,gint8 default_value,GParamFlags flags
6500 </FUNCTION>
6501 <FUNCTION>
6502 <NAME>g_param_spec_uchar</NAME>
6503 <RETURNS>GParamSpec *</RETURNS>
6504 const gchar *name,const gchar *nick,const gchar *blurb,guint8 minimum,guint8 maximum,guint8 default_value,GParamFlags flags
6505 </FUNCTION>
6506 <FUNCTION>
6507 <NAME>g_param_spec_boolean</NAME>
6508 <RETURNS>GParamSpec *</RETURNS>
6509 const gchar *name,const gchar *nick,const gchar *blurb,gboolean default_value,GParamFlags flags
6510 </FUNCTION>
6511 <FUNCTION>
6512 <NAME>g_param_spec_int</NAME>
6513 <RETURNS>GParamSpec *</RETURNS>
6514 const gchar *name,const gchar *nick,const gchar *blurb,gint minimum,gint maximum,gint default_value,GParamFlags flags
6515 </FUNCTION>
6516 <FUNCTION>
6517 <NAME>g_param_spec_uint</NAME>
6518 <RETURNS>GParamSpec *</RETURNS>
6519 const gchar *name,const gchar *nick,const gchar *blurb,guint minimum,guint maximum,guint default_value,GParamFlags flags
6520 </FUNCTION>
6521 <FUNCTION>
6522 <NAME>g_param_spec_long</NAME>
6523 <RETURNS>GParamSpec *</RETURNS>
6524 const gchar *name,const gchar *nick,const gchar *blurb,glong minimum,glong maximum,glong default_value,GParamFlags flags
6525 </FUNCTION>
6526 <FUNCTION>
6527 <NAME>g_param_spec_ulong</NAME>
6528 <RETURNS>GParamSpec *</RETURNS>
6529 const gchar *name,const gchar *nick,const gchar *blurb,gulong minimum,gulong maximum,gulong default_value,GParamFlags flags
6530 </FUNCTION>
6531 <FUNCTION>
6532 <NAME>g_param_spec_enum</NAME>
6533 <RETURNS>GParamSpec *</RETURNS>
6534 const gchar *name,const gchar *nick,const gchar *blurb,GType enum_type,gint default_value,GParamFlags flags
6535 </FUNCTION>
6536 <FUNCTION>
6537 <NAME>g_param_spec_flags</NAME>
6538 <RETURNS>GParamSpec *</RETURNS>
6539 const gchar *name,const gchar *nick,const gchar *blurb,GType flags_type,guint default_value,GParamFlags flags
6540 </FUNCTION>
6541 <FUNCTION>
6542 <NAME>g_param_spec_float</NAME>
6543 <RETURNS>GParamSpec *</RETURNS>
6544 const gchar *name,const gchar *nick,const gchar *blurb,gfloat minimum,gfloat maximum,gfloat default_value,GParamFlags flags
6545 </FUNCTION>
6546 <FUNCTION>
6547 <NAME>g_param_spec_double</NAME>
6548 <RETURNS>GParamSpec *</RETURNS>
6549 const gchar *name,const gchar *nick,const gchar *blurb,gdouble minimum,gdouble maximum,gdouble default_value,GParamFlags flags
6550 </FUNCTION>
6551 <FUNCTION>
6552 <NAME>g_param_spec_string</NAME>
6553 <RETURNS>GParamSpec *</RETURNS>
6554 const gchar *name,const gchar *nick,const gchar *blurb,const gchar *default_value,GParamFlags flags
6555 </FUNCTION>
6556 <FUNCTION>
6557 <NAME>g_param_spec_string_c</NAME>
6558 <RETURNS>GParamSpec *</RETURNS>
6559 const gchar *name,const gchar *nick,const gchar *blurb,const gchar *default_value,GParamFlags flags
6560 </FUNCTION>
6561 <FUNCTION>
6562 <NAME>g_param_spec_object</NAME>
6563 <RETURNS>GParamSpec *</RETURNS>
6564 const gchar *name,const gchar *nick,const gchar *blurb,GType object_type,GParamFlags flags
6565 </FUNCTION>
6566 <VARIABLE>
6567 <NAME>g_log_domain_gobject</NAME>
6568 extern const char *g_log_domain_gobject;
6569 </VARIABLE>
6570 <MACRO>
6571 <NAME>G_TYPE_FUNDAMENTAL</NAME>
6572 #define G_TYPE_FUNDAMENTAL(type) ((type) & 0xff)
6573 </MACRO>
6574 <MACRO>
6575 <NAME>G_TYPE_FUNDAMENTAL_MAX</NAME>
6576 #define G_TYPE_FUNDAMENTAL_MAX (0xff)
6577 </MACRO>
6578 <MACRO>
6579 <NAME>G_TYPE_DERIVE_ID</NAME>
6580 #define G_TYPE_DERIVE_ID(ptype, branch_seqno) (G_TYPE_FUNDAMENTAL (ptype) | ((branch_seqno) << 8))
6581 </MACRO>
6582 <MACRO>
6583 <NAME>G_TYPE_BRANCH_SEQNO</NAME>
6584 #define G_TYPE_BRANCH_SEQNO(type) ((type) >> 8)
6585 </MACRO>
6586 <MACRO>
6587 <NAME>G_TYPE_FUNDAMENTAL_LAST</NAME>
6588 #define G_TYPE_FUNDAMENTAL_LAST ((GType) g_type_fundamental_last ())
6589 </MACRO>
6590 <ENUM>
6591 <NAME>GTypeFundamentals</NAME>
6592 typedef enum /*< skip >*/
6593 {
6594 /* standard types, introduced by g_type_init() */
6595 G_TYPE_INVALID,
6596 G_TYPE_NONE,
6597 G_TYPE_INTERFACE,
6599 /* GLib type ids */
6600 G_TYPE_CHAR,
6601 G_TYPE_UCHAR,
6602 G_TYPE_BOOLEAN,
6603 G_TYPE_INT,
6604 G_TYPE_UINT,
6605 G_TYPE_LONG,
6606 G_TYPE_ULONG,
6607 G_TYPE_ENUM,
6608 G_TYPE_FLAGS,
6609 G_TYPE_FLOAT,
6610 G_TYPE_DOUBLE,
6611 G_TYPE_STRING,
6612 G_TYPE_PARAM,
6613 G_TYPE_OBJECT,
6615 /* the following reserved ids should vanish soon */
6616 G_TYPE_GTK_BOXED,
6617 G_TYPE_GTK_POINTER,
6618 G_TYPE_GTK_SIGNAL,
6620 /* reserved fundamental type ids,
6621 * mail gtk-devel-list@redhat.com for reservations
6622 */
6623 G_TYPE_BSE_PROCEDURE,
6624 G_TYPE_BSE_TIME,
6625 G_TYPE_BSE_NOTE,
6626 G_TYPE_BSE_DOTS,
6627 G_TYPE_GLE_GOBJECT,
6629 G_TYPE_LAST_RESERVED_FUNDAMENTAL,
6631 /* derived type ids */
6632 /* FIXME: G_TYPE_PARAM_INTERFACE */
6633 G_TYPE_PARAM_CHAR = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 1),
6634 G_TYPE_PARAM_UCHAR = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 2),
6635 G_TYPE_PARAM_BOOLEAN = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 3),
6636 G_TYPE_PARAM_INT = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 4),
6637 G_TYPE_PARAM_UINT = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 5),
6638 G_TYPE_PARAM_LONG = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 6),
6639 G_TYPE_PARAM_ULONG = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 7),
6640 G_TYPE_PARAM_ENUM = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 8),
6641 G_TYPE_PARAM_FLAGS = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 9),
6642 G_TYPE_PARAM_FLOAT = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 10),
6643 G_TYPE_PARAM_DOUBLE = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 11),
6644 G_TYPE_PARAM_STRING = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 12),
6645 /* FIXME: G_TYPE_PARAM_PARAM */
6646 G_TYPE_PARAM_OBJECT = G_TYPE_DERIVE_ID (G_TYPE_PARAM, 13)
6647 } GTypeFundamentals;
6648 </ENUM>
6649 <MACRO>
6650 <NAME>G_TYPE_IS_INTERFACE</NAME>
6651 #define G_TYPE_IS_INTERFACE(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_INTERFACE)
6652 </MACRO>
6653 <MACRO>
6654 <NAME>G_TYPE_IS_CLASSED</NAME>
6655 #define G_TYPE_IS_CLASSED(type) (g_type_check_flags ((type), G_TYPE_FLAG_CLASSED))
6656 </MACRO>
6657 <MACRO>
6658 <NAME>G_TYPE_IS_INSTANTIATABLE</NAME>
6659 #define G_TYPE_IS_INSTANTIATABLE(type) (g_type_check_flags ((type), G_TYPE_FLAG_INSTANTIATABLE))
6660 </MACRO>
6661 <MACRO>
6662 <NAME>G_TYPE_IS_DERIVABLE</NAME>
6663 #define G_TYPE_IS_DERIVABLE(type) (g_type_check_flags ((type), G_TYPE_FLAG_DERIVABLE))
6664 </MACRO>
6665 <MACRO>
6666 <NAME>G_TYPE_IS_DEEP_DERIVABLE</NAME>
6667 #define G_TYPE_IS_DEEP_DERIVABLE(type) (g_type_check_flags ((type), G_TYPE_FLAG_DEEP_DERIVABLE))
6668 </MACRO>
6669 <MACRO>
6670 <NAME>G_TYPE_IS_PARAM</NAME>
6671 #define G_TYPE_IS_PARAM(type) (G_TYPE_FUNDAMENTAL (type) == G_TYPE_PARAM)
6672 </MACRO>
6673 <TYPEDEF>
6674 <NAME>GType</NAME>
6675 typedef guint32 GType;
6676 </TYPEDEF>
6677 <STRUCT>
6678 <NAME>GValue</NAME>
6679 </STRUCT>
6680 <STRUCT>
6681 <NAME>GTypePlugin</NAME>
6682 </STRUCT>
6683 <STRUCT>
6684 <NAME>GTypePluginVTable</NAME>
6685 </STRUCT>
6686 <STRUCT>
6687 <NAME>GTypeClass</NAME>
6688 </STRUCT>
6689 <STRUCT>
6690 <NAME>GTypeInterface</NAME>
6691 </STRUCT>
6692 <STRUCT>
6693 <NAME>GTypeInstance</NAME>
6694 </STRUCT>
6695 <STRUCT>
6696 <NAME>GTypeInfo</NAME>
6697 </STRUCT>
6698 <STRUCT>
6699 <NAME>GTypeFundamentalInfo</NAME>
6700 </STRUCT>
6701 <STRUCT>
6702 <NAME>GInterfaceInfo</NAME>
6703 </STRUCT>
6704 <STRUCT>
6705 <NAME>GTypeValueTable</NAME>
6706 </STRUCT>
6707 <STRUCT>
6708 <NAME>GTypeInstance</NAME>
6709 struct GTypeInstance
6710 {
6711 /*< private >*/
6712 GTypeClass *g_class;
6713 };
6714 </STRUCT>
6715 <STRUCT>
6716 <NAME>GTypeInterface</NAME>
6717 struct GTypeInterface
6718 {
6719 /*< private >*/
6720 GType g_type; /* iface type */
6721 GType g_instance_type;
6722 };
6723 </STRUCT>
6724 <MACRO>
6725 <NAME>G_TYPE_CHECK_INSTANCE_CAST</NAME>
6726 #define G_TYPE_CHECK_INSTANCE_CAST(instance, g_type, c_type) (_G_TYPE_CIC ((instance), (g_type), c_type))
6727 </MACRO>
6728 <MACRO>
6729 <NAME>G_TYPE_CHECK_CLASS_CAST</NAME>
6730 #define G_TYPE_CHECK_CLASS_CAST(g_class, g_type, c_type) (_G_TYPE_CCC ((g_class), (g_type), c_type))
6731 </MACRO>
6732 <MACRO>
6733 <NAME>G_TYPE_CHECK_INSTANCE_TYPE</NAME>
6734 #define G_TYPE_CHECK_INSTANCE_TYPE(instance, g_type) (_G_TYPE_CIT ((instance), (g_type)))
6735 </MACRO>
6736 <MACRO>
6737 <NAME>G_TYPE_CHECK_CLASS_TYPE</NAME>
6738 #define G_TYPE_CHECK_CLASS_TYPE(g_class, g_type) (_G_TYPE_CCT ((g_class), (g_type)))
6739 </MACRO>
6740 <MACRO>
6741 <NAME>G_TYPE_INSTANCE_GET_CLASS</NAME>
6742 #define G_TYPE_INSTANCE_GET_CLASS(instance, g_type, c_type) (_G_TYPE_IGC ((instance), c_type))
6743 </MACRO>
6744 <MACRO>
6745 <NAME>G_TYPE_FROM_INSTANCE</NAME>
6746 #define G_TYPE_FROM_INSTANCE(instance) (G_TYPE_FROM_CLASS (((GTypeInstance*) (instance))->g_class))
6747 </MACRO>
6748 <MACRO>
6749 <NAME>G_TYPE_FROM_CLASS</NAME>
6750 #define G_TYPE_FROM_CLASS(g_class) (((GTypeClass*) (g_class))->g_type)
6751 </MACRO>
6752 <MACRO>
6753 <NAME>G_TYPE_FROM_INTERFACE</NAME>
6754 #define G_TYPE_FROM_INTERFACE(g_iface) (((GTypeInterface*) (g_iface))->g_type)
6755 </MACRO>
6756 <FUNCTION>
6757 <NAME>g_type_init</NAME>
6758 <RETURNS>void </RETURNS>
6759 void
6760 </FUNCTION>
6761 <FUNCTION>
6762 <NAME>g_type_name</NAME>
6763 <RETURNS>gchar *</RETURNS>
6764 GType type
6765 </FUNCTION>
6766 <FUNCTION>
6767 <NAME>g_type_qname</NAME>
6768 <RETURNS>GQuark </RETURNS>
6769 GType type
6770 </FUNCTION>
6771 <FUNCTION>
6772 <NAME>g_type_from_name</NAME>
6773 <RETURNS>GType </RETURNS>
6774 const gchar *name
6775 </FUNCTION>
6776 <FUNCTION>
6777 <NAME>g_type_parent</NAME>
6778 <RETURNS>GType </RETURNS>
6779 GType type
6780 </FUNCTION>
6781 <FUNCTION>
6782 <NAME>g_type_next_base</NAME>
6783 <RETURNS>GType </RETURNS>
6784 GType type,GType base_type
6785 </FUNCTION>
6786 <FUNCTION>
6787 <NAME>g_type_is_a</NAME>
6788 <RETURNS>gboolean </RETURNS>
6789 GType type,GType is_a_type
6790 </FUNCTION>
6791 <FUNCTION>
6792 <NAME>g_type_conforms_to</NAME>
6793 <RETURNS>gboolean </RETURNS>
6794 GType type,GType iface_type
6795 </FUNCTION>
6796 <FUNCTION>
6797 <NAME>g_type_fundamental_branch_last</NAME>
6798 <RETURNS>guint </RETURNS>
6799 GType type
6800 </FUNCTION>
6801 <FUNCTION>
6802 <NAME>g_type_class_ref</NAME>
6803 <RETURNS>gpointer </RETURNS>
6804 GType type
6805 </FUNCTION>
6806 <FUNCTION>
6807 <NAME>g_type_class_peek</NAME>
6808 <RETURNS>gpointer </RETURNS>
6809 GType type
6810 </FUNCTION>
6811 <FUNCTION>
6812 <NAME>g_type_class_unref</NAME>
6813 <RETURNS>void </RETURNS>
6814 gpointer g_class
6815 </FUNCTION>
6816 <FUNCTION>
6817 <NAME>g_type_class_peek_parent</NAME>
6818 <RETURNS>gpointer </RETURNS>
6819 gpointer g_class
6820 </FUNCTION>
6821 <FUNCTION>
6822 <NAME>g_type_interface_peek</NAME>
6823 <RETURNS>gpointer </RETURNS>
6824 gpointer instance_class,GType iface_type
6825 </FUNCTION>
6826 <FUNCTION>
6827 <NAME>g_type_children</NAME>
6828 <RETURNS>GType *</RETURNS>
6829 GType type,guint *n_children
6830 </FUNCTION>
6831 <FUNCTION>
6832 <NAME>g_type_interfaces</NAME>
6833 <RETURNS>GType *</RETURNS>
6834 GType type,guint *n_interfaces
6835 </FUNCTION>
6836 <FUNCTION>
6837 <NAME>g_type_set_qdata</NAME>
6838 <RETURNS>void </RETURNS>
6839 GType type,GQuark quark,gpointer data
6840 </FUNCTION>
6841 <FUNCTION>
6842 <NAME>g_type_get_qdata</NAME>
6843 <RETURNS>gpointer </RETURNS>
6844 GType type,GQuark quark
6845 </FUNCTION>
6846 <USER_FUNCTION>
6847 <NAME>GBaseInitFunc</NAME>
6848 <RETURNS>void </RETURNS>
6849 gpointer g_class
6850 </USER_FUNCTION>
6851 <USER_FUNCTION>
6852 <NAME>GBaseFinalizeFunc</NAME>
6853 <RETURNS>void </RETURNS>
6854 gpointer g_class
6855 </USER_FUNCTION>
6856 <USER_FUNCTION>
6857 <NAME>GClassInitFunc</NAME>
6858 <RETURNS>void </RETURNS>
6859 gpointer g_class,
6860 gpointer class_data
6861 </USER_FUNCTION>
6862 <USER_FUNCTION>
6863 <NAME>GClassFinalizeFunc</NAME>
6864 <RETURNS>void </RETURNS>
6865 gpointer g_class,
6866 gpointer class_data
6867 </USER_FUNCTION>
6868 <USER_FUNCTION>
6869 <NAME>GInstanceInitFunc</NAME>
6870 <RETURNS>void </RETURNS>
6871 GTypeInstance *instance,
6872 gpointer g_class
6873 </USER_FUNCTION>
6874 <USER_FUNCTION>
6875 <NAME>GInterfaceInitFunc</NAME>
6876 <RETURNS>void </RETURNS>
6877 gpointer g_iface,
6878 gpointer iface_data
6879 </USER_FUNCTION>
6880 <USER_FUNCTION>
6881 <NAME>GInterfaceFinalizeFunc</NAME>
6882 <RETURNS>void </RETURNS>
6883 gpointer g_iface,
6884 gpointer iface_data
6885 </USER_FUNCTION>
6886 <USER_FUNCTION>
6887 <NAME>GTypePluginRef</NAME>
6888 <RETURNS>void </RETURNS>
6889 GTypePlugin *plugin
6890 </USER_FUNCTION>
6891 <USER_FUNCTION>
6892 <NAME>GTypePluginUnRef</NAME>
6893 <RETURNS>void </RETURNS>
6894 GTypePlugin *plugin
6895 </USER_FUNCTION>
6896 <USER_FUNCTION>
6897 <NAME>GTypePluginFillTypeInfo</NAME>
6898 <RETURNS>void </RETURNS>
6899 GTypePlugin *plugin,
6900 GType g_type,
6901 GTypeInfo *info,
6902 GTypeValueTable *value_table
6903 </USER_FUNCTION>
6904 <USER_FUNCTION>
6905 <NAME>GTypePluginFillInterfaceInfo</NAME>
6906 <RETURNS>void </RETURNS>
6907 GTypePlugin *plugin,
6908 GType interface_type,
6909 GType instance_type,
6910 GInterfaceInfo *info
6911 </USER_FUNCTION>
6912 <USER_FUNCTION>
6913 <NAME>GTypeClassCacheFunc</NAME>
6914 <RETURNS>gboolean </RETURNS>
6915 gpointer cache_data,
6916 GTypeClass *g_class
6917 </USER_FUNCTION>
6918 <STRUCT>
6919 <NAME>GTypePlugin</NAME>
6920 struct GTypePlugin
6921 {
6922 GTypePluginVTable *vtable;
6923 };
6924 </STRUCT>
6925 <STRUCT>
6926 <NAME>GTypePluginVTable</NAME>
6927 struct GTypePluginVTable
6928 {
6929 GTypePluginRef plugin_ref;
6930 GTypePluginUnRef plugin_unref;
6931 GTypePluginFillTypeInfo complete_type_info;
6932 GTypePluginFillInterfaceInfo complete_interface_info;
6933 };
6934 </STRUCT>
6935 <ENUM>
6936 <NAME>GTypeFlags</NAME>
6937 typedef enum /*< skip >*/
6938 {
6939 G_TYPE_FLAG_CLASSED = (1 << 0),
6940 G_TYPE_FLAG_INSTANTIATABLE = (1 << 1),
6941 G_TYPE_FLAG_DERIVABLE = (1 << 2),
6942 G_TYPE_FLAG_DEEP_DERIVABLE = (1 << 3)
6943 } GTypeFlags;
6944 </ENUM>
6945 <STRUCT>
6946 <NAME>GTypeInfo</NAME>
6947 struct GTypeInfo
6948 {
6949 /* interface types, classed types, instantiated types */
6950 guint16 class_size;
6952 GBaseInitFunc base_init;
6953 GBaseFinalizeFunc base_finalize;
6955 /* classed types, instantiated types */
6956 GClassInitFunc class_init;
6957 GClassFinalizeFunc class_finalize;
6958 gconstpointer class_data;
6960 /* instantiated types */
6961 guint16 instance_size;
6962 guint16 n_preallocs;
6963 GInstanceInitFunc instance_init;
6965 /* value handling */
6966 const GTypeValueTable *value_table;
6967 };
6968 </STRUCT>
6969 <STRUCT>
6970 <NAME>GTypeFundamentalInfo</NAME>
6971 struct GTypeFundamentalInfo
6972 {
6973 GTypeFlags type_flags;
6974 };
6975 </STRUCT>
6976 <STRUCT>
6977 <NAME>GInterfaceInfo</NAME>
6978 struct GInterfaceInfo
6979 {
6980 GInterfaceInitFunc interface_init;
6981 GInterfaceFinalizeFunc interface_finalize;
6982 gpointer interface_data;
6983 };
6984 </STRUCT>
6985 <STRUCT>
6986 <NAME>GTypeValueTable</NAME>
6987 struct GTypeValueTable
6988 {
6989 void (*value_init) (GValue *value);
6990 void (*value_free) (GValue *value);
6991 void (*value_copy) (const GValue *src_value,
6992 GValue *dest_value);
6993 /* varargs functionality (optional) */
6994 guint collect_type;
6995 gchar* (*collect_value) (GValue *value,
6996 guint nth_value,
6997 GType *collect_type,
6998 GTypeCValue *collect_value);
6999 guint lcopy_type;
7000 gchar* (*lcopy_value) (const GValue *value,
7001 guint nth_value,
7002 GType *collect_type,
7003 GTypeCValue *collect_value);
7004 };
7005 </STRUCT>
7006 <FUNCTION>
7007 <NAME>g_type_register_static</NAME>
7008 <RETURNS>GType </RETURNS>
7009 GType parent_type,const gchar *type_name,const GTypeInfo *info
7010 </FUNCTION>
7011 <FUNCTION>
7012 <NAME>g_type_register_dynamic</NAME>
7013 <RETURNS>GType </RETURNS>
7014 GType parent_type,const gchar *type_name,GTypePlugin *plugin
7015 </FUNCTION>
7016 <FUNCTION>
7017 <NAME>g_type_register_fundamental</NAME>
7018 <RETURNS>GType </RETURNS>
7019 GType type_id,const gchar *type_name,const GTypeInfo *info,const GTypeFundamentalInfo *finfo
7020 </FUNCTION>
7021 <FUNCTION>
7022 <NAME>g_type_add_interface_static</NAME>
7023 <RETURNS>void </RETURNS>
7024 GType instance_type,GType interface_type,GInterfaceInfo *info
7025 </FUNCTION>
7026 <FUNCTION>
7027 <NAME>g_type_add_interface_dynamic</NAME>
7028 <RETURNS>void </RETURNS>
7029 GType instance_type,GType interface_type,GTypePlugin *plugin
7030 </FUNCTION>
7031 <FUNCTION>
7032 <NAME>g_type_class_is_a</NAME>
7033 <RETURNS>gboolean </RETURNS>
7034 GTypeClass *g_class,GType is_a_type
7035 </FUNCTION>
7036 <FUNCTION>
7037 <NAME>g_type_check_class_cast</NAME>
7038 <RETURNS>GTypeClass *</RETURNS>
7039 GTypeClass *g_class,GType is_a_type
7040 </FUNCTION>
7041 <FUNCTION>
7042 <NAME>g_type_check_instance_cast</NAME>
7043 <RETURNS>GTypeInstance *</RETURNS>
7044 GTypeInstance *instance,GType iface_type
7045 </FUNCTION>
7046 <FUNCTION>
7047 <NAME>g_type_instance_conforms_to</NAME>
7048 <RETURNS>gboolean </RETURNS>
7049 GTypeInstance *instance,GType iface_type
7050 </FUNCTION>
7051 <FUNCTION>
7052 <NAME>g_type_check_flags</NAME>
7053 <RETURNS>gboolean </RETURNS>
7054 GType type,GTypeFlags flags
7055 </FUNCTION>
7056 <FUNCTION>
7057 <NAME>g_type_create_instance</NAME>
7058 <RETURNS>GTypeInstance *</RETURNS>
7059 GType type
7060 </FUNCTION>
7061 <FUNCTION>
7062 <NAME>g_type_free_instance</NAME>
7063 <RETURNS>void </RETURNS>
7064 GTypeInstance *instance
7065 </FUNCTION>
7066 <FUNCTION>
7067 <NAME>g_type_value_table_peek</NAME>
7068 <RETURNS>GTypeValueTable *</RETURNS>
7069 GType type
7070 </FUNCTION>
7071 <FUNCTION>
7072 <NAME>g_type_add_class_cache_func</NAME>
7073 <RETURNS>void </RETURNS>
7074 gpointer cache_data,GTypeClassCacheFunc cache_func
7075 </FUNCTION>
7076 <FUNCTION>
7077 <NAME>g_type_remove_class_cache_func</NAME>
7078 <RETURNS>void </RETURNS>
7079 gpointer cache_data,GTypeClassCacheFunc cache_func
7080 </FUNCTION>
7081 <FUNCTION>
7082 <NAME>g_type_class_unref_uncached</NAME>
7083 <RETURNS>void </RETURNS>
7084 gpointer g_class
7085 </FUNCTION>
7086 <FUNCTION>
7087 <NAME>g_type_get_plugin</NAME>
7088 <RETURNS>GTypePlugin *</RETURNS>
7089 GType type
7090 </FUNCTION>
7091 <FUNCTION>
7092 <NAME>g_type_fundamental_last</NAME>
7093 <RETURNS>GType </RETURNS>
7094 void
7095 </FUNCTION>
7096 <MACRO>
7097 <NAME>G_TYPE_IS_VALUE</NAME>
7098 #define G_TYPE_IS_VALUE(type) (g_type_value_table_peek (type) != NULL)
7099 </MACRO>
7100 <MACRO>
7101 <NAME>G_IS_VALUE</NAME>
7102 #define G_IS_VALUE(value) (G_TYPE_IS_VALUE (G_VALUE_TYPE (value))) /* FIXME */
7103 </MACRO>
7104 <MACRO>
7105 <NAME>G_VALUE_TYPE</NAME>
7106 #define G_VALUE_TYPE(value) (G_TYPE_FROM_CLASS (value))
7107 </MACRO>
7108 <MACRO>
7109 <NAME>G_VALUE_TYPE_NAME</NAME>
7110 #define G_VALUE_TYPE_NAME(value) (g_type_name (G_VALUE_TYPE (value)))
7111 </MACRO>
7112 <USER_FUNCTION>
7113 <NAME>GValueExchange</NAME>
7114 <RETURNS>void </RETURNS>
7115 GValue *value1,
7116 GValue *value2
7117 </USER_FUNCTION>
7118 <STRUCT>
7119 <NAME>GValue</NAME>
7120 struct GValue
7121 {
7122 /*< private >*/
7123 GType g_type;
7125 /* public for GTypeValueTable methods */
7126 union {
7127 gint v_int;
7128 guint v_uint;
7129 glong v_long;
7130 gulong v_ulong;
7131 gfloat v_float;
7132 gdouble v_double;
7133 gpointer v_pointer;
7134 } data[4];
7135 };
7136 </STRUCT>
7137 <FUNCTION>
7138 <NAME>g_value_init</NAME>
7139 <RETURNS>void </RETURNS>
7140 GValue *value,GType g_type
7141 </FUNCTION>
7142 <FUNCTION>
7143 <NAME>g_value_copy</NAME>
7144 <RETURNS>void </RETURNS>
7145 const GValue *src_value,GValue *dest_value
7146 </FUNCTION>
7147 <FUNCTION>
7148 <NAME>g_value_convert</NAME>
7149 <RETURNS>gboolean </RETURNS>
7150 const GValue *src_value,GValue *dest_value
7151 </FUNCTION>
7152 <FUNCTION>
7153 <NAME>g_value_reset</NAME>
7154 <RETURNS>void </RETURNS>
7155 GValue *value
7156 </FUNCTION>
7157 <FUNCTION>
7158 <NAME>g_value_unset</NAME>
7159 <RETURNS>void </RETURNS>
7160 GValue *value
7161 </FUNCTION>
7162 <FUNCTION>
7163 <NAME>g_values_exchange</NAME>
7164 <RETURNS>gboolean </RETURNS>
7165 GValue *value1,GValue *value2
7166 </FUNCTION>
7167 <FUNCTION>
7168 <NAME>g_value_types_exchangable</NAME>
7169 <RETURNS>gboolean </RETURNS>
7170 GType value_type1,GType value_type2
7171 </FUNCTION>
7172 <FUNCTION>
7173 <NAME>g_value_register_exchange_func</NAME>
7174 <RETURNS>void </RETURNS>
7175 GType value_type1,GType value_type2,GValueExchange func
7176 </FUNCTION>
7177 <UNION>
7178 <NAME>GTypeCValue</NAME>
7179 union GTypeCValue
7180 {
7181 gint v_int;
7182 glong v_long;
7183 gdouble v_double;
7184 gpointer v_pointer;
7185 };
7186 </UNION>
7187 <MACRO>
7188 <NAME>G_VALUE_COLLECT</NAME>
7189 #define G_VALUE_COLLECT(value, var_args, __error) \
7190 G_STMT_START { \
7191 GValue *_value = (value); \
7192 GTypeValueTable *_vtable = g_type_value_table_peek (G_VALUE_TYPE (_value)); \
7193 gchar *_error_msg = NULL; \
7194 guint _collect_type = _vtable->collect_type; \
7195 guint _nth_value = 0; \
7196 \
7197 g_value_reset (_value); \
7198 while (_collect_type && !_error_msg) \
7199 { \
7200 GTypeCValue _cvalue; \
7201 \
7202 memset (&_cvalue, 0, sizeof (_cvalue)); \
7203 switch (_collect_type) \
7204 { \
7205 case G_VALUE_COLLECT_INT: \
7206 _cvalue.v_int = va_arg ((var_args), gint); \
7207 break; \
7208 case G_VALUE_COLLECT_LONG: \
7209 _cvalue.v_long = va_arg ((var_args), glong); \
7210 break; \
7211 case G_VALUE_COLLECT_DOUBLE: \
7212 _cvalue.v_double = va_arg ((var_args), gdouble); \
7213 break; \
7214 case G_VALUE_COLLECT_POINTER: \
7215 _cvalue.v_pointer = va_arg ((var_args), gpointer); \
7216 break; \
7217 default: \
7218 _error_msg = g_strdup_printf ("%s: invalid collect type (%d) used for %s", \
7219 G_STRLOC, \
7220 _collect_type, \
7221 "G_VALUE_COLLECT()"); \
7222 continue; \
7223 } \
7224 _error_msg = _vtable->collect_value (_value, \
7225 _nth_value++, \
7226 &_collect_type, \
7227 &_cvalue); \
7228 } \
7229 *(__error) = _error_msg; \
7230 } G_STMT_END
7231 </MACRO>
7232 <MACRO>
7233 <NAME>G_VALUE_LCOPY</NAME>
7234 #define G_VALUE_LCOPY(value, var_args, __error) \
7235 G_STMT_START { \
7236 GValue *_value = (value); \
7237 GTypeValueTable *_vtable = g_type_value_table_peek (G_VALUE_TYPE (_value)); \
7238 gchar *_error_msg = NULL; \
7239 guint _lcopy_type = _vtable->lcopy_type; \
7240 guint _nth_value = 0; \
7241 \
7242 while (_lcopy_type && !_error_msg) \
7243 { \
7244 GTypeCValue _cvalue; \
7245 \
7246 memset (&_cvalue, 0, sizeof (_cvalue)); \
7247 switch (_lcopy_type) \
7248 { \
7249 case G_VALUE_COLLECT_INT: \
7250 _cvalue.v_int = va_arg ((var_args), gint); \
7251 break; \
7252 case G_VALUE_COLLECT_LONG: \
7253 _cvalue.v_long = va_arg ((var_args), glong); \
7254 break; \
7255 case G_VALUE_COLLECT_DOUBLE: \
7256 _cvalue.v_double = va_arg ((var_args), gdouble); \
7257 break; \
7258 case G_VALUE_COLLECT_POINTER: \
7259 _cvalue.v_pointer = va_arg ((var_args), gpointer); \
7260 break; \
7261 default: \
7262 _error_msg = g_strdup_printf ("%s: invalid collect type (%d) used for %s", \
7263 G_STRLOC, \
7264 _lcopy_type, \
7265 "G_VALUE_LCOPY()"); \
7266 continue; \
7267 } \
7268 _error_msg = _vtable->lcopy_value (_value, \
7269 _nth_value++, \
7270 &_lcopy_type, \
7271 &_cvalue); \
7272 } \
7273 *(__error) = _error_msg; \
7274 } G_STMT_END
7275 </MACRO>
7276 <MACRO>
7277 <NAME>G_IS_VALUE_CHAR</NAME>
7278 #define G_IS_VALUE_CHAR(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_CHAR))
7279 </MACRO>
7280 <MACRO>
7281 <NAME>G_IS_VALUE_UCHAR</NAME>
7282 #define G_IS_VALUE_UCHAR(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_UCHAR))
7283 </MACRO>
7284 <MACRO>
7285 <NAME>G_IS_VALUE_BOOLEAN</NAME>
7286 #define G_IS_VALUE_BOOLEAN(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_BOOLEAN))
7287 </MACRO>
7288 <MACRO>
7289 <NAME>G_IS_VALUE_INT</NAME>
7290 #define G_IS_VALUE_INT(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_INT))
7291 </MACRO>
7292 <MACRO>
7293 <NAME>G_IS_VALUE_UINT</NAME>
7294 #define G_IS_VALUE_UINT(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_UINT))
7295 </MACRO>
7296 <MACRO>
7297 <NAME>G_IS_VALUE_LONG</NAME>
7298 #define G_IS_VALUE_LONG(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_LONG))
7299 </MACRO>
7300 <MACRO>
7301 <NAME>G_IS_VALUE_ULONG</NAME>
7302 #define G_IS_VALUE_ULONG(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_ULONG))
7303 </MACRO>
7304 <MACRO>
7305 <NAME>G_IS_VALUE_FLOAT</NAME>
7306 #define G_IS_VALUE_FLOAT(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_FLOAT))
7307 </MACRO>
7308 <MACRO>
7309 <NAME>G_IS_VALUE_DOUBLE</NAME>
7310 #define G_IS_VALUE_DOUBLE(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_DOUBLE))
7311 </MACRO>
7312 <MACRO>
7313 <NAME>G_IS_VALUE_STRING</NAME>
7314 #define G_IS_VALUE_STRING(value) (G_TYPE_CHECK_CLASS_TYPE ((value), G_TYPE_STRING))
7315 </MACRO>
7316 <FUNCTION>
7317 <NAME>g_value_set_char</NAME>
7318 <RETURNS>void </RETURNS>
7319 GValue *value,gint8 v_char
7320 </FUNCTION>
7321 <FUNCTION>
7322 <NAME>g_value_get_char</NAME>
7323 <RETURNS>gint8 </RETURNS>
7324 GValue *value
7325 </FUNCTION>
7326 <FUNCTION>
7327 <NAME>g_value_set_uchar</NAME>
7328 <RETURNS>void </RETURNS>
7329 GValue *value,guint8 v_uchar
7330 </FUNCTION>
7331 <FUNCTION>
7332 <NAME>g_value_get_uchar</NAME>
7333 <RETURNS>guint8 </RETURNS>
7334 GValue *value
7335 </FUNCTION>
7336 <FUNCTION>
7337 <NAME>g_value_set_boolean</NAME>
7338 <RETURNS>void </RETURNS>
7339 GValue *value,gboolean v_boolean
7340 </FUNCTION>
7341 <FUNCTION>
7342 <NAME>g_value_get_boolean</NAME>
7343 <RETURNS>gboolean </RETURNS>
7344 GValue *value
7345 </FUNCTION>
7346 <FUNCTION>
7347 <NAME>g_value_set_int</NAME>
7348 <RETURNS>void </RETURNS>
7349 GValue *value,gint v_int
7350 </FUNCTION>
7351 <FUNCTION>
7352 <NAME>g_value_get_int</NAME>
7353 <RETURNS>gint </RETURNS>
7354 GValue *value
7355 </FUNCTION>
7356 <FUNCTION>
7357 <NAME>g_value_set_uint</NAME>
7358 <RETURNS>void </RETURNS>
7359 GValue *value,guint v_uint
7360 </FUNCTION>
7361 <FUNCTION>
7362 <NAME>g_value_get_uint</NAME>
7363 <RETURNS>guint </RETURNS>
7364 GValue *value
7365 </FUNCTION>
7366 <FUNCTION>
7367 <NAME>g_value_set_long</NAME>
7368 <RETURNS>void </RETURNS>
7369 GValue *value,glong v_long
7370 </FUNCTION>
7371 <FUNCTION>
7372 <NAME>g_value_get_long</NAME>
7373 <RETURNS>glong </RETURNS>
7374 GValue *value
7375 </FUNCTION>
7376 <FUNCTION>
7377 <NAME>g_value_set_ulong</NAME>
7378 <RETURNS>void </RETURNS>
7379 GValue *value,gulong v_ulong
7380 </FUNCTION>
7381 <FUNCTION>
7382 <NAME>g_value_get_ulong</NAME>
7383 <RETURNS>gulong </RETURNS>
7384 GValue *value
7385 </FUNCTION>
7386 <FUNCTION>
7387 <NAME>g_value_set_float</NAME>
7388 <RETURNS>void </RETURNS>
7389 GValue *value,gfloat v_float
7390 </FUNCTION>
7391 <FUNCTION>
7392 <NAME>g_value_get_float</NAME>
7393 <RETURNS>gfloat </RETURNS>
7394 GValue *value
7395 </FUNCTION>
7396 <FUNCTION>
7397 <NAME>g_value_set_double</NAME>
7398 <RETURNS>void </RETURNS>
7399 GValue *value,gdouble v_double
7400 </FUNCTION>
7401 <FUNCTION>
7402 <NAME>g_value_get_double</NAME>
7403 <RETURNS>gdouble </RETURNS>
7404 GValue *value
7405 </FUNCTION>
7406 <FUNCTION>
7407 <NAME>g_value_set_string</NAME>
7408 <RETURNS>void </RETURNS>
7409 GValue *value,const gchar *v_string
7410 </FUNCTION>
7411 <FUNCTION>
7412 <NAME>g_value_get_string</NAME>
7413 <RETURNS>gchar *</RETURNS>
7414 GValue *value
7415 </FUNCTION>
7416 <FUNCTION>
7417 <NAME>g_value_dup_string</NAME>
7418 <RETURNS>gchar *</RETURNS>
7419 GValue *value
7420 </FUNCTION>