_dbus_verbose (" type reader %p read basic type_pos = %d value_pos = %d next = %d remaining sig '%s'\n",
reader, reader->type_pos, reader->value_pos, next,
_dbus_string_get_const_data_len (reader->type_str, reader->type_pos, 0));
-
- _dbus_verbose_bytes_of_string (reader->value_str,
- reader->value_pos,
- MIN (16,
- _dbus_string_get_length (reader->value_str) - reader->value_pos));
}
else
{
else
{
_dbus_verbose ("recursing into type %s\n", _dbus_type_to_string (t));
+#ifndef DBUS_DISABLE_CHECKS
if (t == DBUS_TYPE_INVALID)
_dbus_warn ("You can't recurse into an empty array or off the end of a message body\n");
+#endif /* DBUS_DISABLE_CHECKS */
_dbus_assert_not_reached ("don't yet handle recursing into this type");
}
}
static void
-skip_array_values (const DBusString *value_str,
+skip_array_values (int element_type,
+ const DBusString *value_str,
int *value_pos,
int byte_order)
{
dbus_uint32_t array_len;
- int len_pos;
+ int pos;
+ int alignment;
- len_pos = _DBUS_ALIGN_VALUE (*value_pos, 4);
+ pos = _DBUS_ALIGN_VALUE (*value_pos, 4);
_dbus_demarshal_basic_type (value_str,
DBUS_TYPE_UINT32,
&array_len,
byte_order,
- &len_pos);
+ &pos);
+
+ alignment = _dbus_type_get_alignment (element_type);
+
+ pos = _DBUS_ALIGN_VALUE (pos, alignment);
- *value_pos = len_pos + array_len;
+ *value_pos = pos + array_len;
}
/**
case DBUS_TYPE_ARRAY:
{
- skip_array_values (reader->value_str, &reader->value_pos, reader->byte_order);
+ skip_array_values (first_type_in_signature (reader->type_str,
+ reader->type_pos + 1),
+ reader->value_str, &reader->value_pos, reader->byte_order);
skip_one_complete_type (reader->type_str, &reader->type_pos);
}
break;
}
else if (reader->u.array.element_type == DBUS_TYPE_ARRAY)
{
- skip_array_values (reader->value_str, &reader->value_pos, reader->byte_order);
+ skip_array_values (first_type_in_signature (reader->type_str,
+ reader->type_pos + 1),
+ reader->value_str, &reader->value_pos, reader->byte_order);
}
else
{
writer->value_pos = value_pos;
writer->container_type = DBUS_TYPE_INVALID;
writer->inside_array = FALSE;
+
+ _dbus_verbose ("writer %p init remaining sig '%s'\n", writer,
+ _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0));
}
static dbus_bool_t
return TRUE;
}
-dbus_bool_t
-_dbus_type_writer_write_basic (DBusTypeWriter *writer,
- int type,
- const void *value)
-{
- dbus_bool_t retval;
-
- /* First ensure that our type realloc will succeed */
- if (!_dbus_string_alloc_space (writer->type_str, 1))
- return FALSE;
-
- retval = FALSE;
-
- if (!_dbus_type_writer_write_basic_no_typecode (writer, type, value))
- goto out;
-
- /* Now insert the type unless we're already covered by the array signature */
- if (!writer->inside_array)
- {
- if (!_dbus_string_insert_byte (writer->type_str,
- writer->type_pos,
- type))
- _dbus_assert_not_reached ("failed to insert byte after prealloc");
-
- writer->type_pos += 1;
- }
-
- retval = TRUE;
-
- out:
- _dbus_verbose (" type writer %p basic type_pos = %d value_pos = %d inside_array = %d\n",
- writer, writer->type_pos, writer->value_pos, writer->inside_array);
-
- return retval;
-}
-
-dbus_bool_t
-_dbus_type_writer_write_array (DBusTypeWriter *writer,
- int type,
- const void *array,
- int array_len)
-{
-
-
-}
-
+/* If our parent is an array, things are a little bit complicated.
+ *
+ * The parent must have a complete element type, such as
+ * "i" or "aai" or "(ii)" or "a(ii)". There can't be
+ * unclosed parens, or an "a" with no following type.
+ *
+ * To recurse, the only allowed operation is to recurse into the
+ * first type in the element type. So for "i" you can't recurse, for
+ * "ai" you can recurse into the array, for "(ii)" you can recurse
+ * into the struct.
+ *
+ * If you recurse into the array for "ai", then you must specify
+ * "i" for the element type of the array you recurse into.
+ *
+ * While inside an array at any level, we need to avoid writing to
+ * type_str, since the type only appears once for the whole array,
+ * it does not appear for each array element.
+ *
+ * While inside an array type_pos points to the expected next
+ * typecode, rather than the next place we could write a typecode.
+ */
static void
writer_recurse_init_and_check (DBusTypeWriter *writer,
int container_type,
- const char *array_element_type,
DBusTypeWriter *sub)
{
_dbus_type_writer_init (sub,
sub->container_type = container_type;
- /* While inside an array, we never want to write to the type str.
- * We are inside an array if we're currently recursing into one.
- */
if (writer->inside_array || sub->container_type == DBUS_TYPE_ARRAY)
sub->inside_array = TRUE;
else
sub->inside_array = FALSE;
-
- /* If our parent is an array, things are a little bit complicated.
- *
- * The parent must have a complete element type, such as
- * "i" or "aai" or "(ii)" or "a(ii)". There can't be
- * unclosed parens, or an "a" with no following type.
- *
- * To recurse, the only allowed operation is to recurse into the
- * first type in the element type. So for "i" you can't recurse, for
- * "ai" you can recurse into the array, for "(ii)" you can recurse
- * into the struct.
- *
- * If you recurse into the array for "ai", then you must specify
- * "i" for the element type of the array you recurse into.
- *
- * While inside an array at any level, we need to avoid writing to
- * type_str, since the type only appears once for the whole array,
- * it does not appear for each array element.
- */
+
#ifndef DBUS_DISABLE_CHECKS
- if (writer->container_type == DBUS_TYPE_ARRAY)
+ if (writer->inside_array)
{
- if ((sub->container_type == DBUS_TYPE_STRUCT &&
- writer->u.array.element_type[0] != DBUS_STRUCT_BEGIN_CHAR) ||
- (sub->container_type != DBUS_TYPE_STRUCT &&
- writer->u.array.element_type[0] != sub->container_type))
- {
- _dbus_warn ("Recursing into an array with element type %s not allowed with container type %s\n",
- writer->u.array.element_type, _dbus_type_to_string (sub->container_type));
- }
+ int expected;
- if (sub->container_type == DBUS_TYPE_ARRAY)
+ expected = first_type_in_signature (writer->type_str, writer->type_pos);
+
+ if (expected != sub->container_type)
{
- DBusString parent_elements;
- DBusString our_elements;
-
- _dbus_assert (writer->u.array.element_type[0] == DBUS_TYPE_ARRAY);
-
- _dbus_string_init_const (&parent_elements, &writer->u.array.element_type[1]);
- _dbus_string_init_const (&our_elements, array_element_type);
-
- if (!_dbus_string_equal (&parent_elements, &our_elements))
- {
- _dbus_warn ("Parent array expects elements '%s' and we are writing an array of '%s'\n",
- writer->u.array.element_type,
- array_element_type);
- }
+ _dbus_warn ("Writing an element of type %s, but the expected type here is %s\n",
+ _dbus_type_to_string (sub->container_type),
+ _dbus_type_to_string (expected));
+ _dbus_assert_not_reached ("bad array element written");
}
}
#endif /* DBUS_DISABLE_CHECKS */
- _dbus_verbose (" type writer %p recurse type_pos = %d value_pos = %d inside_array = %d container_type = %s\n",
+ _dbus_verbose (" type writer %p recurse parent type_pos = %d value_pos = %d inside_array = %d container_type = %s remaining sig '%s'\n",
writer, writer->type_pos, writer->value_pos, writer->inside_array,
- _dbus_type_to_string (writer->container_type));
- _dbus_verbose (" type writer %p new sub type_pos = %d value_pos = %d inside_array = %d container_type = %s element_type = '%s'\n",
+ _dbus_type_to_string (writer->container_type),
+ _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0));
+ _dbus_verbose (" type writer %p recurse sub type_pos = %d value_pos = %d inside_array = %d container_type = %s\n",
sub, sub->type_pos, sub->value_pos,
sub->inside_array,
- _dbus_type_to_string (sub->container_type),
- array_element_type ? array_element_type : "n/a");
+ _dbus_type_to_string (sub->container_type));
+}
+
+static dbus_bool_t
+write_or_verify_typecode (DBusTypeWriter *writer,
+ int typecode)
+{
+ /* A subwriter inside an array will have type_pos pointing to the
+ * expected typecode; a writer not inside an array has type_pos
+ * pointing to the next place to insert a typecode.
+ */
+ _dbus_verbose (" type writer %p write_or_verify start type_pos = %d remaining sig '%s'\n",
+ writer, writer->type_pos,
+ _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0));
+
+ if (writer->inside_array)
+ {
+#ifndef DBUS_DISABLE_CHECKS
+ {
+ int expected;
+
+ expected = _dbus_string_get_byte (writer->type_str, writer->type_pos);
+
+ if (expected != typecode)
+ {
+ _dbus_warn ("Array type requires that type %s be written, but %s was written\n",
+ _dbus_type_to_string (expected), _dbus_type_to_string (typecode));
+ _dbus_assert_not_reached ("bad type inserted somewhere inside an array");
+ }
+ }
+#endif /* DBUS_DISABLE_CHECKS */
+
+ /* if immediately inside an array we'd always be appending an element,
+ * 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)
+ writer->type_pos += 1;
+ }
+ else
+ {
+ if (!_dbus_string_insert_byte (writer->type_str,
+ writer->type_pos,
+ typecode))
+ return FALSE;
+
+ writer->type_pos += 1;
+ }
+
+ _dbus_verbose (" type writer %p write_or_verify end type_pos = %d remaining sig '%s'\n",
+ writer, writer->type_pos,
+ _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0));
+
+ return TRUE;
}
dbus_bool_t
int container_type,
DBusTypeWriter *sub)
{
- writer_recurse_init_and_check (writer, container_type, NULL, sub);
+ writer_recurse_init_and_check (writer, container_type, sub);
switch (container_type)
{
case DBUS_TYPE_STRUCT:
{
- if (!writer->inside_array)
- {
- /* Ensure that we'll be able to add alignment padding */
- if (!_dbus_string_alloc_space (sub->value_str, 8))
- return FALSE;
-
- if (!_dbus_string_insert_byte (sub->type_str,
- sub->type_pos,
- DBUS_STRUCT_BEGIN_CHAR))
- return FALSE;
-
- sub->type_pos += 1;
- }
+ /* Ensure that we'll be able to add alignment padding and the typecode */
+ if (!_dbus_string_alloc_space (sub->value_str, 8))
+ return FALSE;
+ if (!write_or_verify_typecode (sub, DBUS_STRUCT_BEGIN_CHAR))
+ _dbus_assert_not_reached ("failed to insert struct typecode after prealloc");
+
if (!_dbus_string_insert_bytes (sub->value_str,
sub->value_pos,
_DBUS_ALIGN_VALUE (sub->value_pos, 8) - sub->value_pos,
{
int element_type_len;
DBusString element_type_str;
+ dbus_uint32_t value = 0;
+ int alignment;
+ int aligned;
+ DBusString str;
- writer_recurse_init_and_check (writer, DBUS_TYPE_ARRAY, element_type, sub);
+ writer_recurse_init_and_check (writer, DBUS_TYPE_ARRAY, sub);
+
+#ifndef DBUS_DISABLE_CHECKS
+ if (writer->container_type == DBUS_TYPE_ARRAY)
+ {
+ DBusString parent_elements;
+ _dbus_assert (element_type != NULL);
+
+ _dbus_string_init_const (&parent_elements,
+ _dbus_string_get_const_data_len (writer->type_str,
+ writer->u.array.element_type_pos + 1,
+ 0));
+
+ if (!_dbus_string_starts_with_c_str (&parent_elements, element_type))
+ {
+ _dbus_warn ("Writing an array of '%s' but this is incompatible with the expected type of elements in the parent array\n",
+ element_type);
+ _dbus_assert_not_reached ("incompatible type for child array");
+ }
+ }
+#endif /* DBUS_DISABLE_CHECKS */
+
_dbus_string_init_const (&element_type_str, element_type);
element_type_len = _dbus_string_get_length (&element_type_str);
if (!_dbus_string_alloc_space (sub->value_str, 8))
return FALSE;
+ sub->type_pos += 1; /* move to point to the element type, since type_pos
+ * should be the expected type for further writes
+ */
+ sub->u.array.element_type_pos = sub->type_pos;
+ sub->u.array.element_type_len = element_type_len;
+
if (!writer->inside_array)
{
+ /* sub is a toplevel/outermost array so we need to write the type data */
+
/* alloc space for array typecode, element signature, possible 7
* bytes of padding
*/
- if (!_dbus_string_alloc_space (sub->type_str, 1 + element_type_len + 7))
+ if (!_dbus_string_alloc_space (writer->type_str, 1 + element_type_len + 7))
return FALSE;
- }
-
- if (!_dbus_string_copy_data (&element_type_str,
- &sub->u.array.element_type))
- return FALSE;
- if (!writer->inside_array)
- {
- if (!_dbus_string_insert_byte (sub->type_str,
- sub->type_pos,
+ if (!_dbus_string_insert_byte (writer->type_str,
+ writer->type_pos,
DBUS_TYPE_ARRAY))
- _dbus_assert_not_reached ("should not have failed to insert array typecode");
+ _dbus_assert_not_reached ("failed to insert array typecode after prealloc");
- sub->type_pos += 1;
-
if (!_dbus_string_copy (&element_type_str, 0,
- sub->type_str, sub->type_pos))
+ sub->type_str, sub->u.array.element_type_pos))
_dbus_assert_not_reached ("should not have failed to insert array element typecodes");
-
- sub->type_pos += element_type_len;
}
-
+
+ /* Write the length */
sub->u.array.len_pos = _DBUS_ALIGN_VALUE (sub->value_pos, 4);
- {
- dbus_uint32_t value = 0;
- int alignment;
- int aligned;
- DBusString str;
-
- if (!_dbus_type_writer_write_basic_no_typecode (sub, DBUS_TYPE_UINT32,
- &value))
- _dbus_assert_not_reached ("should not have failed to insert array len");
-
- _dbus_assert (sub->u.array.len_pos == sub->value_pos - 4);
-
- _dbus_string_init_const (&str, element_type);
- alignment = element_type_get_alignment (&str, 0);
-
- aligned = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
- if (aligned != sub->value_pos)
- {
- if (!_dbus_string_insert_bytes (sub->value_str,
- sub->value_pos,
- aligned - sub->value_pos,
- '\0'))
- _dbus_assert_not_reached ("should not have failed to insert alignment padding");
+ if (!_dbus_type_writer_write_basic_no_typecode (sub, DBUS_TYPE_UINT32,
+ &value))
+ _dbus_assert_not_reached ("should not have failed to insert array len");
+
+ _dbus_assert (sub->u.array.len_pos == sub->value_pos - 4);
- sub->value_pos = aligned;
- }
- sub->u.array.start_pos = sub->value_pos;
- }
+ /* Write alignment padding for array elements */
+ _dbus_string_init_const (&str, element_type);
+ alignment = element_type_get_alignment (&str, 0);
+
+ aligned = _DBUS_ALIGN_VALUE (sub->value_pos, alignment);
+ if (aligned != sub->value_pos)
+ {
+ if (!_dbus_string_insert_bytes (sub->value_str,
+ sub->value_pos,
+ aligned - sub->value_pos,
+ '\0'))
+ _dbus_assert_not_reached ("should not have failed to insert alignment padding");
+
+ sub->value_pos = aligned;
+ }
+ sub->u.array.start_pos = sub->value_pos;
_dbus_assert (sub->u.array.start_pos == sub->value_pos);
_dbus_assert (sub->u.array.len_pos < sub->u.array.start_pos);
-
- /* value_pos now points to the place for array data, and len_pos to the length */
+ _dbus_verbose (" type writer %p recurse array done remaining sig '%s'\n", sub,
+ _dbus_string_get_const_data_len (sub->type_str, sub->type_pos, 0));
+
return TRUE;
}
_dbus_verbose (" type writer %p unrecurse type_pos = %d value_pos = %d inside_array = %d container_type = %s\n",
writer, writer->type_pos, writer->value_pos, writer->inside_array,
_dbus_type_to_string (writer->container_type));
- _dbus_verbose (" type writer %p unrecurse sub type_pos = %d value_pos = %d inside_array = %d container_type = %s element_type = '%s'\n",
+ _dbus_verbose (" type writer %p unrecurse sub type_pos = %d value_pos = %d inside_array = %d container_type = %s\n",
sub, sub->type_pos, sub->value_pos,
sub->inside_array,
- _dbus_type_to_string (sub->container_type),
- sub->container_type == DBUS_TYPE_ARRAY ?
- sub->u.array.element_type : "n/a");
+ _dbus_type_to_string (sub->container_type));
if (sub->container_type == DBUS_TYPE_STRUCT)
{
- if (!sub->inside_array)
- {
- if (!_dbus_string_insert_byte (sub->type_str,
- sub->type_pos,
- DBUS_STRUCT_END_CHAR))
- return FALSE;
- sub->type_pos += 1;
- }
+ if (!write_or_verify_typecode (sub, DBUS_STRUCT_END_CHAR))
+ return FALSE;
}
else if (sub->container_type == DBUS_TYPE_ARRAY)
{
dbus_uint32_t len;
-
- dbus_free (sub->u.array.element_type);
- sub->u.array.element_type = NULL;
/* Set the array length */
len = sub->value_pos - sub->u.array.start_pos;
}
/* Jump the parent writer to the new location */
- writer->type_pos = sub->type_pos;
+ if (!writer->inside_array)
+ {
+ if (sub->inside_array)
+ {
+ /* Transition back to type_pos = insertion point from type_pos = expected */
+
+ _dbus_assert (sub->container_type == DBUS_TYPE_ARRAY);
+ writer->type_pos = sub->u.array.element_type_pos + sub->u.array.element_type_len;
+ }
+ else
+ {
+ writer->type_pos = sub->type_pos;
+ }
+ }
writer->value_pos = sub->value_pos;
+
+
+ _dbus_verbose (" type writer %p unrecursed type_pos = %d value_pos = %d remaining sig '%s'\n",
+ writer, writer->type_pos, writer->value_pos,
+ _dbus_string_get_const_data_len (writer->type_str, writer->type_pos, 0));
return TRUE;
}
+dbus_bool_t
+_dbus_type_writer_write_basic (DBusTypeWriter *writer,
+ int type,
+ const void *value)
+{
+ dbus_bool_t retval;
+
+ /* First ensure that our type realloc will succeed */
+ if (!_dbus_string_alloc_space (writer->type_str, 1))
+ return FALSE;
+
+ retval = FALSE;
+
+ if (!_dbus_type_writer_write_basic_no_typecode (writer, type, value))
+ goto out;
+
+ if (!write_or_verify_typecode (writer, type))
+ _dbus_assert_not_reached ("failed to write typecode after prealloc");
+
+ retval = TRUE;
+
+ out:
+ _dbus_verbose (" type writer %p basic type_pos = %d value_pos = %d inside_array = %d\n",
+ writer, writer->type_pos, writer->value_pos, writer->inside_array);
+
+ return retval;
+}
+
+dbus_bool_t
+_dbus_type_writer_write_array (DBusTypeWriter *writer,
+ int type,
+ const void *array,
+ int array_len)
+{
+
+
+}
+
/** @} */ /* end of DBusMarshal group */
#ifdef DBUS_BUILD_TESTS
_dbus_string_get_length (&block->body));
}
-#define NEXT_EXPECTING_TRUE(reader) do { if (!_dbus_type_reader_next (reader)) \
- { \
- _dbus_warn ("_dbus_type_reader_next() should have returned TRUE at %s %d", \
- _DBUS_FUNCTION_NAME, __LINE__); \
- _dbus_assert_not_reached ("test failed"); \
- } \
+#define NEXT_EXPECTING_TRUE(reader) do { if (!_dbus_type_reader_next (reader)) \
+ { \
+ _dbus_warn ("_dbus_type_reader_next() should have returned TRUE at %s %d\n", \
+ _DBUS_FUNCTION_NAME, __LINE__); \
+ _dbus_assert_not_reached ("test failed"); \
+ } \
} while (0)
-#define NEXT_EXPECTING_FALSE(reader) do { if (_dbus_type_reader_next (reader)) \
- { \
- _dbus_warn ("_dbus_type_reader_next() should have returned FALSE at %s %d", \
- _DBUS_FUNCTION_NAME, __LINE__); \
- _dbus_assert_not_reached ("test failed"); \
- } \
- check_expected_type (reader, DBUS_TYPE_INVALID); \
+#define NEXT_EXPECTING_FALSE(reader) do { if (_dbus_type_reader_next (reader)) \
+ { \
+ _dbus_warn ("_dbus_type_reader_next() should have returned FALSE at %s %d\n", \
+ _DBUS_FUNCTION_NAME, __LINE__); \
+ _dbus_assert_not_reached ("test failed"); \
+ } \
+ check_expected_type (reader, DBUS_TYPE_INVALID); \
} while (0)
#define SAMPLE_INT32 12345678
_dbus_type_to_string (t),
_dbus_type_to_string (expected),
funcname, line);
-
- _dbus_verbose_bytes_of_string (reader->type_str, 0,
- _dbus_string_get_length (reader->type_str));
- _dbus_verbose_bytes_of_string (reader->value_str, 0,
- _dbus_string_get_length (reader->value_str));
exit (1);
}
}
static dbus_bool_t
-write_struct_with_int32s (DataBlock *block,
- DBusTypeWriter *writer)
+write_struct_of_int32 (DataBlock *block,
+ DBusTypeWriter *writer)
{
dbus_int32_t v;
DataBlockState saved;
}
static dbus_bool_t
-read_struct_with_int32s (DataBlock *block,
- DBusTypeReader *reader)
+read_struct_of_int32 (DataBlock *block,
+ DBusTypeReader *reader)
{
dbus_int32_t v;
DBusTypeReader sub;
&sub))
return FALSE;
- if (!write_struct_with_int32s (block, &sub))
+ if (!write_struct_of_int32 (block, &sub))
{
data_block_restore (block, &saved);
return FALSE;
}
- if (!write_struct_with_int32s (block, &sub))
+ if (!write_struct_of_int32 (block, &sub))
{
data_block_restore (block, &saved);
return FALSE;
}
- if (!write_struct_with_int32s (block, &sub))
+ if (!write_struct_of_int32 (block, &sub))
{
data_block_restore (block, &saved);
return FALSE;
_dbus_type_reader_recurse (reader, &sub);
- if (!read_struct_with_int32s (block, &sub))
+ if (!read_struct_of_int32 (block, &sub))
return FALSE;
NEXT_EXPECTING_TRUE (&sub);
- if (!read_struct_with_int32s (block, &sub))
+ if (!read_struct_of_int32 (block, &sub))
return FALSE;
NEXT_EXPECTING_TRUE (&sub);
- if (!read_struct_with_int32s (block, &sub))
+ if (!read_struct_of_int32 (block, &sub))
return FALSE;
NEXT_EXPECTING_FALSE (&sub);
return TRUE;
}
+static dbus_bool_t
+write_struct_of_array_of_int32 (DataBlock *block,
+ DBusTypeWriter *writer)
+{
+ DataBlockState saved;
+ DBusTypeWriter sub;
+
+ data_block_save (block, &saved);
+
+ if (!_dbus_type_writer_recurse (writer,
+ DBUS_TYPE_STRUCT,
+ &sub))
+ return FALSE;
+
+ if (!write_array_of_int32 (block, &sub))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ if (!write_array_of_int32_empty (block, &sub))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ if (!_dbus_type_writer_unrecurse (writer, &sub))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static dbus_bool_t
+read_struct_of_array_of_int32 (DataBlock *block,
+ DBusTypeReader *reader)
+{
+ DBusTypeReader sub;
+
+ check_expected_type (reader, DBUS_TYPE_STRUCT);
+
+ _dbus_type_reader_recurse (reader, &sub);
+
+ check_expected_type (&sub, DBUS_TYPE_ARRAY);
+
+ if (!read_array_of_int32 (block, &sub))
+ return FALSE;
+
+ NEXT_EXPECTING_TRUE (&sub);
+ if (!read_array_of_int32_empty (block, &sub))
+ return FALSE;
+
+ NEXT_EXPECTING_FALSE (&sub);
+
+ return TRUE;
+}
+
+static dbus_bool_t
+write_array_of_struct_of_int32 (DataBlock *block,
+ DBusTypeWriter *writer)
+{
+ DataBlockState saved;
+ DBusTypeWriter sub;
+
+ data_block_save (block, &saved);
+
+ if (!_dbus_type_writer_recurse_array (writer,
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_INT32_AS_STRING
+ DBUS_TYPE_INT32_AS_STRING
+ DBUS_STRUCT_END_CHAR_AS_STRING,
+ &sub))
+ return FALSE;
+
+ if (!write_struct_of_int32 (block, &sub))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ if (!write_struct_of_int32 (block, &sub))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ if (!write_struct_of_int32 (block, &sub))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ if (!_dbus_type_writer_unrecurse (writer, &sub))
+ {
+ data_block_restore (block, &saved);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static dbus_bool_t
+read_array_of_struct_of_int32 (DataBlock *block,
+ DBusTypeReader *reader)
+{
+ DBusTypeReader sub;
+
+ check_expected_type (reader, DBUS_TYPE_ARRAY);
+
+ _dbus_type_reader_recurse (reader, &sub);
+
+ check_expected_type (&sub, DBUS_TYPE_STRUCT);
+
+ if (!read_struct_of_int32 (block, &sub))
+ return FALSE;
+
+ NEXT_EXPECTING_TRUE (&sub);
+
+ if (!read_struct_of_int32 (block, &sub))
+ return FALSE;
+
+ NEXT_EXPECTING_TRUE (&sub);
+
+ if (!read_struct_of_int32 (block, &sub))
+ return FALSE;
+
+ NEXT_EXPECTING_FALSE (&sub);
+
+ return TRUE;
+}
+
typedef enum {
ITEM_INVALID = -1,
ITEM_INT32 = 0,
- ITEM_STRUCT_WITH_INT32S,
+ ITEM_STRUCT_OF_INT32,
ITEM_STRUCT_OF_STRUCTS,
ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS,
ITEM_ARRAY_OF_INT32,
ITEM_ARRAY_OF_ARRAY_OF_INT32,
ITEM_ARRAY_OF_ARRAY_OF_INT32_EMPTY,
ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32,
+ ITEM_STRUCT_OF_ARRAY_OF_INT32,
+ ITEM_ARRAY_OF_STRUCT_OF_INT32,
ITEM_LAST
} WhichItem;
{ "int32",
ITEM_INT32, write_int32, read_int32 },
{ "struct with two int32",
- ITEM_STRUCT_WITH_INT32S, write_struct_with_int32s, read_struct_with_int32s },
+ ITEM_STRUCT_OF_INT32, write_struct_of_int32, read_struct_of_int32 },
{ "struct with three structs of two int32",
ITEM_STRUCT_OF_STRUCTS, write_struct_of_structs, read_struct_of_structs },
{ "struct of two structs of three structs of two int32",
write_array_of_array_of_int32_empty, read_array_of_array_of_int32_empty },
{ "array of array of array of int32",
ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32,
- write_array_of_array_of_array_of_int32, read_array_of_array_of_array_of_int32 }
+ write_array_of_array_of_array_of_int32, read_array_of_array_of_array_of_int32 },
+ { "struct of array of int32",
+ ITEM_STRUCT_OF_ARRAY_OF_INT32, write_struct_of_array_of_int32, read_struct_of_array_of_int32 },
+ { "array of struct of int32",
+ ITEM_ARRAY_OF_STRUCT_OF_INT32, write_array_of_struct_of_int32, read_array_of_struct_of_int32 },
};
typedef struct
{ { ITEM_INT32, ITEM_INT32, ITEM_INVALID } },
{ { ITEM_INT32, ITEM_INT32, ITEM_INT32, ITEM_INT32, ITEM_INT32, ITEM_INVALID } },
- /* STRUCT_WITH_INT32S */
- { { ITEM_STRUCT_WITH_INT32S, ITEM_INVALID } },
- { { ITEM_STRUCT_WITH_INT32S, ITEM_STRUCT_WITH_INT32S, ITEM_INVALID } },
- { { ITEM_STRUCT_WITH_INT32S, ITEM_INT32, ITEM_STRUCT_WITH_INT32S, ITEM_INVALID } },
- { { ITEM_INT32, ITEM_STRUCT_WITH_INT32S, ITEM_INT32, ITEM_STRUCT_WITH_INT32S, ITEM_INVALID } },
- { { ITEM_INT32, ITEM_STRUCT_WITH_INT32S, ITEM_INT32, ITEM_INT32, ITEM_INT32, ITEM_STRUCT_WITH_INT32S, ITEM_INVALID } },
+ /* STRUCT_OF_INT32 */
+ { { ITEM_STRUCT_OF_INT32, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_INT32, ITEM_STRUCT_OF_INT32, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_INT32, ITEM_INT32, ITEM_STRUCT_OF_INT32, ITEM_INVALID } },
+ { { ITEM_INT32, ITEM_STRUCT_OF_INT32, ITEM_INT32, ITEM_STRUCT_OF_INT32, ITEM_INVALID } },
+ { { ITEM_INT32, ITEM_STRUCT_OF_INT32, ITEM_INT32, ITEM_INT32, ITEM_INT32, ITEM_STRUCT_OF_INT32, ITEM_INVALID } },
/* STRUCT_OF_STRUCTS */
{ { ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_STRUCT_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_STRUCT_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } },
- { { ITEM_STRUCT_WITH_INT32S, ITEM_STRUCT_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_STRUCT_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
- { { ITEM_STRUCT_WITH_INT32S, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } },
{ { ITEM_INT32, ITEM_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
- { { ITEM_STRUCT_WITH_INT32S, ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } },
{ { ITEM_ARRAY_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_INT32, ITEM_INVALID } },
/* ARRAY_OF_ARRAY_OF_INT32 */
{ { ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
{ { ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
- { { ITEM_STRUCT_WITH_INT32S, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
{ { ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
/* ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32 */
{ { ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
{ { ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
{ { ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_STRUCTS_OF_STRUCTS, ITEM_INVALID } },
- { { ITEM_STRUCT_WITH_INT32S, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
- { { ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } }
-
+ { { ITEM_STRUCT_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_ARRAY_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+
+ /* STRUCT_OF_ARRAY_OF_INT32 */
+ { { ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_STRUCT_OF_ARRAY_OF_INT32, ITEM_INVALID } },
+
+ /* ARRAY_OF_STRUCT_OF_INT32 */
+ { { ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } },
+ { { ITEM_STRUCT_OF_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } },
+ { { ITEM_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } },
+ { { ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_ARRAY_OF_STRUCT_OF_INT32, ITEM_INVALID } }
};
{
CheckMarshalItem *item = &items[run->items[i]];
+ _dbus_verbose (">>data for reading %s\n", item->desc);
+
+ _dbus_verbose_bytes_of_string (reader.type_str, 0,
+ _dbus_string_get_length (reader.type_str));
+ _dbus_verbose_bytes_of_string (reader.value_str, 0,
+ _dbus_string_get_length (reader.value_str));
+
_dbus_verbose (">>reading %s\n", item->desc);
if (!(* item->read_item_func) (block, &reader))
projects / platform / upstream / dbus.git / commitdiff