GNOME.org
 

[glib/gsettings] g_return_if_fail to catch invalid NULL parameters

commit 6eada6e47b84ba3c3dd779a85f9a9e5fa0c8de0f
Author: Ryan Lortie <desrt desrt ca>
Date:   Fri Aug 28 00:05:16 2009 -0400

    g_return_if_fail to catch invalid NULL parameters

 glib/gvariant-core.c |   25 ++++++++++++++
 glib/gvariant-util.c |   90 ++++++++++++++++++++++++++++++++++++++++---------
 2 files changed, 98 insertions(+), 17 deletions(-)
---
diff --git a/glib/gvariant-core.c b/glib/gvariant-core.c
index 0dda068..8ce1f1a 100644
--- a/glib/gvariant-core.c
+++ b/glib/gvariant-core.c
@@ -883,6 +883,7 @@ g_variant_is_normal_ (GVariant *value)
 const GVariantType *
 g_variant_get_type (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, NULL);
   g_variant_assert_invariant (value);
 
   return g_variant_type_info_get_type (value->type);
@@ -911,6 +912,7 @@ g_variant_n_children (GVariant *value)
 {
   gsize n_children;
 
+  g_return_val_if_fail (value != NULL, 0);
   g_variant_assert_invariant (value);
 
   if (g_variant_forbid_conditions (value, CONDITION_SERIALISED))
@@ -953,6 +955,7 @@ g_variant_get_child_value (GVariant *value,
 {
   GVariant *child;
 
+  g_return_val_if_fail (value != NULL, NULL);
   g_variant_assert_invariant (value);
 
   if (g_variant_forbid_conditions (value, CONDITION_SERIALISED))
@@ -1038,6 +1041,8 @@ g_variant_get_child_value (GVariant *value,
 gsize
 g_variant_get_size (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, 0);
+
   g_variant_require_conditions (value, CONDITION_SIZE_VALID);
 
   return value->size;
@@ -1064,6 +1069,8 @@ g_variant_get_size (GVariant *value)
 gconstpointer
 g_variant_get_data (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, NULL);
+
   g_variant_require_conditions (value, CONDITION_NATIVE | CONDITION_SERIALISED);
 
   return value->contents.serialised.data;
@@ -1089,6 +1096,8 @@ void
 g_variant_store (GVariant *value,
                  gpointer  data)
 {
+  g_return_val_if_fail (value != NULL, NULL);
+
   g_variant_assert_invariant (value);
 
   g_variant_require_conditions (value, CONDITION_SIZE_VALID | CONDITION_NATIVE);
@@ -1148,6 +1157,8 @@ g_variant_get_fixed (GVariant *value,
 {
   gsize fixed_size;
 
+  g_return_val_if_fail (value != NULL, NULL);
+
   g_variant_assert_invariant (value);
 
   g_variant_type_info_query (value->type, NULL, &fixed_size);
@@ -1188,6 +1199,8 @@ g_variant_get_fixed_array (GVariant *value,
 {
   gsize fixed_elem_size;
 
+  g_return_val_if_fail (value != NULL, NULL);
+
   g_variant_assert_invariant (value);
 
   /* unsupported: maybes are treated as arrays of size zero or one */
@@ -1212,6 +1225,8 @@ g_variant_get_fixed_array (GVariant *value,
 void
 g_variant_unref (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, NULL);
+
   g_variant_assert_invariant (value);
 
   if (g_atomic_int_dec_and_test (&value->ref_count))
@@ -1228,6 +1243,8 @@ g_variant_unref (GVariant *value)
 GVariant *
 g_variant_ref (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, NULL);
+
   g_variant_assert_invariant (value);
 
   g_atomic_int_inc (&value->ref_count);
@@ -1246,6 +1263,8 @@ g_variant_ref (GVariant *value)
 GVariant *
 g_variant_ref_sink (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, NULL);
+
   g_variant_assert_invariant (value);
 
   g_variant_ref (value);
@@ -1305,6 +1324,8 @@ g_variant_from_slice (const GVariantType *type,
 {
   GVariant *new;
 
+  g_return_val_if_fail (data != NULL || size == 0, NULL);
+
   if (type == NULL)
     {
       GVariant *variant;
@@ -1361,6 +1382,8 @@ g_variant_from_data (const GVariantType *type,
 {
   GVariant *new;
 
+  g_return_val_if_fail (data != NULL || size == 0, NULL);
+
   if (type == NULL)
     {
       GVariant *variant;
@@ -1414,6 +1437,8 @@ g_variant_load (const GVariantType *type,
 {
   GVariant *new;
 
+  g_return_val_if_fail (data != NULL || size == 0, NULL);
+
   if (type == NULL)
     {
       GVariant *variant;
diff --git a/glib/gvariant-util.c b/glib/gvariant-util.c
index 1cde86c..14d4cde 100644
--- a/glib/gvariant-util.c
+++ b/glib/gvariant-util.c
@@ -68,6 +68,9 @@ g_variant_iter_init (GVariantIter *iter,
 {
   GVariantIterReal *real = (GVariantIterReal *) iter;
 
+  g_return_val_if_fail (iter != NULL, 0);
+  g_return_val_if_fail (value != NULL, 0);
+
   g_assert (sizeof (GVariantIterReal) <= sizeof (GVariantIter));
 
   real->cancelled = FALSE;
@@ -106,6 +109,8 @@ g_variant_iter_next_value (GVariantIter *iter)
 {
   GVariantIterReal *real = (GVariantIterReal *) iter;
 
+  g_return_val_if_fail (iter != NULL, NULL);
+
   if (real->child)
     {
       g_variant_unref (real->child);
@@ -147,6 +152,8 @@ g_variant_iter_cancel (GVariantIter *iter)
 {
   GVariantIterReal *real = (GVariantIterReal *) iter;
 
+  g_return_if_fail (iter != NULL);
+
   real->cancelled = TRUE;
 
   if (real->value)
@@ -174,6 +181,8 @@ g_variant_iter_was_cancelled (GVariantIter *iter)
 {
   GVariantIterReal *real = (GVariantIterReal *) iter;
 
+  g_return_val_if_fail (iter != NULL, FALSE);
+
   return real->cancelled;
 }
 
@@ -200,6 +209,9 @@ gboolean
 g_variant_matches (GVariant           *value,
                    const GVariantType *pattern)
 {
+  g_return_val_if_fail (value != NULL, FALSE);
+  g_return_val_if_fail (value != NULL, FALSE);
+
   return g_variant_type_matches (g_variant_get_type (value), pattern);
 }
 
@@ -357,7 +369,7 @@ g_variant_new_string (const gchar *string)
 GVariant *
 g_variant_new_object_path (const gchar *string)
 {
-  g_assert (g_variant_is_object_path (string));
+  g_return_val_if_fail (g_variant_is_object_path (string), NULL);
 
   return g_variant_load (G_VARIANT_TYPE_OBJECT_PATH,
                          string, strlen (string) + 1,
@@ -384,6 +396,8 @@ g_variant_is_object_path (const gchar *string)
   /* according to DBus specification */
   gsize i;
 
+  g_return_val_if_fail (string != NULL, FALSE);
+
   /* The path must begin with an ASCII '/' (integer 47) character */
   if (string[0] != '/')
     return FALSE;
@@ -428,7 +442,7 @@ g_variant_is_object_path (const gchar *string)
 GVariant *
 g_variant_new_signature (const gchar *string)
 {
-  g_assert (g_variant_is_signature (string));
+  g_return_val_if_fail (g_variant_is_signature (string), NULL);
 
   return g_variant_load (G_VARIANT_TYPE_SIGNATURE,
                          string, strlen (string) + 1,
@@ -452,6 +466,8 @@ g_variant_is_signature (const gchar *string)
 {
   gsize first_invalid;
 
+  g_return_val_if_fail (string != NULL, FALSE);
+
   /* make sure no non-concrete characters appear */
   first_invalid = strspn (string, "ybnqiuxtdvmasog(){}");
   if (string[first_invalid])
@@ -478,6 +494,8 @@ g_variant_new_variant (GVariant *value)
 {
   GVariant **children;
 
+  g_return_val_if_fail (value != NULL, NULL);
+
   children = g_slice_new (GVariant *);
   children[0] = g_variant_ref_sink (value);
 
@@ -501,6 +519,7 @@ g_variant_get_boolean (GVariant *value)
 {
   guint8 byte;
 
+  g_return_val_if_fail (value != NULL, FALSE);
   g_assert (g_variant_matches (value, G_VARIANT_TYPE_BOOLEAN));
   g_variant_store (value, &byte);
 
@@ -522,6 +541,7 @@ g_variant_get_byte (GVariant *value)
 {
   guint8 byte;
 
+  g_return_val_if_fail (value != NULL, 0);
   g_assert (g_variant_matches (value, G_VARIANT_TYPE_BYTE));
   g_variant_store (value, &byte);
 
@@ -543,6 +563,7 @@ g_variant_get_int16 (GVariant *value)
 {
   gint16 int16;
 
+  g_return_val_if_fail (value != NULL, 0);
   g_assert (g_variant_matches (value, G_VARIANT_TYPE_INT16));
   g_variant_store (value, &int16);
 
@@ -564,6 +585,7 @@ g_variant_get_uint16 (GVariant *value)
 {
   guint16 uint16;
 
+  g_return_val_if_fail (value != NULL, 0);
   g_assert (g_variant_matches (value, G_VARIANT_TYPE_UINT16));
   g_variant_store (value, &uint16);
 
@@ -585,6 +607,7 @@ g_variant_get_int32 (GVariant *value)
 {
   gint32 int32;
 
+  g_return_val_if_fail (value != NULL, 0);
   g_assert (g_variant_matches (value, G_VARIANT_TYPE_INT32));
   g_variant_store (value, &int32);
 
@@ -606,6 +629,7 @@ g_variant_get_uint32 (GVariant *value)
 {
   guint32 uint32;
 
+  g_return_val_if_fail (value != NULL, 0);
   g_assert (g_variant_matches (value, G_VARIANT_TYPE_UINT32));
   g_variant_store (value, &uint32);
 
@@ -627,6 +651,7 @@ g_variant_get_int64 (GVariant *value)
 {
   gint64 int64;
 
+  g_return_val_if_fail (value != NULL, 0);
   g_assert (g_variant_matches (value, G_VARIANT_TYPE_INT64));
   g_variant_store (value, &int64);
 
@@ -648,6 +673,7 @@ g_variant_get_uint64 (GVariant *value)
 {
   guint64 uint64;
 
+  g_return_val_if_fail (value != NULL, 0);
   g_assert (g_variant_matches (value, G_VARIANT_TYPE_UINT64));
   g_variant_store (value, &uint64);
 
@@ -669,6 +695,7 @@ g_variant_get_double (GVariant *value)
 {
   gdouble floating;
 
+  g_return_val_if_fail (value != NULL, 0);
   g_assert (g_variant_matches (value, G_VARIANT_TYPE_DOUBLE));
   g_variant_store (value, &floating);
 
@@ -703,10 +730,11 @@ g_variant_get_string (GVariant *value,
   const gchar *string;
   gssize size;
 
+  g_return_val_if_fail (value != NULL, NULL);
   class = g_variant_get_type_class (value);
-  g_assert (class == G_VARIANT_TYPE_CLASS_STRING ||
-            class == G_VARIANT_TYPE_CLASS_OBJECT_PATH ||
-            class == G_VARIANT_TYPE_CLASS_SIGNATURE);
+  g_return_val_if_fail (class == G_VARIANT_TYPE_CLASS_STRING ||
+                        class == G_VARIANT_TYPE_CLASS_OBJECT_PATH ||
+                        class == G_VARIANT_TYPE_CLASS_SIGNATURE, NULL);
 
   string = g_variant_get_data (value);
   size = g_variant_get_size (value);
@@ -775,11 +803,14 @@ gchar *
 g_variant_dup_string (GVariant *value,
                       gsize    *length)
 {
+  GVariantTypeClass class;
   int size;
 
-  g_assert (g_variant_matches (value, G_VARIANT_TYPE_STRING) ||
-            g_variant_matches (value, G_VARIANT_TYPE_OBJECT_PATH) ||
-            g_variant_matches (value, G_VARIANT_TYPE_SIGNATURE));
+  g_return_val_if_fail (value != NULL, NULL);
+  class = g_variant_get_type_class (value);
+  g_return_val_if_fail (class == G_VARIANT_TYPE_CLASS_STRING ||
+                        class == G_VARIANT_TYPE_CLASS_OBJECT_PATH ||
+                        class == G_VARIANT_TYPE_CLASS_SIGNATURE, NULL);
 
   size = g_variant_get_size (value);
 
@@ -800,6 +831,7 @@ g_variant_dup_string (GVariant *value,
 GVariant *
 g_variant_get_variant (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, NULL);
   g_assert (g_variant_matches (value, G_VARIANT_TYPE_VARIANT));
 
   return g_variant_get_child_value (value, 0);
@@ -917,6 +949,9 @@ g_variant_builder_add_value (GVariantBuilder *builder,
 {
   GError *error = NULL;
 
+  g_return_if_fail (builder != NULL);
+  g_return_if_fail (value != NULL);
+
   if G_UNLIKELY (!g_variant_builder_check_add_value (builder, value, &error))
     g_error ("g_variant_builder_add_value: %s", error->message);
 
@@ -973,6 +1008,8 @@ g_variant_builder_open (GVariantBuilder    *parent,
   GVariantBuilder *child;
   GError *error = NULL;
 
+  g_return_val_if_fail (parent != NULL, NULL);
+
   if G_UNLIKELY (!g_variant_builder_check_add (parent, class, type, &error))
     g_error ("g_variant_builder_open: %s", error->message);
 
@@ -1020,6 +1057,8 @@ g_variant_builder_close (GVariantBuilder *child)
   GVariantBuilder *parent;
   GVariant *value;
 
+  g_return_val_if_fail (child != NULL, NULL);
+
   g_assert (child->has_child == FALSE);
   g_assert (child != NULL);
   g_assert (child->parent != NULL);
@@ -1148,7 +1187,8 @@ g_variant_builder_end (GVariantBuilder *builder)
   GError *error = NULL;
   GVariant *value;
 
-  g_assert (builder->parent == NULL);
+  g_return_val_if_fail (builder, NULL);
+  g_return_val_if_fail (builder->parent == NULL, NULL);
 
   if G_UNLIKELY (!g_variant_builder_check_end (builder, &error))
     g_error ("g_variant_builder_end: %s", error->message);
@@ -1242,8 +1282,8 @@ gboolean
 g_variant_builder_check_end (GVariantBuilder  *builder,
                              GError          **error)
 {
-  g_assert (builder != NULL);
-  g_assert (builder->has_child == FALSE);
+  g_return_val_if_fail (builder != NULL, FALSE);
+  g_return_val_if_fail (builder->has_child == FALSE, FALSE);
 
   switch (builder->class)
   {
@@ -1369,11 +1409,11 @@ g_variant_builder_check_add (GVariantBuilder     *builder,
                              const GVariantType  *type,
                              GError             **error)
 {
-  g_assert (builder != NULL);
-  g_assert (builder->has_child == FALSE);
-  g_assert (class != G_VARIANT_TYPE_CLASS_INVALID &&
-            class != G_VARIANT_TYPE_CLASS_ALL &&
-            class != G_VARIANT_TYPE_CLASS_BASIC);
+  g_return_val_if_fail (builder != NULL, FALSE);
+  g_return_val_if_fail (builder->has_child == FALSE, FALSE);
+  g_return_val_if_fail (class != G_VARIANT_TYPE_CLASS_INVALID &&
+                        class != G_VARIANT_TYPE_CLASS_ALL &&
+                        class != G_VARIANT_TYPE_CLASS_BASIC, FALSE);
 
   if (class == G_VARIANT_TYPE_CLASS_VARIANT)
     type = NULL;
@@ -1538,7 +1578,7 @@ g_variant_builder_cancel (GVariantBuilder *builder)
 {
   GVariantBuilder *parent;
 
-  g_assert (builder != NULL);
+  g_return_if_fail (builder != NULL);
 
   do
     {
@@ -1585,6 +1625,7 @@ g_variant_builder_cancel (GVariantBuilder *builder)
 void
 g_variant_flatten (GVariant *value)
 {
+  g_return_if_fail (value != NULL);
   g_variant_get_data (value);
 }
 
@@ -1600,6 +1641,7 @@ g_variant_flatten (GVariant *value)
 const gchar *
 g_variant_get_type_string (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, NULL);
   return (const gchar *) g_variant_get_type (value);
 }
 
@@ -1615,6 +1657,7 @@ g_variant_get_type_string (GVariant *value)
 GVariantTypeClass
 g_variant_get_type_class (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, 0);
   return g_variant_type_get_class (g_variant_get_type (value));
 }
 
@@ -1631,6 +1674,7 @@ g_variant_get_type_class (GVariant *value)
 gboolean
 g_variant_is_basic (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, FALSE);
   return g_variant_type_class_is_basic (g_variant_get_type_class (value));
 }
 
@@ -1648,6 +1692,7 @@ g_variant_is_basic (GVariant *value)
 gboolean
 g_variant_is_container (GVariant *value)
 {
+  g_return_val_if_fail (value != NULL, FALSE);
   return g_variant_type_class_is_container (g_variant_get_type_class (value));
 }
 
@@ -1661,6 +1706,7 @@ g_variant_dump_data (GVariant *value)
   gsize data_size;
   gsize i;
 
+  g_return_if_fail (value != NULL);
   data_size = g_variant_get_size (value);
 
   g_debug ("GVariant at %p (type '%s', %" G_GSIZE_FORMAT " bytes):",
@@ -1782,6 +1828,8 @@ g_variant_new_strv (const gchar * const *strv,
 {
   GVariantBuilder *builder;
 
+  g_return_val_if_fail (strv != NULL || length == 0, NULL);
+
   builder = g_variant_builder_new (G_VARIANT_TYPE_CLASS_ARRAY,
                                    G_VARIANT_TYPE ("as"));
   while (length-- && *strv)
@@ -1815,6 +1863,7 @@ g_variant_get_strv (GVariant *value,
   gint my_length;
   gint i;
 
+  g_return_val_if_fail (value != NULL, NULL);
   g_return_val_if_fail (g_variant_matches (value, G_VARIANT_TYPE ("as")),
                         NULL);
 
@@ -1862,6 +1911,7 @@ g_variant_dup_strv (GVariant *value,
   gint my_length;
   gint i;
 
+  g_return_val_if_fail (value != NULL, NULL);
   g_return_val_if_fail (g_variant_matches (value, G_VARIANT_TYPE ("as")),
                         NULL);
 
@@ -1907,6 +1957,9 @@ g_variant_lookup_value (GVariant    *dictionary,
   GVariant *value;
   GVariant *result = NULL;
 
+  g_return_val_if_fail (dictionary != NULL, NULL);
+  g_return_val_if_fail (key != NULL, NULL);
+
   g_variant_iter_init (&iter, dictionary);
   while (g_variant_iter_next (&iter, "{&s*}", &_key, &value))
     if (strcmp (_key, key) == 0)
@@ -1941,6 +1994,9 @@ g_variant_from_file (const GVariantType *type,
 {
   GMappedFile *mapped;
 
+  g_return_val_if_fail (filename != NULL, NULL);
+  g_return_val_if_fail (error == NULL || *error == NULL, NULL);
+
   mapped = g_mapped_file_new (filename, FALSE, error);
 
   if (mapped == NULL)
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]