Re: [PATCH] (u)int64 + string value transforms



Andy Wingo <wingo pobox com> writes:

> On Thu, 07 Feb 2002, Tim Janik wrote:
> > On Wed, 6 Feb 2002, Andy Wingo wrote:
> 
> > the int64 part looks ok, but we're not going to support string->integer/float
> > conversions.
> 
> ok.
> 
> > there's a lengthy thread on the reasons for that in the list archives, but
> > basically, it's that we're not going to force a specific syntax on people,
> > and that we're not able to handle derived types correctly. so please back out
> > that part and resend the patch (sending it to me privately on the second round
> > will suffice to get commit aproval).
> 
> ok. couldn't find the thread, but understood more or less, i think
> (ie, no support in glib unless it can be supported properly).
> 
> > as an aside, the ->string conversions shouldn't really be used in production
> > code, they are more of a convenience variant for debugging purposes and could
> > possibly change.
> 
> i wouldn't have bothered replying to the list were it not for this part
> :) in gstreamer we need to serialize objects to xml. right now i'm using
> g_strdup_value_contents() to stringify props, and i was wanting to add
> the inverse operation. that's fine if all i have to do is register a few
> more type transforms, but my question is whether i should actually
> register the ->string transforms within gstreamer itself so that we can
> guarantee that they are there and so they work properly, or whether we
> can rely on glib to have these routines availiable. so, i reckon i'll
> include the stringification into gstreamer too.

I'd point out that the g_value_transform() functions don't have
sufficient API to be part of a robust parser... g_value_transform()
doesn't provide any mechanism for reporting errors. (The boolean
return indicates whether the transformation from type a to type
b is supported, not whether it succeeded in this particular case.)

I've applied the 64-bit part of your patch now. (Trying to keep
bugzilla clean...) The one change I made was to make the registration
of the => string functions dependent on whether an appropriate
format was found... I don't much like conditional features,
but I think there will be a fairly broad class of target machines
with 64-bit types (for GCC), but without 64-bit formats in their
C libraries.

Thanks for the patch,
                                        Owen

Index: ChangeLog
===================================================================
RCS file: /cvs/gnome/glib/ChangeLog,v
retrieving revision 1.1011
diff -u -p -r1.1011 ChangeLog
--- ChangeLog	2002/02/08 19:57:25	1.1011
+++ ChangeLog	2002/02/09 04:58:27
@@ -1,3 +1,13 @@
+Fri Feb  8 23:52:27 2002  Owen Taylor  <otaylor redhat com>
+
+	* gobject/gvaluetransform.c: Register transformations for
+	gint64, guint64. (#70780, patch from Andy Wingo)
+
+	* configure.in: Handle missing G_GINT64_FORMAT, 
+	G_GUINT64_FORMAT ... harder to require GNU libc than GCC.
+
+	* NEWS: Some cleanups that I had setting around.
+
 2002-02-08  Darin Adler  <darin bentspoon com>
 
 	* glib/gconvert.h: Make hostname parameter const char *.
Index: configure.in
===================================================================
RCS file: /cvs/gnome/glib/configure.in,v
retrieving revision 1.263
diff -u -p -r1.263 configure.in
--- configure.in	2002/02/07 01:59:26	1.263
+++ configure.in	2002/02/09 04:58:28
@@ -1721,10 +1721,19 @@ ${glib_extension}typedef signed $gint64 
 ${glib_extension}typedef unsigned $gint64 guint64;
 
 #define G_GINT64_CONSTANT(val)	$gint64_constant
+_______EOF
 
+	if test x$gint64_format != x ; then
+	  cat >>$outfile <<_______EOF
 #define G_GINT64_FORMAT $gint64_format
 #define G_GUINT64_FORMAT $guint64_format
 _______EOF
+        else
+	  cat >>$outfile <<_______EOF
+#undef G_GINT64_FORMAT
+#undef G_GUINT64_FORMAT
+_______EOF
+        fi           
 
         cat >>$outfile <<_______EOF
 
Index: gobject/gvaluetransform.c
===================================================================
RCS file: /cvs/gnome/glib/gobject/gvaluetransform.c,v
retrieving revision 1.2
diff -u -p -r1.2 gvaluetransform.c
--- gobject/gvaluetransform.c	2001/03/08 21:34:53	1.2
+++ gobject/gvaluetransform.c	2002/02/09 04:58:29
@@ -20,6 +20,7 @@
 
 #include	"gvalue.h"
 #include	"genums.h"
+#include	"glibconfig.h" /* G_G[U]INT64_FORMAT */
 
 
 /* same type transforms
@@ -34,6 +35,10 @@ value_transform_memcpy_data0 (const GVal
 #define	value_transform_uint_uint	value_transform_memcpy_data0
 #define	value_transform_long_long	value_transform_memcpy_data0
 #define	value_transform_ulong_ulong	value_transform_memcpy_data0
+#define	value_transform_int64_int64	value_transform_memcpy_data0
+#define	value_transform_uint64_uint64	value_transform_memcpy_data0
+#define	value_transform_int64_int64	value_transform_memcpy_data0
+#define	value_transform_uint64_uint64	value_transform_memcpy_data0
 #define	value_transform_float_float	value_transform_memcpy_data0
 #define	value_transform_double_double	value_transform_memcpy_data0
 
@@ -53,6 +58,8 @@ DEFINE_CAST (int_u8,		v_int,    guint8, 
 DEFINE_CAST (int_uint,		v_int,    guint,   v_uint);
 DEFINE_CAST (int_long,		v_int,    glong,   v_long);
 DEFINE_CAST (int_ulong,		v_int,    gulong,  v_ulong);
+DEFINE_CAST (int_int64,		v_int,    gint64,  v_int64);
+DEFINE_CAST (int_uint64,	v_int,    guint64, v_uint64);
 DEFINE_CAST (int_float,		v_int,    gfloat,  v_float);
 DEFINE_CAST (int_double,	v_int,    gdouble, v_double);
 DEFINE_CAST (uint_s8,		v_uint,   gint8,   v_int);
@@ -60,6 +67,8 @@ DEFINE_CAST (uint_u8,		v_uint,   guint8,
 DEFINE_CAST (uint_int,		v_uint,   gint,    v_int);
 DEFINE_CAST (uint_long,		v_uint,   glong,   v_long);
 DEFINE_CAST (uint_ulong,	v_uint,   gulong,  v_ulong);
+DEFINE_CAST (uint_int64,	v_uint,   gint64,  v_int64);
+DEFINE_CAST (uint_uint64,	v_uint,   guint64, v_uint64);
 DEFINE_CAST (uint_float,	v_uint,   gfloat,  v_float);
 DEFINE_CAST (uint_double,	v_uint,   gdouble, v_double);
 DEFINE_CAST (long_s8,		v_long,   gint8,   v_int);
@@ -67,21 +76,45 @@ DEFINE_CAST (long_u8,		v_long,   guint8,
 DEFINE_CAST (long_int,		v_long,   gint,    v_int);
 DEFINE_CAST (long_uint,		v_long,   guint,   v_uint);
 DEFINE_CAST (long_ulong,	v_long,   gulong,  v_ulong);
+DEFINE_CAST (long_int64,	v_long,   gint64,  v_int64);
+DEFINE_CAST (long_uint64,	v_long,   guint64, v_uint64);
 DEFINE_CAST (long_float,	v_long,   gfloat,  v_float);
 DEFINE_CAST (long_double,	v_long,   gdouble, v_double);
 DEFINE_CAST (ulong_s8,		v_ulong,  gint8,   v_int);
 DEFINE_CAST (ulong_u8,		v_ulong,  guint8,  v_uint);
 DEFINE_CAST (ulong_int,		v_ulong,  gint,    v_int);
 DEFINE_CAST (ulong_uint,	v_ulong,  guint,   v_uint);
+DEFINE_CAST (ulong_int64,	v_ulong,  gint64,  v_int64);
+DEFINE_CAST (ulong_uint64,	v_ulong,  guint64, v_uint64);
 DEFINE_CAST (ulong_long,	v_ulong,  glong,   v_long);
 DEFINE_CAST (ulong_float,	v_ulong,  gfloat,  v_float);
 DEFINE_CAST (ulong_double,	v_ulong,  gdouble, v_double);
+DEFINE_CAST (int64_s8,		v_int64,  gint8,   v_int);
+DEFINE_CAST (int64_u8,		v_int64,  guint8,  v_uint);
+DEFINE_CAST (int64_int,		v_int64,  gint,    v_int);
+DEFINE_CAST (int64_uint,	v_int64,  guint,   v_uint);
+DEFINE_CAST (int64_long,	v_int64,  glong,   v_long);
+DEFINE_CAST (int64_uint64,	v_int64,  guint64, v_uint64);
+DEFINE_CAST (int64_ulong,	v_int64,  gulong,  v_ulong);
+DEFINE_CAST (int64_float,	v_int64,  gfloat,  v_float);
+DEFINE_CAST (int64_double,	v_int64,  gdouble, v_double);
+DEFINE_CAST (uint64_s8,		v_uint64, gint8,   v_int);
+DEFINE_CAST (uint64_u8,		v_uint64, guint8,  v_uint);
+DEFINE_CAST (uint64_int,	v_uint64, gint,    v_int);
+DEFINE_CAST (uint64_uint,	v_uint64, guint,   v_uint);
+DEFINE_CAST (uint64_long,	v_uint64, glong,   v_long);
+DEFINE_CAST (uint64_ulong,	v_uint64, gulong,  v_ulong);
+DEFINE_CAST (uint64_int64,	v_uint64, gint64,  v_int64);
+DEFINE_CAST (uint64_float,	v_uint64, gfloat,  v_float);
+DEFINE_CAST (uint64_double,	v_uint64, gdouble, v_double);
 DEFINE_CAST (float_s8,		v_float,  gint8,   v_int);
 DEFINE_CAST (float_u8,		v_float,  guint8,  v_uint);
 DEFINE_CAST (float_int,		v_float,  gint,    v_int);
 DEFINE_CAST (float_uint,	v_float,  guint,   v_uint);
 DEFINE_CAST (float_long,	v_float,  glong,   v_long);
 DEFINE_CAST (float_ulong,	v_float,  gulong,  v_ulong);
+DEFINE_CAST (float_int64,	v_float,  gint64,  v_int64);
+DEFINE_CAST (float_uint64,	v_float,  guint64, v_uint64);
 DEFINE_CAST (float_double,	v_float,  gdouble, v_double);
 DEFINE_CAST (double_s8,		v_double, gint8,   v_int);
 DEFINE_CAST (double_u8,		v_double, guint8,  v_uint);
@@ -89,6 +122,8 @@ DEFINE_CAST (double_int,	v_double, gint,
 DEFINE_CAST (double_uint,	v_double, guint,   v_uint);
 DEFINE_CAST (double_long,	v_double, glong,   v_long);
 DEFINE_CAST (double_ulong,	v_double, gulong,  v_ulong);
+DEFINE_CAST (double_int64,	v_double, gint64,  v_int64);
+DEFINE_CAST (double_uint64,	v_double, guint64, v_uint64);
 DEFINE_CAST (double_float,	v_double, gfloat,  v_float);
 
 
@@ -105,9 +140,11 @@ DEFINE_BOOL_CHECK (int_bool,	v_int);
 DEFINE_BOOL_CHECK (uint_bool,	v_uint);
 DEFINE_BOOL_CHECK (long_bool,	v_long);
 DEFINE_BOOL_CHECK (ulong_bool,	v_uint);
+DEFINE_BOOL_CHECK (int64_bool,	v_int64);
+DEFINE_BOOL_CHECK (uint64_bool,	v_uint64);
 
 
-/* string printouts
+/* string printouts and scanning
  */
 #define	DEFINE_SPRINTF(func_name, from_member, format)				\
     static void									\
@@ -121,6 +158,12 @@ DEFINE_SPRINTF (int_string,	v_int,	  "%d
 DEFINE_SPRINTF (uint_string,	v_uint,	  "%u");
 DEFINE_SPRINTF (long_string,	v_long,	  "%ld");
 DEFINE_SPRINTF (ulong_string,	v_ulong,  "%lu");
+#ifdef G_GINT64_FORMAT
+DEFINE_SPRINTF (int64_string,	v_long,	  "%" G_GINT64_FORMAT);
+#endif
+#ifdef G_GUINT64_FORMAT
+DEFINE_SPRINTF (uint64_string,	v_ulong,  "%" G_GUINT64_FORMAT);
+#endif
 DEFINE_SPRINTF (float_string,	v_float,  "%f");
 DEFINE_SPRINTF (double_string,	v_double, "%f");
 
@@ -211,6 +254,8 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_CHAR,		G_TYPE_UINT,		value_transform_int_uint);
   g_value_register_transform_func (G_TYPE_CHAR,		G_TYPE_LONG,		value_transform_int_long);
   g_value_register_transform_func (G_TYPE_CHAR,		G_TYPE_ULONG,		value_transform_int_ulong);
+  g_value_register_transform_func (G_TYPE_CHAR,		G_TYPE_INT64,		value_transform_int_int64);
+  g_value_register_transform_func (G_TYPE_CHAR,		G_TYPE_UINT64,		value_transform_int_uint64);
   g_value_register_transform_func (G_TYPE_CHAR,		G_TYPE_ENUM,		value_transform_int_int);
   g_value_register_transform_func (G_TYPE_CHAR,		G_TYPE_FLAGS,		value_transform_int_uint);
   g_value_register_transform_func (G_TYPE_CHAR,		G_TYPE_FLOAT,		value_transform_int_float);
@@ -223,6 +268,8 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_UCHAR,	G_TYPE_UINT,		value_transform_uint_uint);
   g_value_register_transform_func (G_TYPE_UCHAR,	G_TYPE_LONG,		value_transform_uint_long);
   g_value_register_transform_func (G_TYPE_UCHAR,	G_TYPE_ULONG,		value_transform_uint_ulong);
+  g_value_register_transform_func (G_TYPE_UCHAR,	G_TYPE_INT64,		value_transform_uint_int64);
+  g_value_register_transform_func (G_TYPE_UCHAR,	G_TYPE_UINT64,		value_transform_uint_uint64);
   g_value_register_transform_func (G_TYPE_UCHAR,	G_TYPE_ENUM,		value_transform_uint_int);
   g_value_register_transform_func (G_TYPE_UCHAR,	G_TYPE_FLAGS,		value_transform_uint_uint);
   g_value_register_transform_func (G_TYPE_UCHAR,	G_TYPE_FLOAT,		value_transform_uint_float);
@@ -235,6 +282,8 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_BOOLEAN,	G_TYPE_UINT,		value_transform_int_uint);
   g_value_register_transform_func (G_TYPE_BOOLEAN,	G_TYPE_LONG,		value_transform_int_long);
   g_value_register_transform_func (G_TYPE_BOOLEAN,	G_TYPE_ULONG,		value_transform_int_ulong);
+  g_value_register_transform_func (G_TYPE_BOOLEAN,	G_TYPE_INT64,		value_transform_int_int64);
+  g_value_register_transform_func (G_TYPE_BOOLEAN,	G_TYPE_UINT64,		value_transform_int_uint64);
   g_value_register_transform_func (G_TYPE_BOOLEAN,	G_TYPE_ENUM,		value_transform_int_int);
   g_value_register_transform_func (G_TYPE_BOOLEAN,	G_TYPE_FLAGS,		value_transform_int_uint);
   SKIP____register_transform_func (G_TYPE_BOOLEAN,	G_TYPE_FLOAT,		value_transform_int_float);
@@ -247,6 +296,8 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_INT,		G_TYPE_UINT,		value_transform_int_uint);
   g_value_register_transform_func (G_TYPE_INT,		G_TYPE_LONG,		value_transform_int_long);
   g_value_register_transform_func (G_TYPE_INT,		G_TYPE_ULONG,		value_transform_int_ulong);
+  g_value_register_transform_func (G_TYPE_INT,		G_TYPE_INT64,		value_transform_int_int64);
+  g_value_register_transform_func (G_TYPE_INT,		G_TYPE_UINT64,		value_transform_int_uint64);
   g_value_register_transform_func (G_TYPE_INT,		G_TYPE_ENUM,		value_transform_int_int);
   g_value_register_transform_func (G_TYPE_INT,		G_TYPE_FLAGS,		value_transform_int_uint);
   g_value_register_transform_func (G_TYPE_INT,		G_TYPE_FLOAT,		value_transform_int_float);
@@ -259,6 +310,8 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_UINT,		G_TYPE_UINT,		value_transform_uint_uint);
   g_value_register_transform_func (G_TYPE_UINT,		G_TYPE_LONG,		value_transform_uint_long);
   g_value_register_transform_func (G_TYPE_UINT,		G_TYPE_ULONG,		value_transform_uint_ulong);
+  g_value_register_transform_func (G_TYPE_UINT,		G_TYPE_INT64,		value_transform_uint_int64);
+  g_value_register_transform_func (G_TYPE_UINT,		G_TYPE_UINT64,		value_transform_uint_uint64);
   g_value_register_transform_func (G_TYPE_UINT,		G_TYPE_ENUM,		value_transform_uint_int);
   g_value_register_transform_func (G_TYPE_UINT,		G_TYPE_FLAGS,		value_transform_uint_uint);
   g_value_register_transform_func (G_TYPE_UINT,		G_TYPE_FLOAT,		value_transform_uint_float);
@@ -271,6 +324,8 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_LONG,		G_TYPE_UINT,		value_transform_long_uint);
   g_value_register_transform_func (G_TYPE_LONG,		G_TYPE_LONG,		value_transform_long_long);
   g_value_register_transform_func (G_TYPE_LONG,		G_TYPE_ULONG,		value_transform_long_ulong);
+  g_value_register_transform_func (G_TYPE_LONG,		G_TYPE_INT64,		value_transform_long_int64);
+  g_value_register_transform_func (G_TYPE_LONG,		G_TYPE_UINT64,		value_transform_long_uint64);
   g_value_register_transform_func (G_TYPE_LONG,		G_TYPE_ENUM,		value_transform_long_int);
   g_value_register_transform_func (G_TYPE_LONG,		G_TYPE_FLAGS,		value_transform_long_uint);
   g_value_register_transform_func (G_TYPE_LONG,		G_TYPE_FLOAT,		value_transform_long_float);
@@ -283,11 +338,41 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_ULONG,	G_TYPE_UINT,		value_transform_ulong_uint);
   g_value_register_transform_func (G_TYPE_ULONG,	G_TYPE_LONG,		value_transform_ulong_long);
   g_value_register_transform_func (G_TYPE_ULONG,	G_TYPE_ULONG,		value_transform_ulong_ulong);
+  g_value_register_transform_func (G_TYPE_ULONG,	G_TYPE_INT64,		value_transform_ulong_int64);
+  g_value_register_transform_func (G_TYPE_ULONG,	G_TYPE_UINT64,		value_transform_ulong_uint64);
   g_value_register_transform_func (G_TYPE_ULONG,	G_TYPE_ENUM,		value_transform_ulong_int);
   g_value_register_transform_func (G_TYPE_ULONG,	G_TYPE_FLAGS,		value_transform_ulong_uint);
   g_value_register_transform_func (G_TYPE_ULONG,	G_TYPE_FLOAT,		value_transform_ulong_float);
   g_value_register_transform_func (G_TYPE_ULONG,	G_TYPE_DOUBLE,		value_transform_ulong_double);
   g_value_register_transform_func (G_TYPE_ULONG,	G_TYPE_STRING,		value_transform_ulong_string);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_CHAR,		value_transform_int64_s8);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_UCHAR,		value_transform_int64_u8);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_BOOLEAN,		value_transform_int64_bool);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_INT,		value_transform_int64_int);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_UINT,		value_transform_int64_uint);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_LONG,		value_transform_int64_long);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_ULONG,		value_transform_int64_ulong);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_INT64,		value_transform_int64_int64);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_UINT64,		value_transform_int64_uint64);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_ENUM,		value_transform_int64_int);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_FLAGS,		value_transform_int64_uint);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_FLOAT,		value_transform_int64_float);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_DOUBLE,		value_transform_int64_double);
+  g_value_register_transform_func (G_TYPE_INT64,	G_TYPE_STRING,		value_transform_int64_string);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_CHAR,		value_transform_uint64_s8);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_UCHAR,		value_transform_uint64_u8);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_BOOLEAN,		value_transform_uint64_bool);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_INT,		value_transform_uint64_int);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_UINT,		value_transform_uint64_uint);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_LONG,		value_transform_uint64_long);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_ULONG,		value_transform_uint64_ulong);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_INT64,		value_transform_uint64_int64);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_UINT64,		value_transform_uint64_uint64);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_ENUM,		value_transform_uint64_int);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_FLAGS,		value_transform_uint64_uint);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_FLOAT,		value_transform_uint64_float);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_DOUBLE,		value_transform_uint64_double);
+  g_value_register_transform_func (G_TYPE_UINT64,	G_TYPE_STRING,		value_transform_uint64_string);
   g_value_register_transform_func (G_TYPE_ENUM,		G_TYPE_CHAR,		value_transform_int_s8);
   g_value_register_transform_func (G_TYPE_ENUM,		G_TYPE_UCHAR,		value_transform_int_u8);
   SKIP____register_transform_func (G_TYPE_ENUM,		G_TYPE_BOOLEAN,		value_transform_int_bool);
@@ -295,6 +380,8 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_ENUM,		G_TYPE_UINT,		value_transform_int_uint);
   g_value_register_transform_func (G_TYPE_ENUM,		G_TYPE_LONG,		value_transform_int_long);
   g_value_register_transform_func (G_TYPE_ENUM,		G_TYPE_ULONG,		value_transform_int_ulong);
+  g_value_register_transform_func (G_TYPE_ENUM,		G_TYPE_INT64,		value_transform_int_int64);
+  g_value_register_transform_func (G_TYPE_ENUM,		G_TYPE_UINT64,		value_transform_int_uint64);
   g_value_register_transform_func (G_TYPE_ENUM,		G_TYPE_ENUM,		value_transform_int_int);
   g_value_register_transform_func (G_TYPE_ENUM,		G_TYPE_FLAGS,		value_transform_int_uint);
   SKIP____register_transform_func (G_TYPE_ENUM,		G_TYPE_FLOAT,		value_transform_int_float);
@@ -307,6 +394,8 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_FLAGS,	G_TYPE_UINT,		value_transform_uint_uint);
   g_value_register_transform_func (G_TYPE_FLAGS,	G_TYPE_LONG,		value_transform_uint_long);
   g_value_register_transform_func (G_TYPE_FLAGS,	G_TYPE_ULONG,		value_transform_uint_ulong);
+  g_value_register_transform_func (G_TYPE_FLAGS,	G_TYPE_INT64,		value_transform_uint_int64);
+  g_value_register_transform_func (G_TYPE_FLAGS,	G_TYPE_UINT64,		value_transform_uint_uint64);
   SKIP____register_transform_func (G_TYPE_FLAGS,	G_TYPE_ENUM,		value_transform_uint_int);
   g_value_register_transform_func (G_TYPE_FLAGS,	G_TYPE_FLAGS,		value_transform_uint_uint);
   SKIP____register_transform_func (G_TYPE_FLAGS,	G_TYPE_FLOAT,		value_transform_uint_float);
@@ -319,6 +408,8 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_FLOAT,	G_TYPE_UINT,		value_transform_float_uint);
   g_value_register_transform_func (G_TYPE_FLOAT,	G_TYPE_LONG,		value_transform_float_long);
   g_value_register_transform_func (G_TYPE_FLOAT,	G_TYPE_ULONG,		value_transform_float_ulong);
+  g_value_register_transform_func (G_TYPE_FLOAT,	G_TYPE_INT64,		value_transform_float_int64);
+  g_value_register_transform_func (G_TYPE_FLOAT,	G_TYPE_UINT64,		value_transform_float_uint64);
   SKIP____register_transform_func (G_TYPE_FLOAT,	G_TYPE_ENUM,		value_transform_float_int);
   SKIP____register_transform_func (G_TYPE_FLOAT,	G_TYPE_FLAGS,		value_transform_float_uint);
   g_value_register_transform_func (G_TYPE_FLOAT,	G_TYPE_FLOAT,		value_transform_float_float);
@@ -331,6 +422,8 @@ g_value_transforms_init (void)		/* sync 
   g_value_register_transform_func (G_TYPE_DOUBLE,	G_TYPE_UINT,		value_transform_double_uint);
   g_value_register_transform_func (G_TYPE_DOUBLE,	G_TYPE_LONG,		value_transform_double_long);
   g_value_register_transform_func (G_TYPE_DOUBLE,	G_TYPE_ULONG,		value_transform_double_ulong);
+  g_value_register_transform_func (G_TYPE_DOUBLE,	G_TYPE_INT64,		value_transform_double_int64);
+  g_value_register_transform_func (G_TYPE_DOUBLE,	G_TYPE_UINT64,		value_transform_double_uint64);
   SKIP____register_transform_func (G_TYPE_DOUBLE,	G_TYPE_ENUM,		value_transform_double_int);
   SKIP____register_transform_func (G_TYPE_DOUBLE,	G_TYPE_FLAGS,		value_transform_double_uint);
   g_value_register_transform_func (G_TYPE_DOUBLE,	G_TYPE_FLOAT,		value_transform_double_float);


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]