Attachment 35306 Details for Bug 27857 – Implement "maybe", "m", DBUS_TYPE_MAYBE

[patch] Implement "maybe", "m", DBUS_TYPE_MAYBE

nullable.diff (text/plain), 16.62 KB, created by Christian Dywan on 2010-04-27 04:56:33 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Christian Dywan

Created: 2010-04-27 04:56:33 UTC

Size: 16.62 KB

patch

obsolete

>diff --git a/dbus/dbus-marshal-basic.c b/dbus/dbus-marshal-basic.c
>index ea18dbf..a37ff02 100644
>--- a/dbus/dbus-marshal-basic.c
>+++ b/dbus/dbus-marshal-basic.c
>@@ -1213,6 +1213,7 @@ _dbus_type_get_alignment (int typecode)
>     case DBUS_TYPE_STRING:
>     case DBUS_TYPE_OBJECT_PATH:
>     case DBUS_TYPE_ARRAY:
>+    case DBUS_TYPE_MAYBE:
>       return 4;
>     case DBUS_TYPE_INT64:
>     case DBUS_TYPE_UINT64:
>@@ -1260,6 +1261,7 @@ _dbus_type_is_valid (int typecode)
>     case DBUS_TYPE_OBJECT_PATH:
>     case DBUS_TYPE_SIGNATURE:
>     case DBUS_TYPE_ARRAY:
>+    case DBUS_TYPE_MAYBE:
>     case DBUS_TYPE_STRUCT:
>     case DBUS_TYPE_DICT_ENTRY:
>     case DBUS_TYPE_VARIANT:
>@@ -1314,6 +1316,8 @@ _dbus_type_to_string (int typecode)
>       return "dict_entry";
>     case DBUS_TYPE_ARRAY:
>       return "array";
>+    case DBUS_TYPE_MAYBE:
>+      return "maybe";
>     case DBUS_TYPE_VARIANT:
>       return "variant";
>     case DBUS_STRUCT_BEGIN_CHAR:
>diff --git a/dbus/dbus-marshal-byteswap.c b/dbus/dbus-marshal-byteswap.c
>index 22d7e22..fadd437 100644
>--- a/dbus/dbus-marshal-byteswap.c
>+++ b/dbus/dbus-marshal-byteswap.c
>@@ -83,6 +83,7 @@ byteswap_body_helper (DBusTypeReader       *reader,
>           break;
> 
>         case DBUS_TYPE_ARRAY:
>+        case DBUS_TYPE_MAYBE:
>         case DBUS_TYPE_STRING:
>         case DBUS_TYPE_OBJECT_PATH:
>           {
>@@ -95,7 +96,7 @@ byteswap_body_helper (DBusTypeReader       *reader,
>             *((dbus_uint32_t*)p) = DBUS_UINT32_SWAP_LE_BE (*((dbus_uint32_t*)p));
>             p += 4;
> 
>-            if (current_type == DBUS_TYPE_ARRAY)
>+            if (DBUS_TYPE_IS_ARRAY (current_type))
>               {
>                 int elem_type;
>                 int alignment;
>diff --git a/dbus/dbus-marshal-header.c b/dbus/dbus-marshal-header.c
>index 3f31d7a..c2b10e6 100644
>--- a/dbus/dbus-marshal-header.c
>+++ b/dbus/dbus-marshal-header.c
>@@ -1099,7 +1099,7 @@ _dbus_header_load (DBusHeader        *header,
>       goto invalid;
>     }
> 
>-  _dbus_assert (_dbus_type_reader_get_current_type (&reader) == DBUS_TYPE_ARRAY);
>+  _dbus_assert (DBUS_TYPE_IS_ARRAY (_dbus_type_reader_get_current_type (&reader)));
>   _dbus_assert (_dbus_type_reader_get_value_pos (&reader) == FIELDS_ARRAY_LENGTH_OFFSET);
> 
>   _dbus_type_reader_recurse (&reader, &array_reader);
>diff --git a/dbus/dbus-marshal-recursive.c b/dbus/dbus-marshal-recursive.c
>index cb10854..512d36d 100644
>--- a/dbus/dbus-marshal-recursive.c
>+++ b/dbus/dbus-marshal-recursive.c
>@@ -340,7 +340,7 @@ _dbus_type_signature_next (const char       *type_str,
>   _dbus_assert (*p != DBUS_STRUCT_END_CHAR);
>   _dbus_assert (*p != DBUS_DICT_ENTRY_END_CHAR);
>   
>-  while (*p == DBUS_TYPE_ARRAY)
>+  while (DBUS_TYPE_IS_ARRAY (*p))
>     ++p;
> 
>   _dbus_assert (*p != DBUS_STRUCT_END_CHAR);
>@@ -463,6 +463,7 @@ base_reader_next (DBusTypeReader *reader,
>       break;
> 
>     case DBUS_TYPE_ARRAY:
>+    case DBUS_TYPE_MAYBE:
>       {
>         if (!reader->klass->types_only)
>           _dbus_marshal_skip_array (reader->value_str,
>@@ -584,6 +585,7 @@ array_reader_next (DBusTypeReader *reader,
>       break;
> 
>     case DBUS_TYPE_ARRAY:
>+    case DBUS_TYPE_MAYBE:
>       {
>         _dbus_marshal_skip_array (reader->value_str,
>                                   _dbus_first_type_in_signature (reader->type_str,
>@@ -809,7 +811,7 @@ _dbus_type_reader_get_element_type (const DBusTypeReader  *reader)
> {
>   int element_type;
> 
>-  _dbus_assert (_dbus_type_reader_get_current_type (reader) == DBUS_TYPE_ARRAY);
>+  _dbus_assert (DBUS_TYPE_IS_ARRAY (_dbus_type_reader_get_current_type (reader)));
> 
>   element_type = _dbus_first_type_in_signature (reader->type_str,
>                                           reader->type_pos + 1);
>@@ -995,6 +997,7 @@ _dbus_type_reader_recurse (DBusTypeReader *reader,
>         sub->klass = &dict_entry_reader_class;
>       break;
>     case DBUS_TYPE_ARRAY:
>+    case DBUS_TYPE_MAYBE:
>       if (reader->klass->types_only)
>         sub->klass = &array_types_only_reader_class;
>       else
>@@ -1632,7 +1635,7 @@ writer_recurse_init_and_check (DBusTypeWriter *writer,
>   sub->container_type = container_type;
> 
>   if (writer->type_pos_is_expectation ||
>-      (sub->container_type == DBUS_TYPE_ARRAY || sub->container_type == DBUS_TYPE_VARIANT))
>+      (DBUS_TYPE_IS_ARRAY (sub->container_type) || sub->container_type == DBUS_TYPE_VARIANT))
>     sub->type_pos_is_expectation = TRUE;
>   else
>     sub->type_pos_is_expectation = FALSE;
>@@ -1733,7 +1736,7 @@ write_or_verify_typecode (DBusTypeWriter *writer,
>        * so the expected type doesn't change; if inside a struct or something
>        * below an array, we need to move through said struct or something.
>        */
>-      if (writer->container_type != DBUS_TYPE_ARRAY)
>+      if (!DBUS_TYPE_IS_ARRAY (writer->container_type))
>         writer->type_pos += 1;
>     }
>   else
>@@ -1791,7 +1794,6 @@ writer_recurse_struct_or_dict_entry (DBusTypeWriter   *writer,
>   return TRUE;
> }
> 
>-
> static dbus_bool_t
> writer_recurse_array (DBusTypeWriter   *writer,
>                       const DBusString *contained_type,
>@@ -1805,7 +1807,7 @@ writer_recurse_array (DBusTypeWriter   *writer,
>   int aligned;
> 
> #ifndef DBUS_DISABLE_CHECKS
>-  if (writer->container_type == DBUS_TYPE_ARRAY &&
>+  if (DBUS_TYPE_IS_ARRAY (writer->container_type) &&
>       writer->type_str)
>     {
>       if (!_dbus_string_equal_substring (contained_type,
>@@ -1865,7 +1867,7 @@ writer_recurse_array (DBusTypeWriter   *writer,
>       /* If the parent is an array, we hold type_pos pointing at the array element type;
>        * otherwise advance it to reflect the array value we just recursed into
>        */
>-      if (writer->container_type != DBUS_TYPE_ARRAY)
>+      if (!DBUS_TYPE_IS_ARRAY (writer->container_type))
>         writer->type_pos += 1 + contained_type_len;
>       else
>         _dbus_assert (writer->type_pos_is_expectation); /* because it's an array */
>@@ -2064,6 +2066,7 @@ _dbus_type_writer_recurse_contained_len (DBusTypeWriter   *writer,
>                                                   sub);
>       break;
>     case DBUS_TYPE_ARRAY:
>+    case DBUS_TYPE_MAYBE:
>       return writer_recurse_array (writer,
>                                    contained_type, contained_type_start, contained_type_len,
>                                    sub, is_array_append);
>@@ -2148,7 +2151,7 @@ _dbus_type_writer_append_array (DBusTypeWriter   *writer,
> static int
> writer_get_array_len (DBusTypeWriter *writer)
> {
>-  _dbus_assert (writer->container_type == DBUS_TYPE_ARRAY);
>+  _dbus_assert (DBUS_TYPE_IS_ARRAY (writer->container_type));
>   return writer->value_pos - writer->u.array.start_pos;
> }
> 
>@@ -2188,7 +2191,7 @@ _dbus_type_writer_unrecurse (DBusTypeWriter *writer,
>       if (!write_or_verify_typecode (sub, DBUS_DICT_ENTRY_END_CHAR))
>         return FALSE;
>     }
>-  else if (sub->container_type == DBUS_TYPE_ARRAY)
>+  else if (DBUS_TYPE_IS_ARRAY (sub->container_type))
>     {
>       if (sub->u.array.len_pos >= 0) /* len_pos == -1 if we weren't enabled when we passed it */
>         {
>@@ -2346,7 +2349,7 @@ _dbus_type_writer_write_fixed_multi (DBusTypeWriter        *writer,
>                                      const void            *value,
>                                      int                    n_elements)
> {
>-  _dbus_assert (writer->container_type == DBUS_TYPE_ARRAY);
>+  _dbus_assert (DBUS_TYPE_IS_ARRAY (writer->container_type));
>   _dbus_assert (dbus_type_is_fixed (element_type));
>   _dbus_assert (writer->type_pos_is_expectation);
>   _dbus_assert (n_elements >= 0);
>@@ -2468,7 +2471,7 @@ writer_write_reader_helper (DBusTypeWriter       *writer,
> 
>           _dbus_type_reader_recurse (reader, &subreader);
> 
>-          if (current_type == DBUS_TYPE_ARRAY)
>+          if (DBUS_TYPE_IS_ARRAY (current_type))
>             {
>               reader_array_len_pos = ARRAY_READER_LEN_POS (&subreader);
>               reader_array_start_pos = subreader.u.array.start_pos;
>@@ -2537,7 +2540,7 @@ writer_write_reader_helper (DBusTypeWriter       *writer,
>            */
>           if (start_after != NULL &&
>               !enabled_at_recurse && past_start_after &&
>-              current_type == DBUS_TYPE_ARRAY &&
>+              DBUS_TYPE_IS_ARRAY (current_type) &&
>               fixups != NULL)
>             {
>               DBusArrayLenFixup fixup;
>diff --git a/dbus/dbus-marshal-validate.c b/dbus/dbus-marshal-validate.c
>index aa470fc..0e01e5b 100644
>--- a/dbus/dbus-marshal-validate.c
>+++ b/dbus/dbus-marshal-validate.c
>@@ -112,6 +112,7 @@ _dbus_validate_signature_with_reason (const DBusString *type_str,
>           break;
> 
>         case DBUS_TYPE_ARRAY:
>+        case DBUS_TYPE_MAYBE:
>           array_depth += 1;
>           if (array_depth > DBUS_MAXIMUM_TYPE_RECURSION_DEPTH)
>             {
>@@ -212,8 +213,8 @@ _dbus_validate_signature_with_reason (const DBusString *type_str,
> 	  goto out;
>         }
> 
>-      if (*p != DBUS_TYPE_ARRAY && 
>-          *p != DBUS_DICT_ENTRY_BEGIN_CHAR && 
>+      if (!DBUS_TYPE_IS_ARRAY (*p) &&
>+	  *p != DBUS_DICT_ENTRY_BEGIN_CHAR && 
> 	  *p != DBUS_STRUCT_BEGIN_CHAR) 
>         {
>           element_count = 
>@@ -231,7 +232,7 @@ _dbus_validate_signature_with_reason (const DBusString *type_str,
>       
>       if (array_depth > 0)
>         {
>-          if (*p == DBUS_TYPE_ARRAY && p != end)
>+          if (DBUS_TYPE_IS_ARRAY (*p) && p != end)
>             {
> 	       const char *p1;
> 	       p1 = p + 1;
>@@ -280,7 +281,7 @@ _dbus_validate_signature_with_reason (const DBusString *type_str,
>       goto out;
>     }
>     
>-  _dbus_assert (last != DBUS_TYPE_ARRAY);
>+  _dbus_assert (!DBUS_TYPE_IS_ARRAY (last));
>   _dbus_assert (last != DBUS_STRUCT_BEGIN_CHAR);
>   _dbus_assert (last != DBUS_DICT_ENTRY_BEGIN_CHAR);
> 
>@@ -354,6 +355,7 @@ validate_body_helper (DBusTypeReader       *reader,
>           break;
> 
>         case DBUS_TYPE_ARRAY:
>+        case DBUS_TYPE_MAYBE:
>         case DBUS_TYPE_STRING:
>         case DBUS_TYPE_OBJECT_PATH:
>           {
>@@ -375,7 +377,7 @@ validate_body_helper (DBusTypeReader       *reader,
>             /* p may now be == end */
>             _dbus_assert (p <= end);
> 
>-            if (current_type == DBUS_TYPE_ARRAY)
>+            if (DBUS_TYPE_IS_ARRAY (current_type))
>               {
>                 int array_elem_type = _dbus_type_reader_get_element_type (reader);
> 
>@@ -423,7 +425,7 @@ validate_body_helper (DBusTypeReader       *reader,
> 
>                 p += claimed_len;
>               }
>-            else if (current_type == DBUS_TYPE_ARRAY && claimed_len > 0)
>+            else if (DBUS_TYPE_IS_ARRAY (current_type) && claimed_len > 0)
>               {
>                 DBusTypeReader sub;
>                 DBusValidity validity;
>@@ -488,7 +490,7 @@ validate_body_helper (DBusTypeReader       *reader,
>               }
> 
>             /* check nul termination */
>-            if (current_type != DBUS_TYPE_ARRAY)
>+            if (!DBUS_TYPE_IS_ARRAY (current_type))
>               {
>                 if (p == end)
>                   return DBUS_INVALID_NOT_ENOUGH_DATA;
>diff --git a/dbus/dbus-message-factory.c b/dbus/dbus-message-factory.c
>index 7432cf2..b414422 100644
>--- a/dbus/dbus-message-factory.c
>+++ b/dbus/dbus-message-factory.c
>@@ -944,6 +944,7 @@ static const int typecodes[] = {
>   DBUS_TYPE_OBJECT_PATH,
>   DBUS_TYPE_SIGNATURE,
>   DBUS_TYPE_ARRAY,
>+  DBUS_TYPE_MAYBE,
>   DBUS_TYPE_VARIANT,
>   DBUS_STRUCT_BEGIN_CHAR,
>   DBUS_STRUCT_END_CHAR,
>diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c
>index 3b5941b..79e7804 100644
>--- a/dbus/dbus-message.c
>+++ b/dbus/dbus-message.c
>@@ -791,7 +791,7 @@ _dbus_message_iter_get_args_valist (DBusMessageIter *iter,
>           _dbus_type_reader_read_basic (&real->u.reader,
>                                         ptr);
>         }
>-      else if (spec_type == DBUS_TYPE_ARRAY)
>+      else if (DBUS_TYPE_IS_ARRAY (spec_type))
>         {
>           int element_type;
>           int spec_element_type;
>@@ -1695,7 +1695,7 @@ dbus_message_append_args_valist (DBusMessage *message,
>                                                value))
>             goto failed;
>         }
>-      else if (type == DBUS_TYPE_ARRAY)
>+      else if (DBUS_TYPE_IS_ARRAY (type))
>         {
>           int element_type;
>           DBusMessageIter array;
>@@ -1705,8 +1705,9 @@ dbus_message_append_args_valist (DBusMessage *message,
>               
>           buf[0] = element_type;
>           buf[1] = '\0';
>+
>           if (!dbus_message_iter_open_container (&iter,
>-                                                 DBUS_TYPE_ARRAY,
>+                                                 type,
>                                                  buf,
>                                                  &array))
>             goto failed;
>@@ -1886,6 +1887,7 @@ _dbus_message_iter_init_common (DBusMessage         *message,
>   real->message = message;
>   real->changed_stamp = message->changed_stamp;
>   real->iter_type = iter_type;
>+
>   real->sig_refcount = 0;
> }
> 
>@@ -2012,7 +2014,7 @@ dbus_message_iter_get_element_type (DBusMessageIter *iter)
> 
>   _dbus_return_val_if_fail (_dbus_message_iter_check (real), DBUS_TYPE_INVALID);
>   _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_READER, DBUS_TYPE_INVALID);
>-  _dbus_return_val_if_fail (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_ARRAY, DBUS_TYPE_INVALID);
>+  _dbus_return_val_if_fail (DBUS_TYPE_IS_ARRAY (dbus_message_iter_get_arg_type (iter)), DBUS_TYPE_INVALID);
> 
>   return _dbus_type_reader_get_element_type (&real->u.reader);
> }
>@@ -2619,7 +2621,8 @@ dbus_message_iter_append_fixed_array (DBusMessageIter *iter,
>   _dbus_return_val_if_fail (_dbus_message_iter_append_check (real), FALSE);
>   _dbus_return_val_if_fail (real->iter_type == DBUS_MESSAGE_ITER_TYPE_WRITER, FALSE);
>   _dbus_return_val_if_fail (dbus_type_is_fixed (element_type) && element_type != DBUS_TYPE_UNIX_FD, FALSE);
>-  _dbus_return_val_if_fail (real->u.writer.container_type == DBUS_TYPE_ARRAY, FALSE);
>+  _dbus_return_val_if_fail (real->u.writer.container_type == DBUS_TYPE_ARRAY
>+    || (real->u.writer.container_type == DBUS_TYPE_MAYBE && n_elements < 2), FALSE);
>   _dbus_return_val_if_fail (value != NULL, FALSE);
>   _dbus_return_val_if_fail (n_elements >= 0, FALSE);
>   _dbus_return_val_if_fail (n_elements <=
>@@ -2672,7 +2675,7 @@ dbus_message_iter_open_container (DBusMessageIter *iter,
>                              contained_signature == NULL) ||
>                             (type == DBUS_TYPE_VARIANT &&
>                              contained_signature != NULL) ||
>-                            (type == DBUS_TYPE_ARRAY &&
>+                            (DBUS_TYPE_IS_ARRAY (type) &&
>                              contained_signature != NULL), FALSE);
>   
>   /* this would fail if the contained_signature is a dict entry, since
>diff --git a/dbus/dbus-protocol.h b/dbus/dbus-protocol.h
>index 17798e9..c0b2cfb 100644
>--- a/dbus/dbus-protocol.h
>+++ b/dbus/dbus-protocol.h
>@@ -120,11 +120,19 @@ extern "C" {
> #define DBUS_TYPE_ARRAY         ((int) 'a')
> /** #DBUS_TYPE_ARRAY as a string literal instead of a int literal */
> #define DBUS_TYPE_ARRAY_AS_STRING          "a"
>+/** Type code marking a D-Bus maybe type */
>+#define DBUS_TYPE_MAYBE         ((int) 'm')
>+/** #DBUS_TYPE_MAYBE as a string literal instead of an int literal */
>+#define DBUS_TYPE_MAYBE_AS_STRING          "m"
> /** Type code marking a D-Bus variant type */
> #define DBUS_TYPE_VARIANT       ((int) 'v')
> /** #DBUS_TYPE_VARIANT as a string literal instead of a int literal */
> #define DBUS_TYPE_VARIANT_AS_STRING        "v"
> 
>+#define DBUS_TYPE_IS_ARRAY(typeliteral) \
>+  (typeliteral == DBUS_TYPE_ARRAY \
>+    || typeliteral == DBUS_TYPE_MAYBE)
>+
> /** STRUCT and DICT_ENTRY are sort of special since their codes can't
>  * appear in a type string, instead
>  * DBUS_STRUCT_BEGIN_CHAR/DBUS_DICT_ENTRY_BEGIN_CHAR have to appear
>diff --git a/dbus/dbus-signature.c b/dbus/dbus-signature.c
>index ddc0bcc..3c763cb 100644
>--- a/dbus/dbus-signature.c
>+++ b/dbus/dbus-signature.c
>@@ -44,7 +44,7 @@ typedef struct
>     ((typecode) == DBUS_TYPE_STRUCT ||          \
>      (typecode) == DBUS_TYPE_DICT_ENTRY ||      \
>      (typecode) == DBUS_TYPE_VARIANT ||         \
>-     (typecode) == DBUS_TYPE_ARRAY)
>+     DBUS_TYPE_IS_ARRAY (typecode))
> 
> 
> /**
>@@ -147,7 +147,7 @@ dbus_signature_iter_get_element_type (const DBusSignatureIter *iter)
> {
>   DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
> 
>-  _dbus_return_val_if_fail (dbus_signature_iter_get_current_type (iter) == DBUS_TYPE_ARRAY, DBUS_TYPE_INVALID);
>+  _dbus_return_val_if_fail (DBUS_TYPE_IS_ARRAY (dbus_signature_iter_get_current_type (iter)), DBUS_TYPE_INVALID);
> 
>   return _dbus_first_type_in_signature_c_str (real_iter->pos, 1);
> }
>@@ -216,7 +216,7 @@ dbus_signature_iter_recurse (const DBusSignatureIter *iter,
>   real_sub_iter->in_array = FALSE;
>   real_sub_iter->pos++;
> 
>-  if (dbus_signature_iter_get_current_type (iter) == DBUS_TYPE_ARRAY)
>+  if (DBUS_TYPE_IS_ARRAY (dbus_signature_iter_get_current_type (iter)))
>     real_sub_iter->in_array = TRUE;
> }
>

Actions: View | Splinter Review

Attachments on bug 27857: 35306 | 35341 | 35454 | 35455 | 35456 | 35457 | 35458 | 35597 | 36154 | 36155 | 41288 | 41289 | 41290 | 41292 | 41294 | 41296

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.